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 811 by gezelter, Thu Dec 15 14:47:17 2005 UTC vs.
Revision 956 by gezelter, Tue May 16 02:06:37 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_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 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 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 LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_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-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877 –  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884    --with-zlib=DIR root directory path of zlib installation defaults to
885                      /usr/local or /usr if not found in /usr/local
886    --without-zlib to disable zlib usage completely
887 <  --with-perl-shebang     override what perl thinks is the way for the kernel
886 <                          to start it (seldom needed)
887 >  --without-fftw          if you turn this off you cannot compute undulation spectra
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889    --with-cgal-makefile=FILE  CGAL makefile that should be used
890  
891   Some influential environment variables:
892 <  CC          C compiler command
893 <  CFLAGS      C compiler flags
892 >  CXX         C++ compiler command
893 >  CXXFLAGS    C++ compiler flags
894    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895                nonstandard directory <lib dir>
896    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897                headers in a nonstandard directory <include dir>
898 <  CXX         C++ compiler command
899 <  CXXFLAGS    C++ compiler flags
898 >  CC          C compiler command
899 >  CFLAGS      C compiler flags
900 >  FC          Fortran compiler command
901 >  FCFLAGS     Fortran compiler flags
902    CPP         C preprocessor
900 –  F90         Fortran 90 compiler command
901 –  F90FLAGS    Fortran 90 compiler flags
903    CXXCPP      C++ preprocessor
904  
905   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1001 | if $ac_init_version; then
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1004 > OOPSE configure 3.0
1005   generated by GNU Autoconf 2.59
1006  
1007   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1015 | running configure, to aid debugging if configure makes
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1018 > It was created by OOPSE $as_me 3.0, which was
1019   generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
# Line 1376 | Line 1377 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1378  
1379  
1380 < # 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 < # ------------------------ #
1556 <
1557 < # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 < # --------------------------------
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
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  
1410  
1646 – # ---------------------------------------- #
1647 – # 4b. Fortan 90 compiler characteristics.  #
1648 – # ---------------------------------------- #
1411  
1412  
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
1413  
1414  
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
1415  
1416  
1417 < # AC_F90_LIBRARY_LDFLAGS
1418 < # ----------------------
1419 < #
1420 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1421 < # intrinsic and run-time libraries that are required to successfully
1422 < # link a Fortran 90 program or shared library.  The output variable
1423 < # 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
1417 > # ACX_CHECK_FFTW()
1418 > # ----------------
1419 > # This macro checks for fftw header files and libraries,
1420 > # including the possible prefixing with s or d to determine precision.
1421 > # Arg 1 is the fftw header/library name to check for, without
1422 > # prefix or anything else (e.g. rfftw_mpi for real MPI transforms)
1423 > # Arg 2 is the size of the real variable used.
1424  
1425  
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
1426  
1717 – # The replacement is empty.
1427  
1428  
1429  
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
1430  
1431  
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
1432  
1433  
1738 – # ---------------------------------------- #
1739 – # 4c. Fortan 95 compiler characteristics.  #
1740 – # ---------------------------------------- #
1434  
1435  
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
1752 –
1753 –
1754 – # _AC_PROG_F95_V
1755 – # --------------
1436   #
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
1762 –
1763 –
1764 – # AC_F95_LIBRARY_LDFLAGS
1765 – # ----------------------
1437   #
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.
1438   #
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
1439  
1440  
1792 – # _AC_F95_NAME_MANGLING
1793 – # ---------------------
1794 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 – #
1796 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 – # by commas:
1798 – #
1799 – # lower case / upper case:
1800 – #    case translation of the Fortan 95 symbols
1801 – # underscore / no underscore:
1802 – #    whether the compiler appends "_" to symbol names
1803 – # extra underscore / no extra underscore:
1804 – #    whether the compiler appends an extra "_" to symbol names already
1805 – #    containing at least one underscore
1806 – #
1807 – # _AC_F95_NAME_MANGLING
1808 –
1809 – # The replacement is empty.
1810 –
1811 –
1812 –
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
1820 –
1821 –
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 –
1441   # AC_F90_MODULE_NAMES
1442   # -------------------
1443   #
# Line 1868 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480  
1481  
1482  
1871 –
1872 –
1873 –
1874 –
1875 –
1876 –
1877 –
1878 –
1879 –
1880 –
1881 –
1882 –
1883 –
1884 –
1885 –
1886 –
1887 –
1888 – #
1889 – #
1890 – #
1891 –
1892 –
1893 –
1894 –
1895 –
1896 –
1897 –
1898 –
1899 –
1900 –
1901 –
1902 –
1903 –
1904 –
1905 –
1906 –
1907 –
1908 –
1909 –
1910 –
1911 –
1912 –
1913 –
1914 –
1915 –
1916 –
1917 –
1918 –
1919 –
1920 –
1921 –
1922 –
1923 –
1924 –
1925 –
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 –
1483   # who am i
1484   # Make sure we can run config.sub.
1485   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 2011 | Line 1538 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1538  
1539  
1540  
1541 < ac_ext=c
1542 < ac_cpp='$CPP $CPPFLAGS'
1543 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1544 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1545 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1541 > # set program name
1542 > PROGNAME="oopse"
1543 >
1544 >
1545 >
1546 >
1547 > OBJEXT=".$OBJEXT"
1548 >
1549 > OOPSE=oopse
1550 >
1551 > if test "x${prefix}" = "xNONE"
1552 > then
1553 >  OOPSE_HOME=${ac_default_prefix}/oopse
1554 > else
1555 >  OOPSE_HOME=${prefix}/oopse
1556 > fi
1557 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1558 > if test "${enable_oopse_home+set}" = set; then
1559 >  enableval="$enable_oopse_home"
1560 >  OOPSE_HOME="${enableval}"
1561 > fi;
1562 >
1563 > # there are two ways to do debugging.  One with the --enable-debug flag
1564 > # and one using the DEBUG environment variable
1565 >
1566 > debug=0
1567 > # Check whether --enable-debug or --disable-debug was given.
1568 > if test "${enable_debug+set}" = set; then
1569 >  enableval="$enable_debug"
1570 >  debug=1
1571 > fi;
1572 > if test "${DEBUG}"; then
1573 >
1574 > cat >>confdefs.h <<\_ACEOF
1575 > #define debug 1
1576 > _ACEOF
1577 >
1578 >  msg="$msg, debug mode"
1579 > fi
1580 >
1581 >
1582 > # Checks for programs.
1583 > ac_ext=cc
1584 > ac_cpp='$CXXCPP $CPPFLAGS'
1585 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1586 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1587 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1588   if test -n "$ac_tool_prefix"; then
1589 <  for ac_prog in pathcc icc xlc gcc cc
1589 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1590    do
1591      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1592   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1593   echo "$as_me:$LINENO: checking for $ac_word" >&5
1594   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1595 < if test "${ac_cv_prog_CC+set}" = set; then
1595 > if test "${ac_cv_prog_CXX+set}" = set; then
1596    echo $ECHO_N "(cached) $ECHO_C" >&6
1597   else
1598 <  if test -n "$CC"; then
1599 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1598 >  if test -n "$CXX"; then
1599 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1600   else
1601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1602   for as_dir in $PATH
# Line 2036 | Line 1605 | do
1605    test -z "$as_dir" && as_dir=.
1606    for ac_exec_ext in '' $ac_executable_extensions; do
1607    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1608 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1608 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1609      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1610      break 2
1611    fi
# Line 2045 | Line 1614 | fi
1614  
1615   fi
1616   fi
1617 < CC=$ac_cv_prog_CC
1618 < if test -n "$CC"; then
1619 <  echo "$as_me:$LINENO: result: $CC" >&5
1620 < echo "${ECHO_T}$CC" >&6
1617 > CXX=$ac_cv_prog_CXX
1618 > if test -n "$CXX"; then
1619 >  echo "$as_me:$LINENO: result: $CXX" >&5
1620 > echo "${ECHO_T}$CXX" >&6
1621   else
1622    echo "$as_me:$LINENO: result: no" >&5
1623   echo "${ECHO_T}no" >&6
1624   fi
1625  
1626 <    test -n "$CC" && break
1626 >    test -n "$CXX" && break
1627    done
1628   fi
1629 < if test -z "$CC"; then
1630 <  ac_ct_CC=$CC
1631 <  for ac_prog in pathcc icc xlc gcc cc
1629 > if test -z "$CXX"; then
1630 >  ac_ct_CXX=$CXX
1631 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1632   do
1633    # Extract the first word of "$ac_prog", so it can be a program name with args.
1634   set dummy $ac_prog; ac_word=$2
1635   echo "$as_me:$LINENO: checking for $ac_word" >&5
1636   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1637 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1637 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1638    echo $ECHO_N "(cached) $ECHO_C" >&6
1639   else
1640 <  if test -n "$ac_ct_CC"; then
1641 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1640 >  if test -n "$ac_ct_CXX"; then
1641 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1642   else
1643   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644   for as_dir in $PATH
# Line 2078 | Line 1647 | do
1647    test -z "$as_dir" && as_dir=.
1648    for ac_exec_ext in '' $ac_executable_extensions; do
1649    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1650 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1650 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1651      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1652      break 2
1653    fi
# Line 2087 | Line 1656 | fi
1656  
1657   fi
1658   fi
1659 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1660 < if test -n "$ac_ct_CC"; then
1661 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1662 < echo "${ECHO_T}$ac_ct_CC" >&6
1659 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1660 > if test -n "$ac_ct_CXX"; then
1661 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1662 > echo "${ECHO_T}$ac_ct_CXX" >&6
1663   else
1664    echo "$as_me:$LINENO: result: no" >&5
1665   echo "${ECHO_T}no" >&6
1666   fi
1667  
1668 <  test -n "$ac_ct_CC" && break
1668 >  test -n "$ac_ct_CXX" && break
1669   done
1670 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1671  
1672 <  CC=$ac_ct_CC
1672 >  CXX=$ac_ct_CXX
1673   fi
1674  
1675  
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 –
1676   # Provide some information about the compiler.
1677   echo "$as_me:$LINENO:" \
1678 <     "checking for C compiler version" >&5
1678 >     "checking for C++ compiler version" >&5
1679   ac_compiler=`set X $ac_compile; echo $2`
1680   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1681    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2149 | Line 1713 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1713   # Try to create an executable without -o first, disregard a.out.
1714   # It will help us diagnose broken compilers, and finding out an intuition
1715   # of exeext.
1716 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1717 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1716 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1717 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1718   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1719   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1720    (eval $ac_link_default) 2>&5
# Line 2193 | Line 1757 | sed 's/^/| /' conftest.$ac_ext >&5
1757    echo "$as_me: failed program was:" >&5
1758   sed 's/^/| /' conftest.$ac_ext >&5
1759  
1760 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1760 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1761   See \`config.log' for more details." >&5
1762 < echo "$as_me: error: C compiler cannot create executables
1762 > echo "$as_me: error: C++ compiler cannot create executables
1763   See \`config.log' for more details." >&2;}
1764     { (exit 77); exit 77; }; }
1765   fi
# Line 2206 | Line 1770 | echo "${ECHO_T}$ac_file" >&6
1770  
1771   # Check the compiler produces executables we can run.  If not, either
1772   # the compiler is broken, or we cross compile.
1773 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1774 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1773 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1774 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1775   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1776   # If not cross compiling, check that we can run a simple program.
1777   if test "$cross_compiling" != yes; then
# Line 2222 | Line 1786 | if test "$cross_compiling" != yes; then
1786      if test "$cross_compiling" = maybe; then
1787          cross_compiling=yes
1788      else
1789 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1789 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1790   If you meant to cross compile, use \`--host'.
1791   See \`config.log' for more details." >&5
1792 < echo "$as_me: error: cannot run C compiled programs.
1792 > echo "$as_me: error: cannot run C++ compiled programs.
1793   If you meant to cross compile, use \`--host'.
1794   See \`config.log' for more details." >&2;}
1795     { (exit 1); exit 1; }; }
# Line 2330 | Line 1894 | ac_objext=$OBJEXT
1894   echo "${ECHO_T}$ac_cv_objext" >&6
1895   OBJEXT=$ac_cv_objext
1896   ac_objext=$OBJEXT
1897 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1898 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1899 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1897 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1898 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1899 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1900    echo $ECHO_N "(cached) $ECHO_C" >&6
1901   else
1902    cat >conftest.$ac_ext <<_ACEOF
# Line 2362 | Line 1926 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1926    cat conftest.err >&5
1927    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1928    (exit $ac_status); } &&
1929 <         { ac_try='test -z "$ac_c_werror_flag"
1929 >         { ac_try='test -z "$ac_cxx_werror_flag"
1930                           || test ! -s conftest.err'
1931    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1932    (eval $ac_try) 2>&5
# Line 2383 | Line 1947 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
1947   ac_compiler_gnu=no
1948   fi
1949   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1950 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
1950 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1951  
1952   fi
1953 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1954 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1955 < GCC=`test $ac_compiler_gnu = yes && echo yes`
1956 < ac_test_CFLAGS=${CFLAGS+set}
1957 < ac_save_CFLAGS=$CFLAGS
1958 < CFLAGS="-g"
1959 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1960 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1961 < if test "${ac_cv_prog_cc_g+set}" = set; then
1953 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1954 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1955 > GXX=`test $ac_compiler_gnu = yes && echo yes`
1956 > ac_test_CXXFLAGS=${CXXFLAGS+set}
1957 > ac_save_CXXFLAGS=$CXXFLAGS
1958 > CXXFLAGS="-g"
1959 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1960 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1961 > if test "${ac_cv_prog_cxx_g+set}" = set; then
1962    echo $ECHO_N "(cached) $ECHO_C" >&6
1963   else
1964    cat >conftest.$ac_ext <<_ACEOF
# Line 2421 | Line 1985 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1985    cat conftest.err >&5
1986    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1987    (exit $ac_status); } &&
1988 <         { ac_try='test -z "$ac_c_werror_flag"
1988 >         { ac_try='test -z "$ac_cxx_werror_flag"
1989                           || test ! -s conftest.err'
1990    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1991    (eval $ac_try) 2>&5
# Line 2434 | Line 1998 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1998    ac_status=$?
1999    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2000    (exit $ac_status); }; }; then
2001 <  ac_cv_prog_cc_g=yes
2001 >  ac_cv_prog_cxx_g=yes
2002   else
2003    echo "$as_me: failed program was:" >&5
2004   sed 's/^/| /' conftest.$ac_ext >&5
2005  
2006 < ac_cv_prog_cc_g=no
2006 > ac_cv_prog_cxx_g=no
2007   fi
2008   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2009   fi
2010 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2011 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2012 < if test "$ac_test_CFLAGS" = set; then
2013 <  CFLAGS=$ac_save_CFLAGS
2014 < elif test $ac_cv_prog_cc_g = yes; then
2015 <  if test "$GCC" = yes; then
2016 <    CFLAGS="-g -O2"
2010 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2011 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2012 > if test "$ac_test_CXXFLAGS" = set; then
2013 >  CXXFLAGS=$ac_save_CXXFLAGS
2014 > elif test $ac_cv_prog_cxx_g = yes; then
2015 >  if test "$GXX" = yes; then
2016 >    CXXFLAGS="-g -O2"
2017    else
2018 <    CFLAGS="-g"
2018 >    CXXFLAGS="-g"
2019    fi
2020   else
2021 <  if test "$GCC" = yes; then
2022 <    CFLAGS="-O2"
2021 >  if test "$GXX" = yes; then
2022 >    CXXFLAGS="-O2"
2023    else
2024 <    CFLAGS=
2024 >    CXXFLAGS=
2025    fi
2026   fi
2027 < 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 \
2027 > for ac_declaration in \
2028     '' \
2029     'extern "C" void std::exit (int) throw (); using std::exit;' \
2030     'extern "C" void std::exit (int); using std::exit;' \
# Line 2639 | Line 2057 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2057    cat conftest.err >&5
2058    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2059    (exit $ac_status); } &&
2060 <         { ac_try='test -z "$ac_c_werror_flag"
2060 >         { ac_try='test -z "$ac_cxx_werror_flag"
2061                           || test ! -s conftest.err'
2062    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2063    (eval $ac_try) 2>&5
# Line 2684 | Line 2102 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2102    cat conftest.err >&5
2103    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104    (exit $ac_status); } &&
2105 <         { ac_try='test -z "$ac_c_werror_flag"
2105 >         { ac_try='test -z "$ac_cxx_werror_flag"
2106                           || test ! -s conftest.err'
2107    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108    (eval $ac_try) 2>&5
# Line 2712 | Line 2130 | fi
2130    echo '#endif'             >>confdefs.h
2131   fi
2132  
2133 < else
2134 <  echo "$as_me: failed program was:" >&5
2135 < sed 's/^/| /' conftest.$ac_ext >&5
2133 > ac_ext=c
2134 > ac_cpp='$CPP $CPPFLAGS'
2135 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2136 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2137 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2138  
2719 – fi
2720 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2139   ac_ext=c
2140   ac_cpp='$CPP $CPPFLAGS'
2141   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2142   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2143   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2726 –
2727 –
2728 – ac_ext=cc
2729 – ac_cpp='$CXXCPP $CPPFLAGS'
2730 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2731 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2732 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2144   if test -n "$ac_tool_prefix"; then
2145 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2145 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2146    do
2147      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2148   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2149   echo "$as_me:$LINENO: checking for $ac_word" >&5
2150   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2151 < if test "${ac_cv_prog_CXX+set}" = set; then
2151 > if test "${ac_cv_prog_CC+set}" = set; then
2152    echo $ECHO_N "(cached) $ECHO_C" >&6
2153   else
2154 <  if test -n "$CXX"; then
2155 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2154 >  if test -n "$CC"; then
2155 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2156   else
2157   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2158   for as_dir in $PATH
# Line 2750 | Line 2161 | do
2161    test -z "$as_dir" && as_dir=.
2162    for ac_exec_ext in '' $ac_executable_extensions; do
2163    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2164 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2164 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2165      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2166      break 2
2167    fi
# Line 2759 | Line 2170 | fi
2170  
2171   fi
2172   fi
2173 < CXX=$ac_cv_prog_CXX
2174 < if test -n "$CXX"; then
2175 <  echo "$as_me:$LINENO: result: $CXX" >&5
2176 < echo "${ECHO_T}$CXX" >&6
2173 > CC=$ac_cv_prog_CC
2174 > if test -n "$CC"; then
2175 >  echo "$as_me:$LINENO: result: $CC" >&5
2176 > echo "${ECHO_T}$CC" >&6
2177   else
2178    echo "$as_me:$LINENO: result: no" >&5
2179   echo "${ECHO_T}no" >&6
2180   fi
2181  
2182 <    test -n "$CXX" && break
2182 >    test -n "$CC" && break
2183    done
2184   fi
2185 < if test -z "$CXX"; then
2186 <  ac_ct_CXX=$CXX
2187 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2185 > if test -z "$CC"; then
2186 >  ac_ct_CC=$CC
2187 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2188   do
2189    # Extract the first word of "$ac_prog", so it can be a program name with args.
2190   set dummy $ac_prog; ac_word=$2
2191   echo "$as_me:$LINENO: checking for $ac_word" >&5
2192   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2193 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2193 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2194    echo $ECHO_N "(cached) $ECHO_C" >&6
2195   else
2196 <  if test -n "$ac_ct_CXX"; then
2197 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2196 >  if test -n "$ac_ct_CC"; then
2197 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2198   else
2199   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2200   for as_dir in $PATH
# Line 2792 | Line 2203 | do
2203    test -z "$as_dir" && as_dir=.
2204    for ac_exec_ext in '' $ac_executable_extensions; do
2205    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2206 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2206 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2207      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2208      break 2
2209    fi
# Line 2801 | Line 2212 | fi
2212  
2213   fi
2214   fi
2215 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2216 < if test -n "$ac_ct_CXX"; then
2217 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2218 < echo "${ECHO_T}$ac_ct_CXX" >&6
2215 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2216 > if test -n "$ac_ct_CC"; then
2217 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2218 > echo "${ECHO_T}$ac_ct_CC" >&6
2219   else
2220    echo "$as_me:$LINENO: result: no" >&5
2221   echo "${ECHO_T}no" >&6
2222   fi
2223  
2224 <  test -n "$ac_ct_CXX" && break
2224 >  test -n "$ac_ct_CC" && break
2225   done
2815 – test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2226  
2227 <  CXX=$ac_ct_CXX
2227 >  CC=$ac_ct_CC
2228   fi
2229  
2230  
2231 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2232 + See \`config.log' for more details." >&5
2233 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2234 + See \`config.log' for more details." >&2;}
2235 +   { (exit 1); exit 1; }; }
2236 +
2237   # Provide some information about the compiler.
2238   echo "$as_me:$LINENO:" \
2239 <     "checking for C++ compiler version" >&5
2239 >     "checking for C compiler version" >&5
2240   ac_compiler=`set X $ac_compile; echo $2`
2241   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2242    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2838 | Line 2254 | ac_compiler=`set X $ac_compile; echo $2`
2254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2255    (exit $ac_status); }
2256  
2257 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2258 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2259 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2257 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2258 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2259 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2260    echo $ECHO_N "(cached) $ECHO_C" >&6
2261   else
2262    cat >conftest.$ac_ext <<_ACEOF
# Line 2870 | Line 2286 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2286    cat conftest.err >&5
2287    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2288    (exit $ac_status); } &&
2289 <         { ac_try='test -z "$ac_cxx_werror_flag"
2289 >         { ac_try='test -z "$ac_c_werror_flag"
2290                           || test ! -s conftest.err'
2291    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2292    (eval $ac_try) 2>&5
# Line 2891 | Line 2307 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2307   ac_compiler_gnu=no
2308   fi
2309   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2310 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2310 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2311  
2312   fi
2313 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2314 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2315 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2316 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2317 < ac_save_CXXFLAGS=$CXXFLAGS
2318 < CXXFLAGS="-g"
2319 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2320 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2321 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2313 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2314 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2315 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2316 > ac_test_CFLAGS=${CFLAGS+set}
2317 > ac_save_CFLAGS=$CFLAGS
2318 > CFLAGS="-g"
2319 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2320 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2321 > if test "${ac_cv_prog_cc_g+set}" = set; then
2322    echo $ECHO_N "(cached) $ECHO_C" >&6
2323   else
2324    cat >conftest.$ac_ext <<_ACEOF
# Line 2929 | Line 2345 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2345    cat conftest.err >&5
2346    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2347    (exit $ac_status); } &&
2348 <         { ac_try='test -z "$ac_cxx_werror_flag"
2348 >         { ac_try='test -z "$ac_c_werror_flag"
2349                           || test ! -s conftest.err'
2350    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2351    (eval $ac_try) 2>&5
# Line 2942 | Line 2358 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2358    ac_status=$?
2359    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2360    (exit $ac_status); }; }; then
2361 <  ac_cv_prog_cxx_g=yes
2361 >  ac_cv_prog_cc_g=yes
2362   else
2363    echo "$as_me: failed program was:" >&5
2364   sed 's/^/| /' conftest.$ac_ext >&5
2365  
2366 < ac_cv_prog_cxx_g=no
2366 > ac_cv_prog_cc_g=no
2367   fi
2368   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2369   fi
2370 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2371 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2372 < if test "$ac_test_CXXFLAGS" = set; then
2373 <  CXXFLAGS=$ac_save_CXXFLAGS
2374 < elif test $ac_cv_prog_cxx_g = yes; then
2375 <  if test "$GXX" = yes; then
2376 <    CXXFLAGS="-g -O2"
2370 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2371 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2372 > if test "$ac_test_CFLAGS" = set; then
2373 >  CFLAGS=$ac_save_CFLAGS
2374 > elif test $ac_cv_prog_cc_g = yes; then
2375 >  if test "$GCC" = yes; then
2376 >    CFLAGS="-g -O2"
2377    else
2378 <    CXXFLAGS="-g"
2378 >    CFLAGS="-g"
2379    fi
2380   else
2381 <  if test "$GXX" = yes; then
2382 <    CXXFLAGS="-O2"
2381 >  if test "$GCC" = yes; then
2382 >    CFLAGS="-O2"
2383    else
2384 <    CXXFLAGS=
2384 >    CFLAGS=
2385    fi
2386   fi
2387 < for ac_declaration in \
2387 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2388 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2389 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2391 > else
2392 >  ac_cv_prog_cc_stdc=no
2393 > ac_save_CC=$CC
2394 > cat >conftest.$ac_ext <<_ACEOF
2395 > /* confdefs.h.  */
2396 > _ACEOF
2397 > cat confdefs.h >>conftest.$ac_ext
2398 > cat >>conftest.$ac_ext <<_ACEOF
2399 > /* end confdefs.h.  */
2400 > #include <stdarg.h>
2401 > #include <stdio.h>
2402 > #include <sys/types.h>
2403 > #include <sys/stat.h>
2404 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2405 > struct buf { int x; };
2406 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2407 > static char *e (p, i)
2408 >     char **p;
2409 >     int i;
2410 > {
2411 >  return p[i];
2412 > }
2413 > static char *f (char * (*g) (char **, int), char **p, ...)
2414 > {
2415 >  char *s;
2416 >  va_list v;
2417 >  va_start (v,p);
2418 >  s = g (p, va_arg (v,int));
2419 >  va_end (v);
2420 >  return s;
2421 > }
2422 >
2423 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2424 >   function prototypes and stuff, but not '\xHH' hex character constants.
2425 >   These don't provoke an error unfortunately, instead are silently treated
2426 >   as 'x'.  The following induces an error, until -std1 is added to get
2427 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2428 >   array size at least.  It's necessary to write '\x00'==0 to get something
2429 >   that's true only with -std1.  */
2430 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2431 >
2432 > int test (int i, double x);
2433 > struct s1 {int (*f) (int a);};
2434 > struct s2 {int (*f) (double a);};
2435 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2436 > int argc;
2437 > char **argv;
2438 > int
2439 > main ()
2440 > {
2441 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2442 >  ;
2443 >  return 0;
2444 > }
2445 > _ACEOF
2446 > # Don't try gcc -ansi; that turns off useful extensions and
2447 > # breaks some systems' header files.
2448 > # AIX                   -qlanglvl=ansi
2449 > # Ultrix and OSF/1      -std1
2450 > # HP-UX 10.20 and later -Ae
2451 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2452 > # SVR4                  -Xc -D__EXTENSIONS__
2453 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2454 > do
2455 >  CC="$ac_save_CC $ac_arg"
2456 >  rm -f conftest.$ac_objext
2457 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2458 >  (eval $ac_compile) 2>conftest.er1
2459 >  ac_status=$?
2460 >  grep -v '^ *+' conftest.er1 >conftest.err
2461 >  rm -f conftest.er1
2462 >  cat conftest.err >&5
2463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2464 >  (exit $ac_status); } &&
2465 >         { ac_try='test -z "$ac_c_werror_flag"
2466 >                         || test ! -s conftest.err'
2467 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468 >  (eval $ac_try) 2>&5
2469 >  ac_status=$?
2470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471 >  (exit $ac_status); }; } &&
2472 >         { ac_try='test -s conftest.$ac_objext'
2473 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474 >  (eval $ac_try) 2>&5
2475 >  ac_status=$?
2476 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477 >  (exit $ac_status); }; }; then
2478 >  ac_cv_prog_cc_stdc=$ac_arg
2479 > break
2480 > else
2481 >  echo "$as_me: failed program was:" >&5
2482 > sed 's/^/| /' conftest.$ac_ext >&5
2483 >
2484 > fi
2485 > rm -f conftest.err conftest.$ac_objext
2486 > done
2487 > rm -f conftest.$ac_ext conftest.$ac_objext
2488 > CC=$ac_save_CC
2489 >
2490 > fi
2491 >
2492 > case "x$ac_cv_prog_cc_stdc" in
2493 >  x|xno)
2494 >    echo "$as_me:$LINENO: result: none needed" >&5
2495 > echo "${ECHO_T}none needed" >&6 ;;
2496 >  *)
2497 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2500 > esac
2501 >
2502 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2503 > # in C++ we need to declare it.  In case someone uses the same compiler
2504 > # for both compiling C and C++ we need to have the C++ compiler decide
2505 > # the declaration of exit, since it's the most demanding environment.
2506 > cat >conftest.$ac_ext <<_ACEOF
2507 > #ifndef __cplusplus
2508 >  choke me
2509 > #endif
2510 > _ACEOF
2511 > rm -f conftest.$ac_objext
2512 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513 >  (eval $ac_compile) 2>conftest.er1
2514 >  ac_status=$?
2515 >  grep -v '^ *+' conftest.er1 >conftest.err
2516 >  rm -f conftest.er1
2517 >  cat conftest.err >&5
2518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519 >  (exit $ac_status); } &&
2520 >         { ac_try='test -z "$ac_c_werror_flag"
2521 >                         || test ! -s conftest.err'
2522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2523 >  (eval $ac_try) 2>&5
2524 >  ac_status=$?
2525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2526 >  (exit $ac_status); }; } &&
2527 >         { ac_try='test -s conftest.$ac_objext'
2528 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2529 >  (eval $ac_try) 2>&5
2530 >  ac_status=$?
2531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532 >  (exit $ac_status); }; }; then
2533 >  for ac_declaration in \
2534     '' \
2535     'extern "C" void std::exit (int) throw (); using std::exit;' \
2536     'extern "C" void std::exit (int); using std::exit;' \
# Line 3001 | Line 2563 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2563    cat conftest.err >&5
2564    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565    (exit $ac_status); } &&
2566 <         { ac_try='test -z "$ac_cxx_werror_flag"
2566 >         { ac_try='test -z "$ac_c_werror_flag"
2567                           || test ! -s conftest.err'
2568    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2569    (eval $ac_try) 2>&5
# Line 3046 | Line 2608 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2608    cat conftest.err >&5
2609    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610    (exit $ac_status); } &&
2611 <         { ac_try='test -z "$ac_cxx_werror_flag"
2611 >         { ac_try='test -z "$ac_c_werror_flag"
2612                           || test ! -s conftest.err'
2613    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2614    (eval $ac_try) 2>&5
# Line 3074 | Line 2636 | fi
2636    echo '#endif'             >>confdefs.h
2637   fi
2638  
2639 + else
2640 +  echo "$as_me: failed program was:" >&5
2641 + sed 's/^/| /' conftest.$ac_ext >&5
2642 +
2643 + fi
2644 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645   ac_ext=c
2646   ac_cpp='$CPP $CPPFLAGS'
2647   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650  
2651 + ac_ext=${FC_SRCEXT-f}
2652 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2653 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2654 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2655 + if test -n "$ac_tool_prefix"; then
2656 +  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2657 +  do
2658 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2659 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2660 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2661 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2662 + if test "${ac_cv_prog_FC+set}" = set; then
2663 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2664 + else
2665 +  if test -n "$FC"; then
2666 +  ac_cv_prog_FC="$FC" # Let the user override the test.
2667 + else
2668 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2669 + for as_dir in $PATH
2670 + do
2671 +  IFS=$as_save_IFS
2672 +  test -z "$as_dir" && as_dir=.
2673 +  for ac_exec_ext in '' $ac_executable_extensions; do
2674 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2675 +    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2676 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2677 +    break 2
2678 +  fi
2679 + done
2680 + done
2681  
2682 + fi
2683 + fi
2684 + FC=$ac_cv_prog_FC
2685 + if test -n "$FC"; then
2686 +  echo "$as_me:$LINENO: result: $FC" >&5
2687 + echo "${ECHO_T}$FC" >&6
2688 + else
2689 +  echo "$as_me:$LINENO: result: no" >&5
2690 + echo "${ECHO_T}no" >&6
2691 + fi
2692 +
2693 +    test -n "$FC" && break
2694 +  done
2695 + fi
2696 + if test -z "$FC"; then
2697 +  ac_ct_FC=$FC
2698 +  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2699 + do
2700 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2701 + set dummy $ac_prog; ac_word=$2
2702 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2703 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2704 + if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2705 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2706 + else
2707 +  if test -n "$ac_ct_FC"; then
2708 +  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2709 + else
2710 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2711 + for as_dir in $PATH
2712 + do
2713 +  IFS=$as_save_IFS
2714 +  test -z "$as_dir" && as_dir=.
2715 +  for ac_exec_ext in '' $ac_executable_extensions; do
2716 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2717 +    ac_cv_prog_ac_ct_FC="$ac_prog"
2718 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719 +    break 2
2720 +  fi
2721 + done
2722 + done
2723 +
2724 + fi
2725 + fi
2726 + ac_ct_FC=$ac_cv_prog_ac_ct_FC
2727 + if test -n "$ac_ct_FC"; then
2728 +  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2729 + echo "${ECHO_T}$ac_ct_FC" >&6
2730 + else
2731 +  echo "$as_me:$LINENO: result: no" >&5
2732 + echo "${ECHO_T}no" >&6
2733 + fi
2734 +
2735 +  test -n "$ac_ct_FC" && break
2736 + done
2737 +
2738 +  FC=$ac_ct_FC
2739 + fi
2740 +
2741 +
2742 + # Provide some information about the compiler.
2743 + echo "$as_me:2743:" \
2744 +     "checking for Fortran compiler version" >&5
2745 + ac_compiler=`set X $ac_compile; echo $2`
2746 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2747 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2748 +  ac_status=$?
2749 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2750 +  (exit $ac_status); }
2751 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2752 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2753 +  ac_status=$?
2754 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755 +  (exit $ac_status); }
2756 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2757 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2758 +  ac_status=$?
2759 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2760 +  (exit $ac_status); }
2761 + rm -f a.out
2762 +
2763 + # If we don't use `.F' as extension, the preprocessor is not run on the
2764 + # input file.  (Note that this only needs to work for GNU compilers.)
2765 + ac_save_ext=$ac_ext
2766 + ac_ext=F
2767 + echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2768 + echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2769 + if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2770 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2771 + else
2772 +  cat >conftest.$ac_ext <<_ACEOF
2773 +      program main
2774 + #ifndef __GNUC__
2775 +       choke me
2776 + #endif
2777 +
2778 +      end
2779 + _ACEOF
2780 + rm -f conftest.$ac_objext
2781 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2782 +  (eval $ac_compile) 2>conftest.er1
2783 +  ac_status=$?
2784 +  grep -v '^ *+' conftest.er1 >conftest.err
2785 +  rm -f conftest.er1
2786 +  cat conftest.err >&5
2787 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788 +  (exit $ac_status); } &&
2789 +         { ac_try='test -z "$ac_fc_werror_flag"
2790 +                         || test ! -s conftest.err'
2791 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2792 +  (eval $ac_try) 2>&5
2793 +  ac_status=$?
2794 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2795 +  (exit $ac_status); }; } &&
2796 +         { ac_try='test -s conftest.$ac_objext'
2797 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2798 +  (eval $ac_try) 2>&5
2799 +  ac_status=$?
2800 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2801 +  (exit $ac_status); }; }; then
2802 +  ac_compiler_gnu=yes
2803 + else
2804 +  echo "$as_me: failed program was:" >&5
2805 + sed 's/^/| /' conftest.$ac_ext >&5
2806 +
2807 + ac_compiler_gnu=no
2808 + fi
2809 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810 + ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811 +
2812 + fi
2813 + echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2814 + echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2815 + ac_ext=$ac_save_ext
2816 + ac_test_FFLAGS=${FCFLAGS+set}
2817 + ac_save_FFLAGS=$FCFLAGS
2818 + FCFLAGS=
2819 + echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2820 + echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2821 + if test "${ac_cv_prog_fc_g+set}" = set; then
2822 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2823 + else
2824 +  FCFLAGS=-g
2825 + cat >conftest.$ac_ext <<_ACEOF
2826 +      program main
2827 +
2828 +      end
2829 + _ACEOF
2830 + rm -f conftest.$ac_objext
2831 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2832 +  (eval $ac_compile) 2>conftest.er1
2833 +  ac_status=$?
2834 +  grep -v '^ *+' conftest.er1 >conftest.err
2835 +  rm -f conftest.er1
2836 +  cat conftest.err >&5
2837 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838 +  (exit $ac_status); } &&
2839 +         { ac_try='test -z "$ac_fc_werror_flag"
2840 +                         || test ! -s conftest.err'
2841 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2842 +  (eval $ac_try) 2>&5
2843 +  ac_status=$?
2844 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2845 +  (exit $ac_status); }; } &&
2846 +         { ac_try='test -s conftest.$ac_objext'
2847 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2848 +  (eval $ac_try) 2>&5
2849 +  ac_status=$?
2850 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851 +  (exit $ac_status); }; }; then
2852 +  ac_cv_prog_fc_g=yes
2853 + else
2854 +  echo "$as_me: failed program was:" >&5
2855 + sed 's/^/| /' conftest.$ac_ext >&5
2856 +
2857 + ac_cv_prog_fc_g=no
2858 + fi
2859 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860 +
2861 + fi
2862 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2863 + echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2864 + if test "$ac_test_FFLAGS" = set; then
2865 +  FCFLAGS=$ac_save_FFLAGS
2866 + elif test $ac_cv_prog_fc_g = yes; then
2867 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2868 +    FCFLAGS="-g -O2"
2869 +  else
2870 +    FCFLAGS="-g"
2871 +  fi
2872 + else
2873 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2874 +    FCFLAGS="-O2"
2875 +  else
2876 +    FCFLAGS=
2877 +  fi
2878 + fi
2879 +
2880   ac_ext=c
2881   ac_cpp='$CPP $CPPFLAGS'
2882   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2883   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2884   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2885 +
2886 + ac_ext=c
2887 + ac_cpp='$CPP $CPPFLAGS'
2888 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2889 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2890 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2891   echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2892   echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2893   # On Suns, sometimes $CPP names a directory.
# Line 3315 | Line 3117 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3117   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3118   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3119  
3318 –
3120   echo "$as_me:$LINENO: checking for egrep" >&5
3121   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3122   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3331 | Line 3132 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132   EGREP=$ac_cv_prog_egrep
3133  
3134  
3135 <
3136 < OOPSE_TEMPLATE_FLAGS=""
3137 < if test $ac_cv_cxx_compiler_gnu = no; then
3138 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3139 < 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
3135 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3136 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3137 > LN_S=$as_ln_s
3138 > if test "$LN_S" = "ln -s"; then
3139 >  echo "$as_me:$LINENO: result: yes" >&5
3140   echo "${ECHO_T}yes" >&6
3141 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3142 <  else
3143 <    echo "$as_me:$LINENO: result: no" >&5
3144 < echo "${ECHO_T}no" >&6
3145 <  fi
3146 <  rm -f conftest*
3147 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3148 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3149 <  echo 'void f(){}' > conftest.cc
3150 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3151 <    echo "$as_me:$LINENO: result: yes" >&5
3141 > else
3142 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3143 > echo "${ECHO_T}no, using $LN_S" >&6
3144 > fi
3145 >
3146 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3147 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3148 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3149 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3150 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3151 > else
3152 >  cat >conftest.make <<\_ACEOF
3153 > all:
3154 >        @echo 'ac_maketemp="$(MAKE)"'
3155 > _ACEOF
3156 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3157 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3158 > if test -n "$ac_maketemp"; then
3159 >  eval ac_cv_prog_make_${ac_make}_set=yes
3160 > else
3161 >  eval ac_cv_prog_make_${ac_make}_set=no
3162 > fi
3163 > rm -f conftest.make
3164 > fi
3165 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3166 >  echo "$as_me:$LINENO: result: yes" >&5
3167   echo "${ECHO_T}yes" >&6
3168 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3169 <  else
3170 <    echo "$as_me:$LINENO: result: no" >&5
3168 >  SET_MAKE=
3169 > else
3170 >  echo "$as_me:$LINENO: result: no" >&5
3171 > echo "${ECHO_T}no" >&6
3172 >  SET_MAKE="MAKE=${MAKE-make}"
3173 > fi
3174 >
3175 > if test -n "$ac_tool_prefix"; then
3176 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3177 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3178 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3179 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3181 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3182 > else
3183 >  if test -n "$RANLIB"; then
3184 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3185 > else
3186 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187 > for as_dir in $PATH
3188 > do
3189 >  IFS=$as_save_IFS
3190 >  test -z "$as_dir" && as_dir=.
3191 >  for ac_exec_ext in '' $ac_executable_extensions; do
3192 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3194 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195 >    break 2
3196 >  fi
3197 > done
3198 > done
3199 >
3200 > fi
3201 > fi
3202 > RANLIB=$ac_cv_prog_RANLIB
3203 > if test -n "$RANLIB"; then
3204 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3205 > echo "${ECHO_T}$RANLIB" >&6
3206 > else
3207 >  echo "$as_me:$LINENO: result: no" >&5
3208   echo "${ECHO_T}no" >&6
3209 + fi
3210 +
3211 + fi
3212 + if test -z "$ac_cv_prog_RANLIB"; then
3213 +  ac_ct_RANLIB=$RANLIB
3214 +  # Extract the first word of "ranlib", so it can be a program name with args.
3215 + set dummy ranlib; ac_word=$2
3216 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3217 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3218 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3219 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3220 + else
3221 +  if test -n "$ac_ct_RANLIB"; then
3222 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3223 + else
3224 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225 + for as_dir in $PATH
3226 + do
3227 +  IFS=$as_save_IFS
3228 +  test -z "$as_dir" && as_dir=.
3229 +  for ac_exec_ext in '' $ac_executable_extensions; do
3230 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3232 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233 +    break 2
3234    fi
3235 <  rm -f conftest*
3236 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3237 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3238 <  echo 'void f(){}' > conftest.cc
3239 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3240 <    echo "$as_me:$LINENO: result: yes" >&5
3241 < echo "${ECHO_T}yes" >&6
3242 <    OOPSE_TEMPLATE_FLAGS="-pto"
3243 <  else
3244 <    echo "$as_me:$LINENO: result: no" >&5
3235 > done
3236 > done
3237 >
3238 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3239 > fi
3240 > fi
3241 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3242 > if test -n "$ac_ct_RANLIB"; then
3243 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3244 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3245 > else
3246 >  echo "$as_me:$LINENO: result: no" >&5
3247   echo "${ECHO_T}no" >&6
3248 + fi
3249 +
3250 +  RANLIB=$ac_ct_RANLIB
3251 + else
3252 +  RANLIB="$ac_cv_prog_RANLIB"
3253 + fi
3254 +
3255 +
3256 +   # Extract the first word of "perl", so it can be a program name with args.
3257 + set dummy perl; ac_word=$2
3258 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3259 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3260 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3261 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3262 + else
3263 +  case $PERLINTERP in
3264 +  [\\/]* | ?:[\\/]*)
3265 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3266 +  ;;
3267 +  *)
3268 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3269 + for as_dir in $PATH
3270 + do
3271 +  IFS=$as_save_IFS
3272 +  test -z "$as_dir" && as_dir=.
3273 +  for ac_exec_ext in '' $ac_executable_extensions; do
3274 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3275 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3276 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3277 +    break 2
3278    fi
3279 <  rm -f conftest*
3280 <  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
3279 > done
3280 > done
3281  
3282 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3283 +  ;;
3284 + esac
3285 + fi
3286 + PERLINTERP=$ac_cv_path_PERLINTERP
3287  
3288 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3289 <  else
3290 <    echo "$as_me:$LINENO: result: no" >&5
3288 > if test -n "$PERLINTERP"; then
3289 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3290 > echo "${ECHO_T}$PERLINTERP" >&6
3291 > else
3292 >  echo "$as_me:$LINENO: result: no" >&5
3293   echo "${ECHO_T}no" >&6
3294 + fi
3295 +
3296 +   ac_cv_path_perlinterp="$PERLINTERP"
3297 +   _sHpB='#!'
3298 +
3299 +
3300 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3301 + if test "${with_perl_shebang+set}" = set; then
3302 +  withval="$with_perl_shebang"
3303 +  opt_perl_shebang="$withval"
3304 + else
3305 +                opt_perl_shebang="not_set"
3306 + fi;
3307 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3311 + else
3312 +   case "$opt_perl_shebang" in
3313 +                      not_set  ) ax_cv_opt_perl_shebang=''
3314 +                               ;;
3315 +                         *     )
3316 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317 +                    esac
3318 +
3319 + fi
3320 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3323 +     then
3324 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328 +
3329 + # Automatic detection of sharpbang formula starts here
3330 +     else
3331 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3332 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3337 + else
3338 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339 +        if test "x$_somian_kspb_perl" == x
3340 +          then _somian_ksbp_warn_empty='durnit'
3341 +          else
3342 +          case "A$_somian_kspb_perl" in
3343 +                 A#!*perl* )
3344 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345 +                        ;;
3346 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3347 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348 +          esac
3349 +        fi
3350 +
3351 + fi
3352 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354 + # The above prints Checking ... result message to user.
3355 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356 +
3357 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3358 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360 +    fi
3361 + # Inform user after printing result value
3362 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3363 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364 + echo "$as_me: Maybe Not good -" >&6;}
3365 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3368 + echo "$as_me: OK Good result - " >&6;}
3369 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371 +    fi
3372    fi
3373 +
3374 + # Find a good install program.  We prefer a C program (faster),
3375 + # so one script is as good as another.  But avoid the broken or
3376 + # incompatible versions:
3377 + # SysV /etc/install, /usr/sbin/install
3378 + # SunOS /usr/etc/install
3379 + # IRIX /sbin/install
3380 + # AIX /bin/install
3381 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3382 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385 + # OS/2's system install, which has a completely different semantic
3386 + # ./install, which can be erroneously created by make from ./install.sh.
3387 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389 + if test -z "$INSTALL"; then
3390 + if test "${ac_cv_path_install+set}" = set; then
3391 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3392 + else
3393 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394 + for as_dir in $PATH
3395 + do
3396 +  IFS=$as_save_IFS
3397 +  test -z "$as_dir" && as_dir=.
3398 +  # Account for people who put trailing slashes in PATH elements.
3399 + case $as_dir/ in
3400 +  ./ | .// | /cC/* | \
3401 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403 +  /usr/ucb/* ) ;;
3404 +  *)
3405 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3406 +    # Don't use installbsd from OSF since it installs stuff as root
3407 +    # by default.
3408 +    for ac_prog in ginstall scoinst install; do
3409 +      for ac_exec_ext in '' $ac_executable_extensions; do
3410 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411 +          if test $ac_prog = install &&
3412 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413 +            # AIX install.  It has an incompatible calling convention.
3414 +            :
3415 +          elif test $ac_prog = install &&
3416 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417 +            # program-specific install script used by HP pwplus--don't use.
3418 +            :
3419 +          else
3420 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421 +            break 3
3422 +          fi
3423 +        fi
3424 +      done
3425 +    done
3426 +    ;;
3427 + esac
3428 + done
3429 +
3430 +
3431   fi
3432 +  if test "${ac_cv_path_install+set}" = set; then
3433 +    INSTALL=$ac_cv_path_install
3434 +  else
3435 +    # As a last resort, use the slow shell script.  We don't cache a
3436 +    # path for INSTALL within a source directory, because that will
3437 +    # break other packages using the cache if that directory is
3438 +    # removed, or if the path is relative.
3439 +    INSTALL=$ac_install_sh
3440 +  fi
3441 + fi
3442 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3443 + echo "${ECHO_T}$INSTALL" >&6
3444  
3445 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446 + # It thinks the first close brace ends the variable substitution.
3447 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448  
3449 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450  
3451 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452  
3453 < ac_ext=f90
3454 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3455 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3456 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3457 < if test -n "$ac_tool_prefix"; then
3458 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3459 <  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
3453 > case "x$INSTALL" in
3454 >   x/*) ;;
3455 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3456 > esac
3457 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3458 > # Extract the first word of "ar", so it can be a program name with args.
3459 > set dummy ar; ac_word=$2
3460   echo "$as_me:$LINENO: checking for $ac_word" >&5
3461   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3462 < if test "${ac_cv_prog_F90+set}" = set; then
3462 > if test "${ac_cv_prog_AR+set}" = set; then
3463    echo $ECHO_N "(cached) $ECHO_C" >&6
3464   else
3465 <  if test -n "$F90"; then
3466 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3465 >  if test -n "$AR"; then
3466 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3467   else
3468   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3469   for as_dir in $PATH
# Line 3412 | Line 3472 | do
3472    test -z "$as_dir" && as_dir=.
3473    for ac_exec_ext in '' $ac_executable_extensions; do
3474    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3475 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3475 >    ac_cv_prog_AR="ar"
3476      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3477      break 2
3478    fi
3479   done
3480   done
3481  
3482 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3483   fi
3484   fi
3485 < F90=$ac_cv_prog_F90
3486 < if test -n "$F90"; then
3487 <  echo "$as_me:$LINENO: result: $F90" >&5
3488 < echo "${ECHO_T}$F90" >&6
3485 > AR=$ac_cv_prog_AR
3486 > if test -n "$AR"; then
3487 >  echo "$as_me:$LINENO: result: $AR" >&5
3488 > echo "${ECHO_T}$AR" >&6
3489   else
3490    echo "$as_me:$LINENO: result: no" >&5
3491   echo "${ECHO_T}no" >&6
3492   fi
3493  
3494 <    test -n "$F90" && break
3495 <  done
3494 > if test "$AR" = "NONE"; then
3495 >  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3496 > echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3497 >   { (exit 1); exit 1; }; }
3498 >  cat >confcache <<\_ACEOF
3499 > # This file is a shell script that caches the results of configure
3500 > # tests run on this system so they can be shared between configure
3501 > # scripts and configure runs, see configure's option --config-cache.
3502 > # It is not useful on other systems.  If it contains results you don't
3503 > # want to keep, you may remove or edit it.
3504 > #
3505 > # config.status only pays attention to the cache file if you give it
3506 > # the --recheck option to rerun configure.
3507 > #
3508 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3509 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3510 > # following values.
3511 >
3512 > _ACEOF
3513 >
3514 > # The following way of writing the cache mishandles newlines in values,
3515 > # but we know of no workaround that is simple, portable, and efficient.
3516 > # So, don't put newlines in cache variables' values.
3517 > # Ultrix sh set writes to stderr and can't be redirected directly,
3518 > # and sets the high bit in the cache file unless we assign to the vars.
3519 > {
3520 >  (set) 2>&1 |
3521 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3522 >    *ac_space=\ *)
3523 >      # `set' does not quote correctly, so add quotes (double-quote
3524 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3525 >      sed -n \
3526 >        "s/'/'\\\\''/g;
3527 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3528 >      ;;
3529 >    *)
3530 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3531 >      sed -n \
3532 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3533 >      ;;
3534 >    esac;
3535 > } |
3536 >  sed '
3537 >     t clear
3538 >     : clear
3539 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3540 >     t end
3541 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3542 >     : end' >>confcache
3543 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3544 >  if test -w $cache_file; then
3545 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3546 >    cat confcache >$cache_file
3547 >  else
3548 >    echo "not updating unwritable cache $cache_file"
3549 >  fi
3550   fi
3551 < if test -z "$F90"; then
3552 <  ac_ct_F90=$F90
3553 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3554 < do
3555 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3441 < set dummy $ac_prog; ac_word=$2
3551 > rm -f confcache
3552 >  exit 1
3553 > fi
3554 > # Extract the first word of "ps", so it can be a program name with args.
3555 > set dummy ps; ac_word=$2
3556   echo "$as_me:$LINENO: checking for $ac_word" >&5
3557   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3558 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3558 > if test "${ac_cv_path_PS+set}" = set; then
3559    echo $ECHO_N "(cached) $ECHO_C" >&6
3560   else
3561 <  if test -n "$ac_ct_F90"; then
3562 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3563 < else
3564 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3561 >  case $PS in
3562 >  [\\/]* | ?:[\\/]*)
3563 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3564 >  ;;
3565 >  *)
3566 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3567   for as_dir in $PATH
3568   do
3569    IFS=$as_save_IFS
3570    test -z "$as_dir" && as_dir=.
3571    for ac_exec_ext in '' $ac_executable_extensions; do
3572    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3573 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3573 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3574      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3575      break 2
3576    fi
3577   done
3578   done
3579  
3580 +  ;;
3581 + esac
3582   fi
3583 < fi
3584 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3585 < if test -n "$ac_ct_F90"; then
3586 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3587 < echo "${ECHO_T}$ac_ct_F90" >&6
3583 > PS=$ac_cv_path_PS
3584 >
3585 > if test -n "$PS"; then
3586 >  echo "$as_me:$LINENO: result: $PS" >&5
3587 > echo "${ECHO_T}$PS" >&6
3588   else
3589    echo "$as_me:$LINENO: result: no" >&5
3590   echo "${ECHO_T}no" >&6
3591   fi
3592  
3593 <  test -n "$ac_ct_F90" && break
3594 < done
3593 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3594 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3595 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3596 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3597 > else
3598  
3599 <  F90=$ac_ct_F90
3599 >        if $PS ax -o rss > /dev/null 2>&1; then
3600 >                ac_cv_prog_ps_ax=yes
3601 >        else
3602 >                ac_cv_prog_ps_ax=no
3603 >        fi
3604 >        if $PS -ef -o rss > /dev/null 2>&1; then
3605 >                ac_cv_prog_ps_ef=yes
3606 >        else
3607 >                ac_cv_prog_ps_ef=no
3608 >        fi
3609 >        if test "$ac_cv_prog_ps_ax" = yes; then
3610 >                ac_cv_prog_ps_syntax=BSD
3611 >        else
3612 >                if test "$ac_cv_prog_ps_ef" = yes; then
3613 >                        ac_cv_prog_ps_syntax=POSIX
3614 >                else
3615 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3616 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3617 >   { (exit 1); exit 1; }; }
3618 >                fi
3619 >        fi
3620 >
3621   fi
3622 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3623 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3624  
3625 + cat >>confdefs.h <<_ACEOF
3626 + #define PSCOMMAND $PS
3627 + _ACEOF
3628  
3629 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3630 < # input file.
3631 < ac_save_ext=$ac_ext
3632 < ac_ext=F90
3633 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3634 < 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
3629 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3630 >
3631 > cat >>confdefs.h <<\_ACEOF
3632 > #define PSTYPE_IS_BSD 1
3633 > _ACEOF
3634 >
3635   else
3636 <  cat >conftest.$ac_ext <<_ACEOF
3636 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637  
3638 < program main
3638 > cat >>confdefs.h <<\_ACEOF
3639 > #define PSTYPE_IS_POSIX 1
3640 > _ACEOF
3641  
3642 < #ifndef __GNUC__
3643 <       choke me
3644 < #endif
3642 >   else
3643 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3644 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3645 >   { (exit 1); exit 1; }; }
3646 >   fi
3647 > fi
3648  
3649 < end program main
3649 > ac_ext=${FC_SRCEXT-f}
3650 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3651 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3652 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3653  
3654 +
3655 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3656 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3657 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3658 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3659 + else
3660 +  ac_ext=F90
3661 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3662 + FCFLAGS_SRCEXT=""
3663 + ac_cv_fc_srcext_F90=unknown
3664 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3665 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3666 +  cat >conftest.$ac_ext <<_ACEOF
3667 +      program main
3668 +
3669 +      end
3670   _ACEOF
3671   rm -f conftest.$ac_objext
3672   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3508 | Line 3677 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3677    cat conftest.err >&5
3678    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679    (exit $ac_status); } &&
3680 <         { ac_try='test -z "$ac_f90_werror_flag"
3680 >         { ac_try='test -z "$ac_fc_werror_flag"
3681                           || test ! -s conftest.err'
3682    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3683    (eval $ac_try) 2>&5
# Line 3521 | Line 3690 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3690    ac_status=$?
3691    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692    (exit $ac_status); }; }; then
3693 <  ac_compiler_gnu=yes
3693 >  ac_cv_fc_srcext_F90=$ac_flag; break
3694   else
3695    echo "$as_me: failed program was:" >&5
3696   sed 's/^/| /' conftest.$ac_ext >&5
3697  
3529 – ac_compiler_gnu=no
3698   fi
3699   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3700 > done
3701 > rm -f conftest.$ac_objext conftest.F90
3702 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3703  
3704   fi
3705 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3706 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3707 < ac_ext=$ac_save_ext
3708 < G95=`test $ac_compiler_gnu = yes && echo yes`
3709 < ac_ext=c
3710 < ac_cpp='$CPP $CPPFLAGS'
3711 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3712 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3713 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3705 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3706 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3707 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3708 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3709 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3710 >   { (exit 1); exit 1; }; }
3711 > else
3712 >  FC_SRCEXT=F90
3713 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3714 >    FCFLAGS_SRCEXT=""
3715 >    FCFLAGS_F90=""
3716 >  else
3717 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3718 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3719 >  fi
3720  
3721  
3722 + fi
3723  
3724  
3725  
3726 +
3727 +
3728   # Try to determine native compiler flags that allow us to use F90 suffix
3729   # for preprocessed f90 source.
3730  
# Line 3553 | Line 3732 | if test "$ac_test_PREPFLAG" != "set"; then
3732    PREPFLAG=""
3733    case "${host_cpu}-${host_os}" in
3734  
3735 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3735 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736                      PREPFLAG="-fpp1 "
3737                  fi;;
3738 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3738 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3739                      PREPFLAG="-qsuffix=cpp=F90 "
3740                  fi;;
3741    *darwin*)
3742 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3742 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743                  PREPFLAG="-qsuffix=cpp=F90 "
3744          fi;;
3745    esac
# Line 3575 | Line 3754 | echo $ECHO_N "checking to make sure F90 preprocessor f
3754   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755  
3756  
3757 <  ac_ext=f90
3758 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3759 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3760 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3757 >  ac_ext=${FC_SRCEXT-f}
3758 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3759 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3760 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3761  
3762    ac_save_ext=$ac_ext
3763    ac_ext=F90
3764 <  ac_save_F90FLAGS=$F90FLAGS
3764 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765  
3766    if test "$PREPFLAG"; then
3767 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3767 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3768   fi
3769  
3770      cat >conftest.$ac_ext <<_ACEOF
3771  
3772  
3773 < program main
3595 <
3773 > program conftest
3774    integer :: i
3775    i = 1
3776 + end program conftest
3777  
3599 –
3600 – end program main
3601 –
3778   _ACEOF
3779   rm -f conftest.$ac_objext
3780   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3609 | Line 3785 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785    cat conftest.err >&5
3786    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787    (exit $ac_status); } &&
3788 <         { ac_try='test -z "$ac_f90_werror_flag"
3788 >         { ac_try='test -z "$ac_fc_werror_flag"
3789                           || test ! -s conftest.err'
3790    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791    (eval $ac_try) 2>&5
# Line 3631 | Line 3807 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3807   fi
3808   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809  
3810 <  F90FLAGS=$ac_save_F90FLAGS
3810 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811    ac_ext=$ac_save_ext
3812 <  ac_ext=c
3813 < ac_cpp='$CPP $CPPFLAGS'
3814 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3815 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3640 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3641 <
3812 >  ac_ext=${FC_SRCEXT-f}
3813 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3814 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3815 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3816  
3817 +
3818    if test "$prepflagworks" = 1; then
3819      echo "$as_me:$LINENO: result: yes" >&5
3820   echo "${ECHO_T}yes" >&6
3821 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3822  
3823    else
3824      echo "$as_me:$LINENO: result: no" >&5
# Line 3664 | Line 3840 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3840    PREPDEFFLAG=""
3841    case "${host_cpu}-${host_os}" in
3842  
3843 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3843 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844                      PREPDEFFLAG=" "
3845                  fi;;
3846 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3846 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847                      PREPDEFFLAG="-WF,"
3848                  fi;;
3849    *darwin*)
3850 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3850 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851                  PREPDEFFLAG="-WF,"
3852          fi;;
3853    esac
# Line 3686 | Line 3862 | echo $ECHO_N "checking to make sure F90 preprocessor d
3862   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863  
3864  
3865 <  ac_ext=f90
3866 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3867 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3868 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3865 >  ac_ext=${FC_SRCEXT-f}
3866 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3867 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3868 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3869  
3870    ac_save_ext=$ac_ext
3871    ac_ext=F90
3872 <  ac_save_F90FLAGS=$F90FLAGS
3872 >  ac_save_FCFLAGS=$FCFLAGS
3873  
3874    if test "$PREPDEFFLAG"; then
3875 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3875 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876   fi
3877  
3878      cat >conftest.$ac_ext <<_ACEOF
3879  
3880  
3881 < program main
3706 <
3881 > program conftest
3882    integer :: i
3883   #ifdef TEST
3884    i = 1
3885   #else
3886    choke me
3887   #endif
3888 + end program conftest
3889  
3714 –
3715 – end program main
3716 –
3890   _ACEOF
3891   rm -f conftest.$ac_objext
3892   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3724 | Line 3897 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3897    cat conftest.err >&5
3898    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899    (exit $ac_status); } &&
3900 <         { ac_try='test -z "$ac_f90_werror_flag"
3900 >         { ac_try='test -z "$ac_fc_werror_flag"
3901                           || test ! -s conftest.err'
3902    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903    (eval $ac_try) 2>&5
# Line 3746 | Line 3919 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3919   fi
3920   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921  
3922 <  F90FLAGS=$ac_save_F90FLAGS
3922 >  FCFLAGS=$ac_save_FCFLAGS
3923    ac_ext=$ac_save_ext
3924 <  ac_ext=c
3925 < ac_cpp='$CPP $CPPFLAGS'
3926 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3927 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3924 >  ac_ext=${FC_SRCEXT-f}
3925 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3926 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3927 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3928  
3929  
3758 –
3930    if test "$prepdefflagworks" = 1; then
3931      echo "$as_me:$LINENO: result: yes" >&5
3932   echo "${ECHO_T}yes" >&6
# Line 3769 | Line 3940 | fi
3940    fi
3941   fi
3942  
3943 < ac_ext=f90
3944 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3945 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3946 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3947 <
3948 <
3949 <
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
3943 > ac_ext=${FC_SRCEXT-f}
3944 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3945 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3946 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3947 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3948 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3949 > if test "${ac_cv_prog_fc_v+set}" = set; then
3950    echo $ECHO_N "(cached) $ECHO_C" >&6
3951   else
3952 +  cat >conftest.$ac_ext <<_ACEOF
3953 +      program main
3954  
3955 < cat >conftest.$ac_ext <<_ACEOF
3790 <
3791 < program main
3792 <
3793 <
3794 < end program main
3795 <
3955 >      end
3956   _ACEOF
3957   rm -f conftest.$ac_objext
3958   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3803 | Line 3963 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3963    cat conftest.err >&5
3964    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965    (exit $ac_status); } &&
3966 <         { ac_try='test -z "$ac_f90_werror_flag"
3966 >         { ac_try='test -z "$ac_fc_werror_flag"
3967                           || test ! -s conftest.err'
3968    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969    (eval $ac_try) 2>&5
# Line 3816 | Line 3976 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3976    ac_status=$?
3977    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978    (exit $ac_status); }; }; then
3979 <  ac_cv_prog_f90_v=
3979 >  ac_cv_prog_fc_v=
3980   # Try some options frequently used verbose output
3981   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3982 <  ac_ext=f90
3983 < 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
3982 >  cat >conftest.$ac_ext <<_ACEOF
3983 >      program main
3984  
3985 < cat >conftest.$ac_ext <<_ACEOF
3828 <
3829 < program main
3830 <
3831 <
3832 < end program main
3833 <
3985 >      end
3986   _ACEOF
3987  
3988   # Compile and link our simple test program by passing a flag (argument
3989 < # 1 to this macro) to the Fortran 90 compiler in order to get
3990 < # "verbose" output that we can then parse for the Fortran 90 linker
3989 > # 1 to this macro) to the Fortran compiler in order to get
3990 > # "verbose" output that we can then parse for the Fortran linker
3991   # flags.
3992 < ac_save_F90FLAGS=$F90FLAGS
3993 < F90FLAGS="$F90FLAGS $ac_verb"
3992 > ac_save_FFLAGS=$FCFLAGS
3993 > FCFLAGS="$FCFLAGS $ac_verb"
3994 > (eval echo $as_me:3994: \"$ac_link\") >&5
3995 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3996 > echo "$ac_fc_v_output" >&5
3997 > FCFLAGS=$ac_save_FFLAGS
3998  
3999 < (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
3999 > rm -f conftest*
4000  
4001 < rm -f conftest.*
4002 < ac_ext=f90
4003 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4004 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4005 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4001 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4002 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4003 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4004 > ac_fc_v_output="`echo $ac_fc_v_output |
4005 >        grep 'LPATH is:' |
4006 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4007  
4008 < # If we are using xlf then replace all the commas with spaces.
4009 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4010 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4011 < fi
4008 > case $ac_fc_v_output in
4009 >  # If we are using xlf then replace all the commas with spaces.
4010 >  *xlfentry*)
4011 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4012  
4013 < # If we are using Cray Fortran then delete quotes.
4014 < # Use "\"" instead of '"' for font-lock-mode.
4015 < # FIXME: a more general fix for quoted arguments with spaces?
4016 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4017 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4018 < fi
4013 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4014 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4015 >  *mGLOB_options_string*)
4016 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4017 >
4018 >  # If we are using Cray Fortran then delete quotes.
4019 >  # Use "\"" instead of '"' for font-lock-mode.
4020 >  # FIXME: a more general fix for quoted arguments with spaces?
4021 >  *cft90*)
4022 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4023 > esac
4024 >
4025 >
4026    # look for -l* and *.a constructs in the output
4027 <  for ac_arg in $ac_f90_v_output; do
4027 >  for ac_arg in $ac_fc_v_output; do
4028       case $ac_arg in
4029          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030 <          ac_cv_prog_f90_v=$ac_verb
4030 >          ac_cv_prog_fc_v=$ac_verb
4031            break 2 ;;
4032       esac
4033    done
4034   done
4035 < if test -z "$ac_cv_prog_f90_v"; then
4036 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4037 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4035 > if test -z "$ac_cv_prog_fc_v"; then
4036 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4037 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4038   fi
4039   else
4040    echo "$as_me: failed program was:" >&5
# Line 3885 | Line 4046 | fi
4046   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047  
4048   fi
4049 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4050 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4051 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4052 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4053 < if test "${ac_cv_flibs+set}" = set; then
4049 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4050 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4051 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4052 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4053 > if test "${ac_cv_fc_libs+set}" = set; then
4054    echo $ECHO_N "(cached) $ECHO_C" >&6
4055   else
4056 <  if test "x$F90LIBS" != "x"; then
4057 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4056 >  if test "x$FCLIBS" != "x"; then
4057 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058   else
4059  
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 –
4060   cat >conftest.$ac_ext <<_ACEOF
4061 +      program main
4062  
4063 < program main
3907 <
3908 <
3909 < end program main
3910 <
4063 >      end
4064   _ACEOF
4065  
4066   # Compile and link our simple test program by passing a flag (argument
4067 < # 1 to this macro) to the Fortran 90 compiler in order to get
4068 < # "verbose" output that we can then parse for the Fortran 90 linker
4067 > # 1 to this macro) to the Fortran compiler in order to get
4068 > # "verbose" output that we can then parse for the Fortran linker
4069   # flags.
4070 < ac_save_F90FLAGS=$F90FLAGS
4071 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4070 > ac_save_FFLAGS=$FCFLAGS
4071 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4072 > (eval echo $as_me:4072: \"$ac_link\") >&5
4073 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4074 > echo "$ac_fc_v_output" >&5
4075 > FCFLAGS=$ac_save_FFLAGS
4076  
4077 < (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
4077 > rm -f conftest*
4078  
4079 < rm -f conftest.*
4080 < ac_ext=f90
4081 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4082 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4083 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4079 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4080 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4081 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4082 > ac_fc_v_output="`echo $ac_fc_v_output |
4083 >        grep 'LPATH is:' |
4084 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4085  
4086 < # If we are using xlf then replace all the commas with spaces.
4087 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4088 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4089 < fi
4086 > case $ac_fc_v_output in
4087 >  # If we are using xlf then replace all the commas with spaces.
4088 >  *xlfentry*)
4089 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4090  
4091 < # If we are using Cray Fortran then delete quotes.
4092 < # Use "\"" instead of '"' for font-lock-mode.
4093 < # FIXME: a more general fix for quoted arguments with spaces?
4094 < 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
4091 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4092 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4093 >  *mGLOB_options_string*)
4094 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4095  
4096 < ac_cv_f90libs=
4096 >  # If we are using Cray Fortran then delete quotes.
4097 >  # Use "\"" instead of '"' for font-lock-mode.
4098 >  # FIXME: a more general fix for quoted arguments with spaces?
4099 >  *cft90*)
4100 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101 > esac
4102  
4103 +
4104 +
4105 + ac_cv_fc_libs=
4106 +
4107   # Save positional arguments (if any)
4108   ac_save_positional="$@"
4109  
4110 < set X $ac_f90_v_output
4110 > set X $ac_fc_v_output
4111   while test $# != 1; do
4112    shift
4113    ac_arg=$1
4114    case $ac_arg in
4115          [\\/]*.a | ?:[\\/]*.a)
4116              ac_exists=false
4117 <  for ac_i in $ac_cv_f90libs; do
4117 >  for ac_i in $ac_cv_fc_libs; do
4118      if test x"$ac_arg" = x"$ac_i"; then
4119        ac_exists=true
4120        break
# Line 3962 | Line 4124 | else
4124    if test x"$ac_exists" = xtrue; then
4125    :
4126   else
4127 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4127 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4128   fi
4129  
4130            ;;
4131          -bI:*)
4132              ac_exists=false
4133 <  for ac_i in $ac_cv_f90libs; do
4133 >  for ac_i in $ac_cv_fc_libs; do
4134      if test x"$ac_arg" = x"$ac_i"; then
4135        ac_exists=true
4136        break
# Line 3980 | Line 4142 | else
4142   else
4143    if test "$ac_compiler_gnu" = yes; then
4144    for ac_link_opt in $ac_arg; do
4145 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4145 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146    done
4147   else
4148 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4148 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149   fi
4150   fi
4151  
4152            ;;
4153            # Ignore these flags.
4154 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4154 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155            ;;
4156          -lkernel32)
4157 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4157 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4158            ;;
4159          -[LRuY])
4160            # These flags, when seen by themselves, take an argument.
4161            # We remove the space between option and argument and re-iterate
4162            # unless we find an empty arg or a new option (starting with -)
4163            case $2 in
4164 <             "" | -*);;
4165 <             *)
4164 >             "" | -*);;
4165 >             *)
4166                  ac_arg="$ac_arg$2"
4005 –
4167                  shift; shift
4168                  set X $ac_arg "$@"
4169                  ;;
# Line 4011 | Line 4172 | fi
4172          -YP,*)
4173            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4174                ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_j" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 4022 | Line 4183 | else
4183    :
4184   else
4185    ac_arg="$ac_arg $ac_j"
4186 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4186 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4187   fi
4188  
4189            done
4190            ;;
4191          -[lLR]*)
4192              ac_exists=false
4193 <  for ac_i in $ac_cv_f90libs; do
4193 >  for ac_i in $ac_cv_fc_libs; do
4194      if test x"$ac_arg" = x"$ac_i"; then
4195        ac_exists=true
4196        break
# Line 4039 | Line 4200 | else
4200    if test x"$ac_exists" = xtrue; then
4201    :
4202   else
4203 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4203 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204   fi
4205  
4206            ;;
# Line 4054 | Line 4215 | case `(uname -sr) 2>/dev/null` in
4215   # must begin with a "/").
4216   case `(uname -sr) 2>/dev/null` in
4217     "SunOS 5"*)
4218 <      ac_ld_run_path=`echo $ac_f90_v_output |
4218 >      ac_ld_run_path=`echo $ac_fc_v_output |
4219                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4220        test "x$ac_ld_run_path" != x &&
4060 –
4221          if test "$ac_compiler_gnu" = yes; then
4222    for ac_link_opt in $ac_ld_run_path; do
4223 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4223 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224    done
4225   else
4226 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4226 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227   fi
4228        ;;
4229   esac
4230 < fi # test "x$F90LIBS" = "x"
4230 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231  
4232   fi
4233 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4234 < echo "${ECHO_T}$ac_cv_flibs" >&6
4235 < F90LIBS="$ac_cv_f90libs"
4233 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4234 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4235 > FCLIBS="$ac_cv_fc_libs"
4236  
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
4237  
4238 + ac_ext=${FC_SRCEXT-f}
4239 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4240 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4241 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4242  
4243 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4244 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4245 < if test "${ac_cv_f90_mangling+set}" = set; then
4243 >
4244 > ac_ext=${FC_SRCEXT-f}
4245 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4246 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4247 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4248 >
4249 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4250 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4251 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4252    echo $ECHO_N "(cached) $ECHO_C" >&6
4253   else
4254 <  ac_ext=f90
4255 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4256 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4257 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4258 < cat >conftest.$ac_ext <<_ACEOF
4259 < subroutine foobar()
4260 < return
4261 < end
4262 < subroutine foo_bar()
4263 < return
4264 < end
4254 >  ac_fc_dm_save_LIBS=$LIBS
4255 > LIBS="$LIBS $FCLIBS"
4256 > ac_fortran_dm_var=FC_DUMMY_MAIN
4257 > ac_ext=c
4258 > ac_cpp='$CPP $CPPFLAGS'
4259 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4260 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4261 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4262 >
4263 > # First, try linking without a dummy main:
4264 > cat >conftest.$ac_ext <<_ACEOF
4265 > /* confdefs.h.  */
4266   _ACEOF
4267 + cat confdefs.h >>conftest.$ac_ext
4268 + cat >>conftest.$ac_ext <<_ACEOF
4269 + /* end confdefs.h.  */
4270 +
4271 + #ifdef FC_DUMMY_MAIN
4272 + #ifndef FC_DUMMY_MAIN_EQ_F77
4273 + #  ifdef __cplusplus
4274 +     extern "C"
4275 + #  endif
4276 +   int FC_DUMMY_MAIN() { return 1; }
4277 + #endif
4278 + #endif
4279 + int
4280 + main ()
4281 + {
4282 +
4283 +  ;
4284 +  return 0;
4285 + }
4286 + _ACEOF
4287 + rm -f conftest.$ac_objext conftest$ac_exeext
4288 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4289 +  (eval $ac_link) 2>conftest.er1
4290 +  ac_status=$?
4291 +  grep -v '^ *+' conftest.er1 >conftest.err
4292 +  rm -f conftest.er1
4293 +  cat conftest.err >&5
4294 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4295 +  (exit $ac_status); } &&
4296 +         { ac_try='test -z "$ac_c_werror_flag"
4297 +                         || test ! -s conftest.err'
4298 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4299 +  (eval $ac_try) 2>&5
4300 +  ac_status=$?
4301 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4302 +  (exit $ac_status); }; } &&
4303 +         { ac_try='test -s conftest$ac_exeext'
4304 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4305 +  (eval $ac_try) 2>&5
4306 +  ac_status=$?
4307 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308 +  (exit $ac_status); }; }; then
4309 +  ac_cv_fortran_dummy_main=none
4310 + else
4311 +  echo "$as_me: failed program was:" >&5
4312 + sed 's/^/| /' conftest.$ac_ext >&5
4313 +
4314 + ac_cv_fortran_dummy_main=unknown
4315 + fi
4316 + rm -f conftest.err conftest.$ac_objext \
4317 +      conftest$ac_exeext conftest.$ac_ext
4318 +
4319 + if test $ac_cv_fortran_dummy_main = unknown; then
4320 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4321 +     cat >conftest.$ac_ext <<_ACEOF
4322 + /* confdefs.h.  */
4323 + _ACEOF
4324 + cat confdefs.h >>conftest.$ac_ext
4325 + cat >>conftest.$ac_ext <<_ACEOF
4326 + /* end confdefs.h.  */
4327 + #define $ac_fortran_dm_var $ac_func
4328 + #ifdef FC_DUMMY_MAIN
4329 + #ifndef FC_DUMMY_MAIN_EQ_F77
4330 + #  ifdef __cplusplus
4331 +     extern "C"
4332 + #  endif
4333 +   int FC_DUMMY_MAIN() { return 1; }
4334 + #endif
4335 + #endif
4336 + int
4337 + main ()
4338 + {
4339 +
4340 +  ;
4341 +  return 0;
4342 + }
4343 + _ACEOF
4344 + rm -f conftest.$ac_objext conftest$ac_exeext
4345 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4346 +  (eval $ac_link) 2>conftest.er1
4347 +  ac_status=$?
4348 +  grep -v '^ *+' conftest.er1 >conftest.err
4349 +  rm -f conftest.er1
4350 +  cat conftest.err >&5
4351 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4352 +  (exit $ac_status); } &&
4353 +         { ac_try='test -z "$ac_c_werror_flag"
4354 +                         || test ! -s conftest.err'
4355 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4356 +  (eval $ac_try) 2>&5
4357 +  ac_status=$?
4358 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4359 +  (exit $ac_status); }; } &&
4360 +         { ac_try='test -s conftest$ac_exeext'
4361 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4362 +  (eval $ac_try) 2>&5
4363 +  ac_status=$?
4364 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4365 +  (exit $ac_status); }; }; then
4366 +  ac_cv_fortran_dummy_main=$ac_func; break
4367 + else
4368 +  echo "$as_me: failed program was:" >&5
4369 + sed 's/^/| /' conftest.$ac_ext >&5
4370 +
4371 + fi
4372 + rm -f conftest.err conftest.$ac_objext \
4373 +      conftest$ac_exeext conftest.$ac_ext
4374 +   done
4375 + fi
4376 + ac_ext=${FC_SRCEXT-f}
4377 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4378 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4379 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4380 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4381 + rm -f conftest*
4382 + LIBS=$ac_fc_dm_save_LIBS
4383 +
4384 + fi
4385 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4386 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4387 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4388 + if test "$FC_DUMMY_MAIN" != unknown; then
4389 +  if test $FC_DUMMY_MAIN != none; then
4390 +
4391 + cat >>confdefs.h <<_ACEOF
4392 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4393 + _ACEOF
4394 +
4395 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4396 +
4397 + cat >>confdefs.h <<\_ACEOF
4398 + #define FC_DUMMY_MAIN_EQ_F77 1
4399 + _ACEOF
4400 +
4401 +  fi
4402 + fi
4403 + else
4404 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4405 + See \`config.log' for more details." >&5
4406 + echo "$as_me: error: linking to Fortran libraries from C fails
4407 + See \`config.log' for more details." >&2;}
4408 +   { (exit 1); exit 1; }; }
4409 + fi
4410 +
4411 +
4412 + ac_ext=${FC_SRCEXT-f}
4413 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4414 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4415 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4416 +
4417 + ac_ext=${FC_SRCEXT-f}
4418 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4419 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4420 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4421 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4422 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4423 + if test "${ac_cv_fc_mangling+set}" = set; then
4424 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4425 + else
4426 +  cat >conftest.$ac_ext <<_ACEOF
4427 +      subroutine foobar()
4428 +      return
4429 +      end
4430 +      subroutine foo_bar()
4431 +      return
4432 +      end
4433 + _ACEOF
4434   rm -f conftest.$ac_objext
4435   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4436    (eval $ac_compile) 2>conftest.er1
# Line 4106 | Line 4440 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4440    cat conftest.err >&5
4441    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442    (exit $ac_status); } &&
4443 <         { ac_try='test -z "$ac_f90_werror_flag"
4443 >         { ac_try='test -z "$ac_fc_werror_flag"
4444                           || test ! -s conftest.err'
4445    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4446    (eval $ac_try) 2>&5
# Line 4119 | Line 4453 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4453    ac_status=$?
4454    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455    (exit $ac_status); }; }; then
4456 <  mv conftest.$ac_objext cf90_test.$ac_objext
4456 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4457  
4458 +  ac_save_LIBS=$LIBS
4459 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4460 +
4461    ac_ext=c
4462   ac_cpp='$CPP $CPPFLAGS'
4463   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4464   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4465   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4129 –
4130 –  ac_save_LIBS=$LIBS
4131 –  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4132 –
4466    ac_success=no
4467    for ac_foobar in foobar FOOBAR; do
4468      for ac_underscore in "" "_"; do
# Line 4148 | Line 4481 | char $ac_func ();
4481   /* We use char because int might match the return type of a gcc2
4482     builtin and then its argument prototype would still apply.  */
4483   char $ac_func ();
4484 + #ifdef FC_DUMMY_MAIN
4485 + #ifndef FC_DUMMY_MAIN_EQ_F77
4486 + #  ifdef __cplusplus
4487 +     extern "C"
4488 + #  endif
4489 +   int FC_DUMMY_MAIN() { return 1; }
4490 + #endif
4491 + #endif
4492   int
4493   main ()
4494   {
# Line 4188 | Line 4529 | rm -f conftest.err conftest.$ac_objext \
4529        conftest$ac_exeext conftest.$ac_ext
4530      done
4531    done
4532 +  ac_ext=${FC_SRCEXT-f}
4533 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4534 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4535 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4536  
4537    if test "$ac_success" = "yes"; then
4538       case $ac_foobar in
4539 <        foobar)
4540 <           ac_case=lower
4541 <           ac_foo_bar=foo_bar
4542 <           ;;
4543 <        FOOBAR)
4544 <           ac_case=upper
4545 <           ac_foo_bar=FOO_BAR
4546 <           ;;
4539 >        foobar)
4540 >           ac_case=lower
4541 >           ac_foo_bar=foo_bar
4542 >           ;;
4543 >        FOOBAR)
4544 >           ac_case=upper
4545 >           ac_foo_bar=FOO_BAR
4546 >           ;;
4547       esac
4548  
4549 +     ac_ext=c
4550 + ac_cpp='$CPP $CPPFLAGS'
4551 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4552 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4553 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4554       ac_success_extra=no
4555       for ac_extra in "" "_"; do
4556 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557 <
4208 <        cat >conftest.$ac_ext <<_ACEOF
4556 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557 >        cat >conftest.$ac_ext <<_ACEOF
4558   /* confdefs.h.  */
4559   _ACEOF
4560   cat confdefs.h >>conftest.$ac_ext
# Line 4219 | Line 4568 | char $ac_func ();
4568   /* We use char because int might match the return type of a gcc2
4569     builtin and then its argument prototype would still apply.  */
4570   char $ac_func ();
4571 + #ifdef FC_DUMMY_MAIN
4572 + #ifndef FC_DUMMY_MAIN_EQ_F77
4573 + #  ifdef __cplusplus
4574 +     extern "C"
4575 + #  endif
4576 +   int FC_DUMMY_MAIN() { return 1; }
4577 + #endif
4578 + #endif
4579   int
4580   main ()
4581   {
# Line 4258 | Line 4615 | rm -f conftest.err conftest.$ac_objext \
4615   rm -f conftest.err conftest.$ac_objext \
4616        conftest$ac_exeext conftest.$ac_ext
4617       done
4618 +     ac_ext=${FC_SRCEXT-f}
4619 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4620 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4621 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4622  
4623       if test "$ac_success_extra" = "yes"; then
4624 <        ac_cv_f90_mangling="$ac_case case"
4624 >        ac_cv_fc_mangling="$ac_case case"
4625          if test -z "$ac_underscore"; then
4626 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4626 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627          else
4628 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4268 <
4628 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629          fi
4630          if test -z "$ac_extra"; then
4631 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4631 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632          else
4633 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4633 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634          fi
4635        else
4636 <        ac_cv_f90_mangling="unknown"
4636 >        ac_cv_fc_mangling="unknown"
4637        fi
4638    else
4639 <     ac_cv_f90_mangling="unknown"
4280 <
4639 >     ac_cv_fc_mangling="unknown"
4640    fi
4641  
4642    LIBS=$ac_save_LIBS
4643 <  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*
4643 >  rm -f cfortran_test* conftest*
4644   else
4645    echo "$as_me: failed program was:" >&5
4646   sed 's/^/| /' conftest.$ac_ext >&5
4647  
4648 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4649 + See \`config.log' for more details." >&5
4650 + echo "$as_me: error: cannot compile a simple Fortran program
4651 + See \`config.log' for more details." >&2;}
4652 +   { (exit 1); exit 1; }; }
4653   fi
4654   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
4655  
4656   fi
4657 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4658 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4657 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4658 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4659  
4660 + ac_ext=${FC_SRCEXT-f}
4661 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664  
4665 + ac_ext=${FC_SRCEXT-f}
4666 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4667 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4668 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4669  
4670 < case $ac_cv_f90_mangling in
4670 >
4671 > case $ac_cv_fc_mangling in
4672    "lower case, no underscore, no extra underscore")
4673            cat >>confdefs.h <<\_ACEOF
4674 < #define F90_FUNC(name,NAME) name
4674 > #define FC_FUNC(name,NAME) name
4675   _ACEOF
4676  
4677            cat >>confdefs.h <<\_ACEOF
4678 < #define F90_FUNC_(name,NAME) name
4678 > #define FC_FUNC_(name,NAME) name
4679   _ACEOF
4680   ;;
4681    "lower case, no underscore, extra underscore")
4682            cat >>confdefs.h <<\_ACEOF
4683 < #define F90_FUNC(name,NAME) name
4683 > #define FC_FUNC(name,NAME) name
4684   _ACEOF
4685  
4686            cat >>confdefs.h <<\_ACEOF
4687 < #define F90_FUNC_(name,NAME) name ## _
4687 > #define FC_FUNC_(name,NAME) name ## _
4688   _ACEOF
4689   ;;
4690    "lower case, underscore, no extra underscore")
4691            cat >>confdefs.h <<\_ACEOF
4692 < #define F90_FUNC(name,NAME) name ## _
4692 > #define FC_FUNC(name,NAME) name ## _
4693   _ACEOF
4694  
4695            cat >>confdefs.h <<\_ACEOF
4696 < #define F90_FUNC_(name,NAME) name ## _
4696 > #define FC_FUNC_(name,NAME) name ## _
4697   _ACEOF
4698   ;;
4699    "lower case, underscore, extra underscore")
4700            cat >>confdefs.h <<\_ACEOF
4701 < #define F90_FUNC(name,NAME) name ## _
4701 > #define FC_FUNC(name,NAME) name ## _
4702   _ACEOF
4703  
4704            cat >>confdefs.h <<\_ACEOF
4705 < #define F90_FUNC_(name,NAME) name ## __
4705 > #define FC_FUNC_(name,NAME) name ## __
4706   _ACEOF
4707   ;;
4708    "upper case, no underscore, no extra underscore")
4709            cat >>confdefs.h <<\_ACEOF
4710 < #define F90_FUNC(name,NAME) NAME
4710 > #define FC_FUNC(name,NAME) NAME
4711   _ACEOF
4712  
4713            cat >>confdefs.h <<\_ACEOF
4714 < #define F90_FUNC_(name,NAME) NAME
4714 > #define FC_FUNC_(name,NAME) NAME
4715   _ACEOF
4716   ;;
4717    "upper case, no underscore, extra underscore")
4718            cat >>confdefs.h <<\_ACEOF
4719 < #define F90_FUNC(name,NAME) NAME
4719 > #define FC_FUNC(name,NAME) NAME
4720   _ACEOF
4721  
4722            cat >>confdefs.h <<\_ACEOF
4723 < #define F90_FUNC_(name,NAME) NAME ## _
4723 > #define FC_FUNC_(name,NAME) NAME ## _
4724   _ACEOF
4725   ;;
4726    "upper case, underscore, no extra underscore")
4727            cat >>confdefs.h <<\_ACEOF
4728 < #define F90_FUNC(name,NAME) NAME ## _
4728 > #define FC_FUNC(name,NAME) NAME ## _
4729   _ACEOF
4730  
4731            cat >>confdefs.h <<\_ACEOF
4732 < #define F90_FUNC_(name,NAME) NAME ## _
4732 > #define FC_FUNC_(name,NAME) NAME ## _
4733   _ACEOF
4734   ;;
4735    "upper case, underscore, extra underscore")
4736            cat >>confdefs.h <<\_ACEOF
4737 < #define F90_FUNC(name,NAME) NAME ## _
4737 > #define FC_FUNC(name,NAME) NAME ## _
4738   _ACEOF
4739  
4740            cat >>confdefs.h <<\_ACEOF
4741 < #define F90_FUNC_(name,NAME) NAME ## __
4741 > #define FC_FUNC_(name,NAME) NAME ## __
4742   _ACEOF
4743   ;;
4744    *)
4745 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4746 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4745 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4746 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4747 >          ;;
4748 > esac
4749 >
4750 > ac_ext=${FC_SRCEXT-f}
4751 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4752 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4753 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4754 >
4755 >
4756 >
4757 > ac_ext=${FC_SRCEXT-f}
4758 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4759 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4760 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4762 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4763 > if test "${ac_cv_prog_fc_v+set}" = set; then
4764 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4765 > else
4766 >  cat >conftest.$ac_ext <<_ACEOF
4767 >      program main
4768 >
4769 >      end
4770 > _ACEOF
4771 > rm -f conftest.$ac_objext
4772 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4773 >  (eval $ac_compile) 2>conftest.er1
4774 >  ac_status=$?
4775 >  grep -v '^ *+' conftest.er1 >conftest.err
4776 >  rm -f conftest.er1
4777 >  cat conftest.err >&5
4778 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4779 >  (exit $ac_status); } &&
4780 >         { ac_try='test -z "$ac_fc_werror_flag"
4781 >                         || test ! -s conftest.err'
4782 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4783 >  (eval $ac_try) 2>&5
4784 >  ac_status=$?
4785 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4786 >  (exit $ac_status); }; } &&
4787 >         { ac_try='test -s conftest.$ac_objext'
4788 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4789 >  (eval $ac_try) 2>&5
4790 >  ac_status=$?
4791 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4792 >  (exit $ac_status); }; }; then
4793 >  ac_cv_prog_fc_v=
4794 > # Try some options frequently used verbose output
4795 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4796 >  cat >conftest.$ac_ext <<_ACEOF
4797 >      program main
4798 >
4799 >      end
4800 > _ACEOF
4801 >
4802 > # Compile and link our simple test program by passing a flag (argument
4803 > # 1 to this macro) to the Fortran compiler in order to get
4804 > # "verbose" output that we can then parse for the Fortran linker
4805 > # flags.
4806 > ac_save_FFLAGS=$FCFLAGS
4807 > FCFLAGS="$FCFLAGS $ac_verb"
4808 > (eval echo $as_me:4808: \"$ac_link\") >&5
4809 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4810 > echo "$ac_fc_v_output" >&5
4811 > FCFLAGS=$ac_save_FFLAGS
4812 >
4813 > rm -f conftest*
4814 >
4815 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4816 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4817 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4818 > ac_fc_v_output="`echo $ac_fc_v_output |
4819 >        grep 'LPATH is:' |
4820 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4821 >
4822 > case $ac_fc_v_output in
4823 >  # If we are using xlf then replace all the commas with spaces.
4824 >  *xlfentry*)
4825 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4826 >
4827 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4828 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4829 >  *mGLOB_options_string*)
4830 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4831 >
4832 >  # If we are using Cray Fortran then delete quotes.
4833 >  # Use "\"" instead of '"' for font-lock-mode.
4834 >  # FIXME: a more general fix for quoted arguments with spaces?
4835 >  *cft90*)
4836 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4837 > esac
4838 >
4839 >
4840 >  # look for -l* and *.a constructs in the output
4841 >  for ac_arg in $ac_fc_v_output; do
4842 >     case $ac_arg in
4843 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4844 >          ac_cv_prog_fc_v=$ac_verb
4845 >          break 2 ;;
4846 >     esac
4847 >  done
4848 > done
4849 > if test -z "$ac_cv_prog_fc_v"; then
4850 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4851 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4852 > fi
4853 > else
4854 >  echo "$as_me: failed program was:" >&5
4855 > sed 's/^/| /' conftest.$ac_ext >&5
4856 >
4857 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4858 > echo "$as_me: WARNING: compilation failed" >&2;}
4859 > fi
4860 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4861 >
4862 > fi
4863 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4864 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4865 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4866 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4867 > if test "${ac_cv_fc_libs+set}" = set; then
4868 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4869 > else
4870 >  if test "x$FCLIBS" != "x"; then
4871 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4872 > else
4873 >
4874 > cat >conftest.$ac_ext <<_ACEOF
4875 >      program main
4876 >
4877 >      end
4878 > _ACEOF
4879 >
4880 > # Compile and link our simple test program by passing a flag (argument
4881 > # 1 to this macro) to the Fortran compiler in order to get
4882 > # "verbose" output that we can then parse for the Fortran linker
4883 > # flags.
4884 > ac_save_FFLAGS=$FCFLAGS
4885 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4886 > (eval echo $as_me:4886: \"$ac_link\") >&5
4887 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4888 > echo "$ac_fc_v_output" >&5
4889 > FCFLAGS=$ac_save_FFLAGS
4890 >
4891 > rm -f conftest*
4892 >
4893 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4894 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4895 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4896 > ac_fc_v_output="`echo $ac_fc_v_output |
4897 >        grep 'LPATH is:' |
4898 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4899 >
4900 > case $ac_fc_v_output in
4901 >  # If we are using xlf then replace all the commas with spaces.
4902 >  *xlfentry*)
4903 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4904 >
4905 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4906 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4907 >  *mGLOB_options_string*)
4908 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4909 >
4910 >  # If we are using Cray Fortran then delete quotes.
4911 >  # Use "\"" instead of '"' for font-lock-mode.
4912 >  # FIXME: a more general fix for quoted arguments with spaces?
4913 >  *cft90*)
4914 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4915 > esac
4916 >
4917 >
4918 >
4919 > ac_cv_fc_libs=
4920 >
4921 > # Save positional arguments (if any)
4922 > ac_save_positional="$@"
4923 >
4924 > set X $ac_fc_v_output
4925 > while test $# != 1; do
4926 >  shift
4927 >  ac_arg=$1
4928 >  case $ac_arg in
4929 >        [\\/]*.a | ?:[\\/]*.a)
4930 >            ac_exists=false
4931 >  for ac_i in $ac_cv_fc_libs; do
4932 >    if test x"$ac_arg" = x"$ac_i"; then
4933 >      ac_exists=true
4934 >      break
4935 >    fi
4936 >  done
4937 >
4938 >  if test x"$ac_exists" = xtrue; then
4939 >  :
4940 > else
4941 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4942 > fi
4943 >
4944            ;;
4945 +        -bI:*)
4946 +            ac_exists=false
4947 +  for ac_i in $ac_cv_fc_libs; do
4948 +    if test x"$ac_arg" = x"$ac_i"; then
4949 +      ac_exists=true
4950 +      break
4951 +    fi
4952 +  done
4953 +
4954 +  if test x"$ac_exists" = xtrue; then
4955 +  :
4956 + else
4957 +  if test "$ac_compiler_gnu" = yes; then
4958 +  for ac_link_opt in $ac_arg; do
4959 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4960 +  done
4961 + else
4962 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4963 + fi
4964 + fi
4965 +
4966 +          ;;
4967 +          # Ignore these flags.
4968 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4969 +          ;;
4970 +        -lkernel32)
4971 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4972 +          ;;
4973 +        -[LRuY])
4974 +          # These flags, when seen by themselves, take an argument.
4975 +          # We remove the space between option and argument and re-iterate
4976 +          # unless we find an empty arg or a new option (starting with -)
4977 +          case $2 in
4978 +             "" | -*);;
4979 +             *)
4980 +                ac_arg="$ac_arg$2"
4981 +                shift; shift
4982 +                set X $ac_arg "$@"
4983 +                ;;
4984 +          esac
4985 +          ;;
4986 +        -YP,*)
4987 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4988 +              ac_exists=false
4989 +  for ac_i in $ac_cv_fc_libs; do
4990 +    if test x"$ac_j" = x"$ac_i"; then
4991 +      ac_exists=true
4992 +      break
4993 +    fi
4994 +  done
4995 +
4996 +  if test x"$ac_exists" = xtrue; then
4997 +  :
4998 + else
4999 +  ac_arg="$ac_arg $ac_j"
5000 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5001 + fi
5002 +
5003 +          done
5004 +          ;;
5005 +        -[lLR]*)
5006 +            ac_exists=false
5007 +  for ac_i in $ac_cv_fc_libs; do
5008 +    if test x"$ac_arg" = x"$ac_i"; then
5009 +      ac_exists=true
5010 +      break
5011 +    fi
5012 +  done
5013 +
5014 +  if test x"$ac_exists" = xtrue; then
5015 +  :
5016 + else
5017 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5018 + fi
5019 +
5020 +          ;;
5021 +          # Ignore everything else.
5022 +  esac
5023 + done
5024 + # restore positional arguments
5025 + set X $ac_save_positional; shift
5026 +
5027 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5028 + # then we insist that the "run path" must be an absolute path (i.e. it
5029 + # must begin with a "/").
5030 + case `(uname -sr) 2>/dev/null` in
5031 +   "SunOS 5"*)
5032 +      ac_ld_run_path=`echo $ac_fc_v_output |
5033 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5034 +      test "x$ac_ld_run_path" != x &&
5035 +        if test "$ac_compiler_gnu" = yes; then
5036 +  for ac_link_opt in $ac_ld_run_path; do
5037 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5038 +  done
5039 + else
5040 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5041 + fi
5042 +      ;;
5043   esac
5044 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5045  
5046 + fi
5047 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5048 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5049 + FCLIBS="$ac_cv_fc_libs"
5050  
5051  
5052 + ac_ext=${FC_SRCEXT-f}
5053 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5054 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5055 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5056  
5057  
5058 +
5059   echo "$as_me:$LINENO: checking for module suffix" >&5
5060   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5061   rm -f conftest*
5062   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5063   rm -f work*
5064 < cat >conftest.f90 <<EOF
5064 > cat >conftest.$ac_ext <<EOF
5065          module conftest
5066          integer n
5067          parameter (n=1)
# Line 4400 | Line 5070 | modcase="lower"
5070   # SGI and absoft compilers generates module name in upper case!
5071   testname="conftest"
5072   modcase="lower"
5073 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5074 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5073 > if (eval $ac_compile) 2>/dev/null ; then
5074 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5075      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5076      if test -z "$MOD" ; then
5077          MOD=`ls CONFTEST* 2>/dev/null \
5078 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5078 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5079          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5080          if test -n "$MOD" ; then
5081              testname="CONFTEST"
# Line 4445 | Line 5115 | rm -f work*
5115   rm -f conftest*
5116   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5117   rm -f work*
5118 < cat >conftest.f90 <<EOF
5118 > cat >conftest.$ac_ext <<EOF
5119          module conftest
5120          integer n
5121          parameter (n=1)
# Line 4453 | Line 5123 | testname="conftest"
5123   EOF
5124   # SGI and absoft compilers generates module name in upper case!
5125   testname="conftest"
5126 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5127 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5126 > if (eval $ac_compile) 2>/dev/null ; then
5127 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5128     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5129     if test -n "$mod" ; then
5130        testname="CONFTEST"
# Line 4463 | Line 5133 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5133     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134     cp $testname.$MOD conf
5135     rm -f conftest* CONFTEST*
5136 <   cat >conftest1.f90 <<EOF
5136 >   cat >conftest1.$ac_ext <<EOF
5137          program main
5138          use conftest
5139          print *, n
# Line 4471 | Line 5141 | EOF
5141   EOF
5142     F90_WORK_FILES_ARG=""
5143     F90MODINCSPEC=""
5144 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5144 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5145         MODDIRFLAG="-I"
5146         F90MODINCSPEC="-I<dir>"
5147         echo "$as_me:$LINENO: result: -I" >&5
5148   echo "${ECHO_T}-I" >&6
5149 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5149 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5150         MODDIRFLAG="-M"
5151         F90MODINCSPEC="-M<dir>"
5152         echo "$as_me:$LINENO: result: -M" >&5
5153   echo "${ECHO_T}-M" >&6
5154 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5154 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5155         MODDIRFLAG="-p"
5156         F90MODINCSPEC="-p<dir>"
5157         echo "$as_me:$LINENO: result: -p" >&5
# Line 4490 | Line 5160 | echo "${ECHO_T}-p" >&6
5160          cp work.pc conf/mpimod.pc
5161          echo "mpimod.pc" > conf/mpimod.pcl
5162          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5163 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5163 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5164              MODDIRFLAG='-cl,mpimod.pcl'
5165              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5166   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4520 | Line 5190 | else
5190   if test "${ac_cv_f90_module_names+set}" = set; then
5191    echo $ECHO_N "(cached) $ECHO_C" >&6
5192   else
5193 <  ac_ext=f90
5194 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5195 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5196 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5193 >  ac_ext=${FC_SRCEXT-f}
5194 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5195 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5196 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5197  
5198   # carry out the test in a new directory, so that we don't miss anything
5199   mkdir conftest
# Line 4541 | Line 5211 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5211    cat conftest.err >&5
5212    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213    (exit $ac_status); } &&
5214 <         { ac_try='test -z "$ac_f90_werror_flag"
5214 >         { ac_try='test -z "$ac_fc_werror_flag"
5215                           || test ! -s conftest.err'
5216    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5217    (eval $ac_try) 2>&5
# Line 4657 | Line 5327 | rm -rf conftest
5327   cd ..
5328   # cleanup
5329   rm -rf conftest
5330 < ac_ext=f90
5331 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5332 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5333 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5330 > ac_ext=${FC_SRCEXT-f}
5331 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5332 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5333 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5334  
5335   fi
5336   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4749 | Line 5419 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5419   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420  
5421  
5422 < ac_ext=cc
5423 < ac_cpp='$CXXCPP $CPPFLAGS'
5424 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5422 > ac_ext=c
5423 > ac_cpp='$CPP $CPPFLAGS'
5424 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5427  
5428  
5429 < ac_ext=cc
5430 < ac_cpp='$CXXCPP $CPPFLAGS'
5431 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5432 < 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
5429 >
5430 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5431 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5432 > if test "${ac_cv_lib_m_asin+set}" = set; then
5433    echo $ECHO_N "(cached) $ECHO_C" >&6
5434   else
5435 <      # Double quotes because CXXCPP needs to be expanded
5436 <    for CXXCPP in "$CXX -E" "/lib/cpp"
5437 <    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
5435 >  ac_check_lib_save_LIBS=$LIBS
5436 > LIBS="-lm  $LIBS"
5437 > cat >conftest.$ac_ext <<_ACEOF
5438   /* confdefs.h.  */
5439   _ACEOF
5440   cat confdefs.h >>conftest.$ac_ext
5441   cat >>conftest.$ac_ext <<_ACEOF
5442   /* end confdefs.h.  */
5443 < #ifdef __STDC__
5444 < # include <limits.h>
5445 < #else
5446 < # include <assert.h>
5443 >
5444 > /* Override any gcc2 internal prototype to avoid an error.  */
5445 > #ifdef __cplusplus
5446 > extern "C"
5447   #endif
5448 <                     Syntax error
5448 > /* We use char because int might match the return type of a gcc2
5449 >   builtin and then its argument prototype would still apply.  */
5450 > char asin ();
5451 > #ifdef FC_DUMMY_MAIN
5452 > #ifndef FC_DUMMY_MAIN_EQ_F77
5453 > #  ifdef __cplusplus
5454 >     extern "C"
5455 > #  endif
5456 >   int FC_DUMMY_MAIN() { return 1; }
5457 > #endif
5458 > #endif
5459 > int
5460 > main ()
5461 > {
5462 > asin ();
5463 >  ;
5464 >  return 0;
5465 > }
5466   _ACEOF
5467 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5468 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5467 > rm -f conftest.$ac_objext conftest$ac_exeext
5468 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5469 >  (eval $ac_link) 2>conftest.er1
5470    ac_status=$?
5471    grep -v '^ *+' conftest.er1 >conftest.err
5472    rm -f conftest.er1
5473    cat conftest.err >&5
5474    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475 <  (exit $ac_status); } >/dev/null; then
5476 <  if test -s conftest.err; then
5477 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5478 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5479 <  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
5475 >  (exit $ac_status); } &&
5476 >         { ac_try='test -z "$ac_c_werror_flag"
5477 >                         || test ! -s conftest.err'
5478 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5479 >  (eval $ac_try) 2>&5
5480    ac_status=$?
4836 –  grep -v '^ *+' conftest.er1 >conftest.err
4837 –  rm -f conftest.er1
4838 –  cat conftest.err >&5
5481    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5482 <  (exit $ac_status); } >/dev/null; then
5483 <  if test -s conftest.err; then
5484 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5485 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5486 <  else
5487 <    ac_cpp_err=
5488 <  fi
5482 >  (exit $ac_status); }; } &&
5483 >         { ac_try='test -s conftest$ac_exeext'
5484 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5485 >  (eval $ac_try) 2>&5
5486 >  ac_status=$?
5487 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5488 >  (exit $ac_status); }; }; then
5489 >  ac_cv_lib_m_asin=yes
5490   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
5491    echo "$as_me: failed program was:" >&5
5492   sed 's/^/| /' conftest.$ac_ext >&5
5493  
5494 <  # Passes both tests.
4858 < ac_preproc_ok=:
4859 < break
5494 > ac_cv_lib_m_asin=no
5495   fi
5496 < rm -f conftest.err conftest.$ac_ext
5497 <
5498 < 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
5496 > rm -f conftest.err conftest.$ac_objext \
5497 >      conftest$ac_exeext conftest.$ac_ext
5498 > LIBS=$ac_check_lib_save_LIBS
5499   fi
5500 + echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5501 + echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5502 + if test $ac_cv_lib_m_asin = yes; then
5503 +  cat >>confdefs.h <<_ACEOF
5504 + #define HAVE_LIBM 1
5505 + _ACEOF
5506  
5507 <    done
4871 <    ac_cv_prog_CXXCPP=$CXXCPP
5507 >  LIBS="-lm $LIBS"
5508  
4873 – fi
4874 –  CXXCPP=$ac_cv_prog_CXXCPP
5509   else
5510 <  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
5510 >  exit
5511   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
5512  
4925 –  # Broken: fails on valid input.
4926 – continue
4927 – fi
4928 – rm -f conftest.err conftest.$ac_ext
5513  
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 –
5514   echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5515   echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5516   if test "${ac_cv_header_stdc+set}" = set; then
# Line 5003 | Line 5527 | cat >>conftest.$ac_ext <<_ACEOF
5527   #include <string.h>
5528   #include <float.h>
5529  
5530 + #ifdef FC_DUMMY_MAIN
5531 + #ifndef FC_DUMMY_MAIN_EQ_F77
5532 + #  ifdef __cplusplus
5533 +     extern "C"
5534 + #  endif
5535 +   int FC_DUMMY_MAIN() { return 1; }
5536 + #endif
5537 + #endif
5538   int
5539   main ()
5540   {
# Line 5020 | Line 5552 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5552    cat conftest.err >&5
5553    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554    (exit $ac_status); } &&
5555 <         { ac_try='test -z "$ac_cxx_werror_flag"
5555 >         { ac_try='test -z "$ac_c_werror_flag"
5556                           || test ! -s conftest.err'
5557    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5558    (eval $ac_try) 2>&5
# Line 5149 | Line 5681 | cat >>confdefs.h <<\_ACEOF
5681  
5682   cat >>confdefs.h <<\_ACEOF
5683   #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
5684   _ACEOF
5685  
5686   fi
# Line 5267 | Line 5723 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5723    cat conftest.err >&5
5724    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725    (exit $ac_status); } &&
5726 <         { ac_try='test -z "$ac_cxx_werror_flag"
5726 >         { ac_try='test -z "$ac_c_werror_flag"
5727                           || test ! -s conftest.err'
5728    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5729    (eval $ac_try) 2>&5
# Line 5301 | Line 5757 | done
5757   done
5758  
5759  
5760 < echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
5761 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
5762 < if test "${ac_cv_cxx_have_stl+set}" = set; then
5763 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5760 > #
5761 > # Handle user hints
5762 > #
5763 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5764 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5765 >
5766 > # Check whether --with-zlib or --without-zlib was given.
5767 > if test "${with_zlib+set}" = set; then
5768 >  withval="$with_zlib"
5769 >  if test "$withval" != no ; then
5770 >  echo "$as_me:$LINENO: result: yes" >&5
5771 > echo "${ECHO_T}yes" >&6
5772 >  if test -d "$withval"
5773 >  then
5774 >    ZLIB_HOME="$withval"
5775 >  else
5776 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5777 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5778 >  fi
5779   else
5780 +  echo "$as_me:$LINENO: result: no" >&5
5781 + echo "${ECHO_T}no" >&6
5782 + fi
5783 + fi;
5784  
5785 + ZLIB_HOME=/usr/local
5786 + if test ! -f "${ZLIB_HOME}/include/zlib.h"
5787 + then
5788 +        ZLIB_HOME=/usr
5789 + fi
5790  
5791 + #
5792 + # Locate zlib, if wanted
5793 + #
5794 + if test -n "${ZLIB_HOME}"
5795 + then
5796 +        ZLIB_OLD_LDFLAGS=$LDFLAGS
5797 +        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5798 +        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5799 +        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5800  
5312 – ac_ext=cc
5313 – ac_cpp='$CXXCPP $CPPFLAGS'
5314 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5315 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5316 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5801  
5802 < cat >conftest.$ac_ext <<_ACEOF
5802 >        ac_ext=c
5803 > ac_cpp='$CPP $CPPFLAGS'
5804 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5805 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5806 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5807 >
5808 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5809 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5810 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5811 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5812 > else
5813 >  ac_check_lib_save_LIBS=$LIBS
5814 > LIBS="-lz  $LIBS"
5815 > cat >conftest.$ac_ext <<_ACEOF
5816   /* confdefs.h.  */
5817   _ACEOF
5818   cat confdefs.h >>conftest.$ac_ext
5819   cat >>conftest.$ac_ext <<_ACEOF
5820   /* end confdefs.h.  */
5821 < #include <list>
5822 < #include <deque>
5823 < #ifdef HAVE_NAMESPACES
5824 < using namespace std;
5821 >
5822 > /* Override any gcc2 internal prototype to avoid an error.  */
5823 > #ifdef __cplusplus
5824 > extern "C"
5825   #endif
5826 + /* We use char because int might match the return type of a gcc2
5827 +   builtin and then its argument prototype would still apply.  */
5828 + char inflateEnd ();
5829 + #ifdef FC_DUMMY_MAIN
5830 + #ifndef FC_DUMMY_MAIN_EQ_F77
5831 + #  ifdef __cplusplus
5832 +     extern "C"
5833 + #  endif
5834 +   int FC_DUMMY_MAIN() { return 1; }
5835 + #endif
5836 + #endif
5837   int
5838   main ()
5839   {
5840 < list<int> x; x.push_back(5);
5333 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
5840 > inflateEnd ();
5841    ;
5842    return 0;
5843   }
5844   _ACEOF
5845 < rm -f conftest.$ac_objext
5846 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5847 <  (eval $ac_compile) 2>conftest.er1
5845 > rm -f conftest.$ac_objext conftest$ac_exeext
5846 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5847 >  (eval $ac_link) 2>conftest.er1
5848    ac_status=$?
5849    grep -v '^ *+' conftest.er1 >conftest.err
5850    rm -f conftest.er1
5851    cat conftest.err >&5
5852    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5853    (exit $ac_status); } &&
5854 <         { ac_try='test -z "$ac_cxx_werror_flag"
5854 >         { ac_try='test -z "$ac_c_werror_flag"
5855                           || test ! -s conftest.err'
5856    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5857    (eval $ac_try) 2>&5
5858    ac_status=$?
5859    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5860    (exit $ac_status); }; } &&
5861 <         { ac_try='test -s conftest.$ac_objext'
5861 >         { ac_try='test -s conftest$ac_exeext'
5862    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5863    (eval $ac_try) 2>&5
5864    ac_status=$?
5865    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5866    (exit $ac_status); }; }; then
5867 <  ac_cv_cxx_have_stl=yes
5867 >  ac_cv_lib_z_inflateEnd=yes
5868   else
5869    echo "$as_me: failed program was:" >&5
5870   sed 's/^/| /' conftest.$ac_ext >&5
5364 –
5365 – 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
5871  
5872 <
5872 > ac_cv_lib_z_inflateEnd=no
5873   fi
5874 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
5875 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
5876 < if test "$ac_cv_cxx_have_stl" = yes; then
5379 <
5380 < cat >>confdefs.h <<\_ACEOF
5381 < #define HAVE_STL
5382 < _ACEOF
5383 <
5874 > rm -f conftest.err conftest.$ac_objext \
5875 >      conftest$ac_exeext conftest.$ac_ext
5876 > LIBS=$ac_check_lib_save_LIBS
5877   fi
5878 + echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5879 + echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5880 + if test $ac_cv_lib_z_inflateEnd = yes; then
5881 +  zlib_cv_libz=yes
5882 + else
5883 +  zlib_cv_libz=no
5884 + fi
5885  
5886 <
5887 <
5888 <  if test "${ac_cv_header_iostream+set}" = set; then
5889 <  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
5886 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5887 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5888 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5889 > if test "${ac_cv_header_zlib_h+set}" = set; then
5890    echo $ECHO_N "(cached) $ECHO_C" >&6
5891   fi
5892 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
5893 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
5892 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5893 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5894   else
5895    # Is the header compilable?
5896 < echo "$as_me:$LINENO: checking iostream usability" >&5
5897 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
5896 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5897 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5898   cat >conftest.$ac_ext <<_ACEOF
5899   /* confdefs.h.  */
5900   _ACEOF
# Line 5404 | Line 5902 | $ac_includes_default
5902   cat >>conftest.$ac_ext <<_ACEOF
5903   /* end confdefs.h.  */
5904   $ac_includes_default
5905 < #include <iostream>
5905 > #include <zlib.h>
5906   _ACEOF
5907   rm -f conftest.$ac_objext
5908   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5415 | Line 5913 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5913    cat conftest.err >&5
5914    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915    (exit $ac_status); } &&
5916 <         { ac_try='test -z "$ac_cxx_werror_flag"
5916 >         { ac_try='test -z "$ac_c_werror_flag"
5917                           || test ! -s conftest.err'
5918    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5919    (eval $ac_try) 2>&5
# Line 5440 | Line 5938 | echo "${ECHO_T}$ac_header_compiler" >&6
5938   echo "${ECHO_T}$ac_header_compiler" >&6
5939  
5940   # Is the header present?
5941 < echo "$as_me:$LINENO: checking iostream presence" >&5
5942 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
5941 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5942 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5943   cat >conftest.$ac_ext <<_ACEOF
5944   /* confdefs.h.  */
5945   _ACEOF
5946   cat confdefs.h >>conftest.$ac_ext
5947   cat >>conftest.$ac_ext <<_ACEOF
5948   /* end confdefs.h.  */
5949 < #include <iostream>
5949 > #include <zlib.h>
5950   _ACEOF
5951   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5952    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5459 | Line 5957 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
5957    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5958    (exit $ac_status); } >/dev/null; then
5959    if test -s conftest.err; then
5960 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5961 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5960 >    ac_cpp_err=$ac_c_preproc_warn_flag
5961 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5962    else
5963      ac_cpp_err=
5964    fi
# Line 5480 | Line 5978 | echo "${ECHO_T}$ac_header_preproc" >&6
5978   echo "${ECHO_T}$ac_header_preproc" >&6
5979  
5980   # So?  What about this header?
5981 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
5981 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982    yes:no: )
5983 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
5984 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
5986 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
5983 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5984 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5986 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5987      ac_header_preproc=yes
5988      ;;
5989    no:yes:* )
5990 <    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
5991 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
5992 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
5993 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
5994 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
5995 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
5996 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
5997 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
5998 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
5999 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
6000 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
6001 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
5990 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5991 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5992 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5993 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5994 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5995 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5996 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5997 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5998 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5999 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6000 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6001 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6002      (
6003        cat <<\_ASBOX
6004   ## ------------------------------ ##
# Line 5511 | Line 6009 | esac
6009        sed "s/^/$as_me: WARNING:     /" >&2
6010      ;;
6011   esac
6012 < echo "$as_me:$LINENO: checking for iostream" >&5
6013 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
6014 < if test "${ac_cv_header_iostream+set}" = set; then
6012 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6013 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014 > if test "${ac_cv_header_zlib_h+set}" = set; then
6015    echo $ECHO_N "(cached) $ECHO_C" >&6
6016   else
6017 <  ac_cv_header_iostream=$ac_header_preproc
6017 >  ac_cv_header_zlib_h=$ac_header_preproc
6018   fi
6019 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6020 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
6019 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6020 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6021  
6022   fi
6023 < if test $ac_cv_header_iostream = yes; then
6023 > if test $ac_cv_header_zlib_h = yes; then
6024 >  zlib_cv_zlib_h=yes
6025 > else
6026 >  zlib_cv_zlib_h=no
6027 > fi
6028  
6029  
6030 < cat >>confdefs.h <<\_ACEOF
6031 < #define HAVE_IOSTREAM 1
6032 < _ACEOF
6030 >        ac_ext=c
6031 > ac_cpp='$CPP $CPPFLAGS'
6032 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6033 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6035  
6036 +        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6037 +        then
6038 +                #
6039 +                # If both library and header were found, use them
6040 +                #
6041  
6042 < else
6043 <
6044 <
5536 < for ac_header in iostream.h
5537 < do
5538 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5539 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5540 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5541 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5542 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6042 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6043 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6044 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6045    echo $ECHO_N "(cached) $ECHO_C" >&6
5544 – fi
5545 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5546 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6046   else
6047 <  # Is the header compilable?
6048 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5550 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6047 >  ac_check_lib_save_LIBS=$LIBS
6048 > LIBS="-lz  $LIBS"
6049   cat >conftest.$ac_ext <<_ACEOF
6050   /* confdefs.h.  */
6051   _ACEOF
6052   cat confdefs.h >>conftest.$ac_ext
6053   cat >>conftest.$ac_ext <<_ACEOF
6054   /* end confdefs.h.  */
6055 < $ac_includes_default
6056 < #include <$ac_header>
6055 >
6056 > /* Override any gcc2 internal prototype to avoid an error.  */
6057 > #ifdef __cplusplus
6058 > extern "C"
6059 > #endif
6060 > /* We use char because int might match the return type of a gcc2
6061 >   builtin and then its argument prototype would still apply.  */
6062 > char inflateEnd ();
6063 > #ifdef FC_DUMMY_MAIN
6064 > #ifndef FC_DUMMY_MAIN_EQ_F77
6065 > #  ifdef __cplusplus
6066 >     extern "C"
6067 > #  endif
6068 >   int FC_DUMMY_MAIN() { return 1; }
6069 > #endif
6070 > #endif
6071 > int
6072 > main ()
6073 > {
6074 > inflateEnd ();
6075 >  ;
6076 >  return 0;
6077 > }
6078   _ACEOF
6079 < rm -f conftest.$ac_objext
6080 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6081 <  (eval $ac_compile) 2>conftest.er1
6079 > rm -f conftest.$ac_objext conftest$ac_exeext
6080 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6081 >  (eval $ac_link) 2>conftest.er1
6082    ac_status=$?
6083    grep -v '^ *+' conftest.er1 >conftest.err
6084    rm -f conftest.er1
6085    cat conftest.err >&5
6086    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6087    (exit $ac_status); } &&
6088 <         { ac_try='test -z "$ac_cxx_werror_flag"
6088 >         { ac_try='test -z "$ac_c_werror_flag"
6089                           || test ! -s conftest.err'
6090    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6091    (eval $ac_try) 2>&5
6092    ac_status=$?
6093    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6094    (exit $ac_status); }; } &&
6095 <         { ac_try='test -s conftest.$ac_objext'
6095 >         { ac_try='test -s conftest$ac_exeext'
6096    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6097    (eval $ac_try) 2>&5
6098    ac_status=$?
6099    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6100    (exit $ac_status); }; }; then
6101 <  ac_header_compiler=yes
6101 >  ac_cv_lib_z_inflateEnd=yes
6102   else
6103    echo "$as_me: failed program was:" >&5
6104   sed 's/^/| /' conftest.$ac_ext >&5
6105  
6106 < ac_header_compiler=no
6106 > ac_cv_lib_z_inflateEnd=no
6107   fi
6108 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6109 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6110 < echo "${ECHO_T}$ac_header_compiler" >&6
6111 <
6112 < # Is the header present?
6113 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6114 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6115 < cat >conftest.$ac_ext <<_ACEOF
6116 < /* confdefs.h.  */
6108 > rm -f conftest.err conftest.$ac_objext \
6109 >      conftest$ac_exeext conftest.$ac_ext
6110 > LIBS=$ac_check_lib_save_LIBS
6111 > fi
6112 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6113 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6114 > if test $ac_cv_lib_z_inflateEnd = yes; then
6115 >  cat >>confdefs.h <<_ACEOF
6116 > #define HAVE_LIBZ 1
6117   _ACEOF
6118 < cat confdefs.h >>conftest.$ac_ext
6119 < cat >>conftest.$ac_ext <<_ACEOF
6120 < /* end confdefs.h.  */
5602 < #include <$ac_header>
5603 < _ACEOF
5604 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5605 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5606 <  ac_status=$?
5607 <  grep -v '^ *+' conftest.er1 >conftest.err
5608 <  rm -f conftest.er1
5609 <  cat conftest.err >&5
5610 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5611 <  (exit $ac_status); } >/dev/null; then
5612 <  if test -s conftest.err; then
5613 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5614 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5615 <  else
5616 <    ac_cpp_err=
5617 <  fi
5618 < else
5619 <  ac_cpp_err=yes
6118 >
6119 >  LIBS="-lz $LIBS"
6120 >
6121   fi
5621 – if test -z "$ac_cpp_err"; then
5622 –  ac_header_preproc=yes
5623 – else
5624 –  echo "$as_me: failed program was:" >&5
5625 – sed 's/^/| /' conftest.$ac_ext >&5
6122  
6123 <  ac_header_preproc=no
6123 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6124 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6125 >                echo "$as_me:$LINENO: result: ok" >&5
6126 > echo "${ECHO_T}ok" >&6
6127 >        else
6128 >                #
6129 >                # If either header or library was not found, revert and bomb
6130 >                #
6131 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6132 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6133 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6134 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6135 >                echo "$as_me:$LINENO: result: failed" >&5
6136 > echo "${ECHO_T}failed" >&6
6137 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6138 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6139 >   { (exit 1); exit 1; }; }
6140 >        fi
6141   fi
5629 – rm -f conftest.err conftest.$ac_ext
5630 – echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5631 – echo "${ECHO_T}$ac_header_preproc" >&6
6142  
6143 < # So?  What about this header?
6144 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6145 <  yes:no: )
6146 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6147 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6148 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5639 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5640 <    ac_header_preproc=yes
5641 <    ;;
5642 <  no:yes:* )
5643 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5644 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5645 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5646 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5647 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5648 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5649 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5650 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5651 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5652 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5653 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5654 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5655 <    (
5656 <      cat <<\_ASBOX
5657 < ## ------------------------------ ##
5658 < ## Report this to gezelter@nd.edu ##
5659 < ## ------------------------------ ##
5660 < _ASBOX
5661 <    ) |
5662 <      sed "s/^/$as_me: WARNING:     /" >&2
5663 <    ;;
5664 < esac
5665 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5666 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5667 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5668 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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 >
6149   else
6150 <  eval "$as_ac_Header=\$ac_header_preproc"
6151 < fi
6152 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5673 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6150 >  with_fftw=yes
6151 > fi;
6152 > if test "$with_fftw" = "no"; then
6153  
6154 < fi
6155 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5677 <  cat >>confdefs.h <<_ACEOF
5678 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6154 > cat >>confdefs.h <<\_ACEOF
6155 > #define WITHOUT_FFTW
6156   _ACEOF
6157  
6158   fi
6159 + if test "$with_fftw" = "yes"; then
6160 +  sizeof_real=8
6161  
5683 – done
6162  
6163 + if test -z "$ac_fftw_firstname"; then
6164  
6165 + sizeof_real=$sizeof_real
6166 + if test $sizeof_real = 8; then
6167 +  prec="double"
6168 +  fftwcheckprefix=d
6169 + else
6170 +  prec="single"
6171 +  fftwcheckprefix=s
6172   fi
6173  
6174 + xfftwname=${fftwcheckprefix}fftw3
6175  
6176 <
6177 <
6178 <  if test "${ac_cv_header_iomanip+set}" = set; then
6179 <  echo "$as_me:$LINENO: checking for iomanip" >&5
6180 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
5694 < if test "${ac_cv_header_iomanip+set}" = set; then
5695 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5696 < fi
5697 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
5698 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
5699 < else
5700 <  # Is the header compilable?
5701 < echo "$as_me:$LINENO: checking iomanip usability" >&5
5702 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
6176 > ok="no"
6177 > # check header doesn't work, since we must use mpicc to get includes,
6178 > # we cant trust cpp.
6179 > echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6180 > echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6181   cat >conftest.$ac_ext <<_ACEOF
6182   /* confdefs.h.  */
6183   _ACEOF
6184   cat confdefs.h >>conftest.$ac_ext
6185   cat >>conftest.$ac_ext <<_ACEOF
6186   /* end confdefs.h.  */
6187 < $ac_includes_default
6188 < #include <iomanip>
6187 > #include <$xfftwname.h>
6188 > #ifdef FC_DUMMY_MAIN
6189 > #ifndef FC_DUMMY_MAIN_EQ_F77
6190 > #  ifdef __cplusplus
6191 >     extern "C"
6192 > #  endif
6193 >   int FC_DUMMY_MAIN() { return 1; }
6194 > #endif
6195 > #endif
6196 > int
6197 > main ()
6198 > {
6199 >
6200 >  ;
6201 >  return 0;
6202 > }
6203   _ACEOF
6204   rm -f conftest.$ac_objext
6205   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5718 | Line 6210 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6210    cat conftest.err >&5
6211    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212    (exit $ac_status); } &&
6213 <         { ac_try='test -z "$ac_cxx_werror_flag"
6213 >         { ac_try='test -z "$ac_c_werror_flag"
6214                           || test ! -s conftest.err'
6215    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6216    (eval $ac_try) 2>&5
# Line 5731 | Line 6223 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6223    ac_status=$?
6224    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225    (exit $ac_status); }; }; then
6226 <  ac_header_compiler=yes
6226 >
6227 > fftwname=$xfftwname
6228 > echo "$as_me:$LINENO: result: yes" >&5
6229 > echo "${ECHO_T}yes" >&6
6230 >
6231   else
6232    echo "$as_me: failed program was:" >&5
6233   sed 's/^/| /' conftest.$ac_ext >&5
6234  
6235 < ac_header_compiler=no
6235 > echo "$as_me:$LINENO: result: no" >&5
6236 > echo "${ECHO_T}no" >&6
6237   fi
6238   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5742 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5743 – echo "${ECHO_T}$ac_header_compiler" >&6
6239  
6240 < # Is the header present?
6241 < echo "$as_me:$LINENO: checking iomanip presence" >&5
6242 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
6240 > # fftwname was set if we found a header
6241 >
6242 > if test -n "$fftwname"; then
6243 > # we cannot run the code since an MPI program might not be allowed
6244 > # on a login node of a supercomputer
6245   cat >conftest.$ac_ext <<_ACEOF
6246   /* confdefs.h.  */
6247   _ACEOF
6248   cat confdefs.h >>conftest.$ac_ext
6249   cat >>conftest.$ac_ext <<_ACEOF
6250   /* end confdefs.h.  */
6251 < #include <iomanip>
6251 > #include <$fftwname.h>
6252 > #ifdef FC_DUMMY_MAIN
6253 > #ifndef FC_DUMMY_MAIN_EQ_F77
6254 > #  ifdef __cplusplus
6255 >     extern "C"
6256 > #  endif
6257 >   int FC_DUMMY_MAIN() { return 1; }
6258 > #endif
6259 > #endif
6260 > int
6261 > main ()
6262 > {
6263 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6264 >  ;
6265 >  return 0;
6266 > }
6267   _ACEOF
6268 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6269 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6268 > rm -f conftest.$ac_objext
6269 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6270 >  (eval $ac_compile) 2>conftest.er1
6271    ac_status=$?
6272    grep -v '^ *+' conftest.er1 >conftest.err
6273    rm -f conftest.er1
6274    cat conftest.err >&5
6275    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276 <  (exit $ac_status); } >/dev/null; then
6277 <  if test -s conftest.err; then
6278 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6279 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6280 <  else
6281 <    ac_cpp_err=
6282 <  fi
6276 >  (exit $ac_status); } &&
6277 >         { ac_try='test -z "$ac_c_werror_flag"
6278 >                         || test ! -s conftest.err'
6279 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6280 >  (eval $ac_try) 2>&5
6281 >  ac_status=$?
6282 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6283 >  (exit $ac_status); }; } &&
6284 >         { ac_try='test -s conftest.$ac_objext'
6285 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6286 >  (eval $ac_try) 2>&5
6287 >  ac_status=$?
6288 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6289 >  (exit $ac_status); }; }; then
6290 >
6291 > ok=yes
6292 > usedprefix=$fftwcheckprefix
6293 >
6294   else
5771 –  ac_cpp_err=yes
5772 – fi
5773 – if test -z "$ac_cpp_err"; then
5774 –  ac_header_preproc=yes
5775 – else
6295    echo "$as_me: failed program was:" >&5
6296   sed 's/^/| /' conftest.$ac_ext >&5
6297  
6298 <  ac_header_preproc=no
6298 > ok=no
6299   fi
6300 < rm -f conftest.err conftest.$ac_ext
5782 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5783 < echo "${ECHO_T}$ac_header_preproc" >&6
5784 <
5785 < # So?  What about this header?
5786 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
5787 <  yes:no: )
5788 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
5789 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
5790 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
5791 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
5792 <    ac_header_preproc=yes
5793 <    ;;
5794 <  no:yes:* )
5795 <    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
5796 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
5797 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
5798 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
5799 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
5800 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
5801 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
5802 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
5803 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
5804 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
5805 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
5806 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
5807 <    (
5808 <      cat <<\_ASBOX
5809 < ## ------------------------------ ##
5810 < ## Report this to gezelter@nd.edu ##
5811 < ## ------------------------------ ##
5812 < _ASBOX
5813 <    ) |
5814 <      sed "s/^/$as_me: WARNING:     /" >&2
5815 <    ;;
5816 < esac
5817 < echo "$as_me:$LINENO: checking for iomanip" >&5
5818 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
5819 < if test "${ac_cv_header_iomanip+set}" = set; then
5820 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5821 < else
5822 <  ac_cv_header_iomanip=$ac_header_preproc
6300 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301   fi
5824 – echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
5825 – echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6302  
6303 < fi
6304 < if test $ac_cv_header_iomanip = yes; then
6305 <
6306 <
5831 < cat >>confdefs.h <<\_ACEOF
5832 < #define HAVE_IOMANIP 1
5833 < _ACEOF
5834 <
5835 <
5836 < else
5837 <
5838 <
5839 < for ac_header in iomanip.h
5840 < do
5841 < 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
5846 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5847 < fi
5848 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5849 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5850 < else
5851 <  # Is the header compilable?
5852 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5853 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5854 < cat >conftest.$ac_ext <<_ACEOF
6303 > if test "$ok" != "yes"; then
6304 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6305 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6306 >  cat >conftest.$ac_ext <<_ACEOF
6307   /* confdefs.h.  */
6308   _ACEOF
6309   cat confdefs.h >>conftest.$ac_ext
6310   cat >>conftest.$ac_ext <<_ACEOF
6311   /* end confdefs.h.  */
6312 < $ac_includes_default
6313 < #include <$ac_header>
6312 > #include <fftw3.h>
6313 > #ifdef FC_DUMMY_MAIN
6314 > #ifndef FC_DUMMY_MAIN_EQ_F77
6315 > #  ifdef __cplusplus
6316 >     extern "C"
6317 > #  endif
6318 >   int FC_DUMMY_MAIN() { return 1; }
6319 > #endif
6320 > #endif
6321 > int
6322 > main ()
6323 > {
6324 >
6325 >  ;
6326 >  return 0;
6327 > }
6328   _ACEOF
6329   rm -f conftest.$ac_objext
6330   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5869 | Line 6335 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6335    cat conftest.err >&5
6336    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337    (exit $ac_status); } &&
6338 <         { ac_try='test -z "$ac_cxx_werror_flag"
6338 >         { ac_try='test -z "$ac_c_werror_flag"
6339                           || test ! -s conftest.err'
6340    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6341    (eval $ac_try) 2>&5
# Line 5882 | Line 6348 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6348    ac_status=$?
6349    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350    (exit $ac_status); }; }; then
6351 <  ac_header_compiler=yes
6351 >  echo "$as_me:$LINENO: result: yes" >&5
6352 > echo "${ECHO_T}yes" >&6
6353   else
6354    echo "$as_me: failed program was:" >&5
6355   sed 's/^/| /' conftest.$ac_ext >&5
6356  
6357 < ac_header_compiler=no
6357 >
6358 > echo "$as_me:$LINENO: result: no" >&5
6359 > echo "${ECHO_T}no" >&6
6360 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6361 > Do you have $prec precision FFTW installed? If you are using packages,
6362 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6363 > software at www.fftw.org.
6364 > If you compiled FFTW yourself:
6365 > Note that the default FFTW setup is double precision.  If you want MPI support,
6366 > use --with-mpi. It is a good idea to install both single & double.
6367 > If you have installed FFTW in a non-standard location, you should
6368 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6369 > variables before running configure.
6370 > That is also necessary to do if your compiler doesn't search
6371 > /usr/local/include and /usr/local/lib by default." >&5
6372 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6373 > Do you have $prec precision FFTW installed? If you are using packages,
6374 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6375 > software at www.fftw.org.
6376 > If you compiled FFTW yourself:
6377 > Note that the default FFTW setup is double precision.  If you want MPI support,
6378 > use --with-mpi. It is a good idea to install both single & double.
6379 > If you have installed FFTW in a non-standard location, you should
6380 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6381 > variables before running configure.
6382 > That is also necessary to do if your compiler doesn't search
6383 > /usr/local/include and /usr/local/lib by default." >&2;}
6384 >   { (exit 1); exit 1; }; }
6385 >
6386   fi
6387   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5893 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5894 – echo "${ECHO_T}$ac_header_compiler" >&6
5895 –
5896 – # Is the header present?
5897 – echo "$as_me:$LINENO: checking $ac_header presence" >&5
5898 – echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6388   cat >conftest.$ac_ext <<_ACEOF
6389   /* confdefs.h.  */
6390   _ACEOF
6391   cat confdefs.h >>conftest.$ac_ext
6392   cat >>conftest.$ac_ext <<_ACEOF
6393   /* end confdefs.h.  */
6394 < #include <$ac_header>
6394 > #include <fftw3.h>
6395 > #ifdef FC_DUMMY_MAIN
6396 > #ifndef FC_DUMMY_MAIN_EQ_F77
6397 > #  ifdef __cplusplus
6398 >     extern "C"
6399 > #  endif
6400 >   int FC_DUMMY_MAIN() { return 1; }
6401 > #endif
6402 > #endif
6403 > int
6404 > main ()
6405 > {
6406 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6407 >  ;
6408 >  return 0;
6409 > }
6410   _ACEOF
6411 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6412 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6411 > rm -f conftest.$ac_objext
6412 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6413 >  (eval $ac_compile) 2>conftest.er1
6414    ac_status=$?
6415    grep -v '^ *+' conftest.er1 >conftest.err
6416    rm -f conftest.er1
6417    cat conftest.err >&5
6418    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6419 <  (exit $ac_status); } >/dev/null; then
6420 <  if test -s conftest.err; then
6421 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6422 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6423 <  else
6424 <    ac_cpp_err=
6425 <  fi
6419 >  (exit $ac_status); } &&
6420 >         { ac_try='test -z "$ac_c_werror_flag"
6421 >                         || test ! -s conftest.err'
6422 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6423 >  (eval $ac_try) 2>&5
6424 >  ac_status=$?
6425 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426 >  (exit $ac_status); }; } &&
6427 >         { ac_try='test -s conftest.$ac_objext'
6428 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6429 >  (eval $ac_try) 2>&5
6430 >  ac_status=$?
6431 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432 >  (exit $ac_status); }; }; then
6433 >
6434 > usedprefix=""
6435 > fftwname=fftw3
6436 >
6437   else
6438 <  ac_cpp_err=yes
6439 < fi
6440 < if test -z "$ac_cpp_err"; then
6441 <  ac_header_preproc=yes
6442 < else
6443 <  echo "$as_me: failed program was:" >&5
6444 < sed 's/^/| /' conftest.$ac_ext >&5
6445 <
6446 <  ac_header_preproc=no
6447 < fi
6448 < rm -f conftest.err conftest.$ac_ext
6449 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6450 < echo "${ECHO_T}$ac_header_preproc" >&6
6451 <
6452 < # So?  What about this header?
6453 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6454 <  yes:no: )
6455 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6456 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6457 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6458 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6459 <    ac_header_preproc=yes
6460 <    ;;
6461 <  no:yes:* )
6462 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6463 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6464 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6465 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6466 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6467 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6468 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6469 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6470 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6471 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6472 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6473 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6474 <    (
6475 <      cat <<\_ASBOX
6476 < ## ------------------------------ ##
6477 < ## Report this to gezelter@nd.edu ##
6478 < ## ------------------------------ ##
6479 < _ASBOX
6480 <    ) |
6481 <      sed "s/^/$as_me: WARNING:     /" >&2
6482 <    ;;
6483 < esac
6484 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6485 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6486 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6487 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6488 < else
6489 <  eval "$as_ac_Header=\$ac_header_preproc"
6490 < fi
6491 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6492 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6493 <
6494 < fi
6495 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6496 <  cat >>confdefs.h <<_ACEOF
6497 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6498 < _ACEOF
6499 <
6500 < fi
6501 <
6502 < done
6503 <
6504 <
6505 < fi
6506 <
6507 <
6508 <
6509 <
6510 < for ac_header in cmath
6511 < do
6512 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6513 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6514 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6515 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6516 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6517 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6518 < fi
6519 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6520 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6521 < else
6522 <  # Is the header compilable?
6523 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6524 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6525 < cat >conftest.$ac_ext <<_ACEOF
6526 < /* confdefs.h.  */
6527 < _ACEOF
6528 < cat confdefs.h >>conftest.$ac_ext
6529 < cat >>conftest.$ac_ext <<_ACEOF
6530 < /* end confdefs.h.  */
6531 < $ac_includes_default
6532 < #include <$ac_header>
6533 < _ACEOF
6534 < rm -f conftest.$ac_objext
6535 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6536 <  (eval $ac_compile) 2>conftest.er1
6537 <  ac_status=$?
6538 <  grep -v '^ *+' conftest.er1 >conftest.err
6539 <  rm -f conftest.er1
6540 <  cat conftest.err >&5
6541 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6542 <  (exit $ac_status); } &&
6543 <         { ac_try='test -z "$ac_cxx_werror_flag"
6544 <                         || test ! -s conftest.err'
6545 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6546 <  (eval $ac_try) 2>&5
6547 <  ac_status=$?
6548 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6549 <  (exit $ac_status); }; } &&
6550 <         { ac_try='test -s conftest.$ac_objext'
6551 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6552 <  (eval $ac_try) 2>&5
6553 <  ac_status=$?
6554 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6555 <  (exit $ac_status); }; }; then
6556 <  ac_header_compiler=yes
6557 < else
6558 <  echo "$as_me: failed program was:" >&5
6559 < sed 's/^/| /' conftest.$ac_ext >&5
6560 <
6561 < ac_header_compiler=no
6562 < fi
6563 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6564 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6565 < echo "${ECHO_T}$ac_header_compiler" >&6
6566 <
6567 < # Is the header present?
6568 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6569 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6570 < cat >conftest.$ac_ext <<_ACEOF
6571 < /* confdefs.h.  */
6572 < _ACEOF
6573 < cat confdefs.h >>conftest.$ac_ext
6574 < cat >>conftest.$ac_ext <<_ACEOF
6575 < /* end confdefs.h.  */
6576 < #include <$ac_header>
6577 < _ACEOF
6578 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6579 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6580 <  ac_status=$?
6581 <  grep -v '^ *+' conftest.er1 >conftest.err
6582 <  rm -f conftest.er1
6583 <  cat conftest.err >&5
6584 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6585 <  (exit $ac_status); } >/dev/null; then
6586 <  if test -s conftest.err; then
6587 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6588 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6589 <  else
6590 <    ac_cpp_err=
6591 <  fi
6592 < else
6593 <  ac_cpp_err=yes
6594 < fi
6595 < if test -z "$ac_cpp_err"; then
6596 <  ac_header_preproc=yes
6597 < else
6598 <  echo "$as_me: failed program was:" >&5
6599 < sed 's/^/| /' conftest.$ac_ext >&5
6600 <
6601 <  ac_header_preproc=no
6602 < fi
6603 < rm -f conftest.err conftest.$ac_ext
6604 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6605 < echo "${ECHO_T}$ac_header_preproc" >&6
6606 <
6607 < # So?  What about this header?
6608 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6609 <  yes:no: )
6610 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6611 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6612 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6613 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6614 <    ac_header_preproc=yes
6615 <    ;;
6616 <  no:yes:* )
6617 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6618 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6619 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6620 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6621 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6622 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6623 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6624 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6625 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6626 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6627 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6628 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6629 <    (
6630 <      cat <<\_ASBOX
6631 < ## ------------------------------ ##
6632 < ## Report this to gezelter@nd.edu ##
6633 < ## ------------------------------ ##
6634 < _ASBOX
6635 <    ) |
6636 <      sed "s/^/$as_me: WARNING:     /" >&2
6637 <    ;;
6638 < esac
6639 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6640 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6641 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6642 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6643 < else
6644 <  eval "$as_ac_Header=\$ac_header_preproc"
6645 < fi
6646 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6647 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6648 <
6649 < fi
6650 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6651 <  cat >>confdefs.h <<_ACEOF
6652 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6653 < _ACEOF
6654 <
6655 < fi
6656 <
6657 < done
6658 <
6659 <
6660 <
6661 <
6662 <  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
6663 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
6664 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
6665 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6666 < else
6667 <
6668 <      ac_cv_cxx_have_std_iostream=no
6669 <      ac_cv_cxx_need_use_std_iostream=no
6670 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6671 <
6672 <
6673 <        ac_ext=cc
6674 < ac_cpp='$CXXCPP $CPPFLAGS'
6675 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6676 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6677 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6678 <
6679 <        cat >conftest.$ac_ext <<_ACEOF
6680 < /* confdefs.h.  */
6681 < _ACEOF
6682 < cat confdefs.h >>conftest.$ac_ext
6683 < cat >>conftest.$ac_ext <<_ACEOF
6684 < /* end confdefs.h.  */
6685 <
6686 < #ifdef HAVE_IOSTREAM
6687 < #include <iostream>
6688 < #else
6689 < #include <iostream.h>
6690 < #endif
6691 <
6692 < int
6693 < main ()
6694 < {
6695 < std::cout<<"Hello World"<<std::endl;return 0;
6696 <  ;
6697 <  return 0;
6698 < }
6699 < _ACEOF
6700 < rm -f conftest.$ac_objext
6701 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6702 <  (eval $ac_compile) 2>conftest.er1
6703 <  ac_status=$?
6704 <  grep -v '^ *+' conftest.er1 >conftest.err
6705 <  rm -f conftest.er1
6706 <  cat conftest.err >&5
6707 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6708 <  (exit $ac_status); } &&
6709 <         { ac_try='test -z "$ac_cxx_werror_flag"
6710 <                         || test ! -s conftest.err'
6711 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6712 <  (eval $ac_try) 2>&5
6713 <  ac_status=$?
6714 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6715 <  (exit $ac_status); }; } &&
6716 <         { ac_try='test -s conftest.$ac_objext'
6717 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6718 <  (eval $ac_try) 2>&5
6719 <  ac_status=$?
6720 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6721 <  (exit $ac_status); }; }; then
6722 <  ac_cv_cxx_have_std_iostream=yes
6723 < else
6724 <  echo "$as_me: failed program was:" >&5
6725 < sed 's/^/| /' conftest.$ac_ext >&5
6726 <
6727 < fi
6728 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6729 <        cat >conftest.$ac_ext <<_ACEOF
6730 < /* confdefs.h.  */
6731 < _ACEOF
6732 < cat confdefs.h >>conftest.$ac_ext
6733 < cat >>conftest.$ac_ext <<_ACEOF
6734 < /* end confdefs.h.  */
6735 <
6736 < #define __USE_STD_IOSTREAM 1
6737 < #ifdef HAVE_IOSTREAM
6738 < #include <iostream>
6739 < #else
6740 < #include <iostream.h>
6741 < #endif
6742 <
6743 < int
6744 < main ()
6745 < {
6746 < std::cout<<"Hello World"<<std::endl;return 0;
6747 <  ;
6748 <  return 0;
6749 < }
6750 < _ACEOF
6751 < rm -f conftest.$ac_objext
6752 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6753 <  (eval $ac_compile) 2>conftest.er1
6754 <  ac_status=$?
6755 <  grep -v '^ *+' conftest.er1 >conftest.err
6756 <  rm -f conftest.er1
6757 <  cat conftest.err >&5
6758 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6759 <  (exit $ac_status); } &&
6760 <         { ac_try='test -z "$ac_cxx_werror_flag"
6761 <                         || test ! -s conftest.err'
6762 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6763 <  (eval $ac_try) 2>&5
6764 <  ac_status=$?
6765 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6766 <  (exit $ac_status); }; } &&
6767 <         { ac_try='test -s conftest.$ac_objext'
6768 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6769 <  (eval $ac_try) 2>&5
6770 <  ac_status=$?
6771 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6772 <  (exit $ac_status); }; }; then
6773 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
6774 < else
6775 <  echo "$as_me: failed program was:" >&5
6776 < sed 's/^/| /' conftest.$ac_ext >&5
6777 <
6778 < fi
6779 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6780 <        ac_ext=cc
6781 < ac_cpp='$CXXCPP $CPPFLAGS'
6782 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6783 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6784 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6785 <
6786 <      fi
6787 <
6788 < fi
6789 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
6790 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
6791 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
6792 <
6793 < cat >>confdefs.h <<\_ACEOF
6794 < #define HAVE_STD_IOSTREAM 1
6795 < _ACEOF
6796 <
6797 <  fi
6798 <  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
6799 <
6800 < cat >>confdefs.h <<\_ACEOF
6801 < #define __USE_STD_IOSTREAM 1
6802 < _ACEOF
6803 <
6804 <  fi
6805 <
6806 <
6807 <
6808 <
6809 <  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
6810 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
6811 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
6812 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6813 < else
6814 <
6815 <      ac_cv_cxx_have_std_stl=no
6816 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6817 <
6818 <
6819 <        ac_ext=cc
6820 < ac_cpp='$CXXCPP $CPPFLAGS'
6821 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6822 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6823 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6824 <
6825 <        cat >conftest.$ac_ext <<_ACEOF
6826 < /* confdefs.h.  */
6827 < _ACEOF
6828 < cat confdefs.h >>conftest.$ac_ext
6829 < cat >>conftest.$ac_ext <<_ACEOF
6830 < /* end confdefs.h.  */
6831 < #include <list>
6832 <
6833 < int
6834 < main ()
6835 < {
6836 < std::list<int> foo;return 0;
6837 <  ;
6838 <  return 0;
6839 < }
6840 < _ACEOF
6841 < rm -f conftest.$ac_objext
6842 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6843 <  (eval $ac_compile) 2>conftest.er1
6844 <  ac_status=$?
6845 <  grep -v '^ *+' conftest.er1 >conftest.err
6846 <  rm -f conftest.er1
6847 <  cat conftest.err >&5
6848 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6849 <  (exit $ac_status); } &&
6850 <         { ac_try='test -z "$ac_cxx_werror_flag"
6851 <                         || test ! -s conftest.err'
6852 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6853 <  (eval $ac_try) 2>&5
6854 <  ac_status=$?
6855 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6856 <  (exit $ac_status); }; } &&
6857 <         { ac_try='test -s conftest.$ac_objext'
6858 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6859 <  (eval $ac_try) 2>&5
6860 <  ac_status=$?
6861 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6862 <  (exit $ac_status); }; }; then
6863 <  ac_cv_cxx_have_std_stl=yes
6864 < else
6865 <  echo "$as_me: failed program was:" >&5
6866 < sed 's/^/| /' conftest.$ac_ext >&5
6867 <
6438 >  echo "$as_me: failed program was:" >&5
6439 > sed 's/^/| /' conftest.$ac_ext >&5
6440 >
6441 >
6442 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6443 > Do you have $prec precision FFTW installed? If you are using packages,
6444 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6445 > software at www.fftw.org.
6446 > If you compiled FFTW yourself:
6447 > Note that the default FFTW setup is double precision.  If you want MPI support,
6448 > use --with-mpi. It is a good idea to install both single & double.
6449 > If you have installed FFTW in a non-standard location, you should
6450 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6451 > variables before running configure.
6452 > That is also necessary to do if your compiler doesn't search
6453 > /usr/local/include and /usr/local/lib by default." >&5
6454 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6455 > Do you have $prec precision FFTW installed? If you are using packages,
6456 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6457 > software at www.fftw.org.
6458 > If you compiled FFTW yourself:
6459 > Note that the default FFTW setup is double precision.  If you want MPI support,
6460 > use --with-mpi. It is a good idea to install both single & double.
6461 > If you have installed FFTW in a non-standard location, you should
6462 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6463 > variables before running configure.
6464 > That is also necessary to do if your compiler doesn't search
6465 > /usr/local/include and /usr/local/lib by default." >&2;}
6466 >   { (exit 1); exit 1; }; }
6467 > fi
6468 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6469 > fi
6470 >
6471 >
6472 > as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6473 > echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6474 > echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6475 > if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6476 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6477 > else
6478 >  ac_check_lib_save_LIBS=$LIBS
6479 > LIBS="-l$fftwname  $LIBS"
6480 > cat >conftest.$ac_ext <<_ACEOF
6481 > /* confdefs.h.  */
6482 > _ACEOF
6483 > cat confdefs.h >>conftest.$ac_ext
6484 > cat >>conftest.$ac_ext <<_ACEOF
6485 > /* end confdefs.h.  */
6486 >
6487 >
6488 > #ifdef FC_DUMMY_MAIN
6489 > #ifndef FC_DUMMY_MAIN_EQ_F77
6490 > #  ifdef __cplusplus
6491 >     extern "C"
6492 > #  endif
6493 >   int FC_DUMMY_MAIN() { return 1; }
6494 > #endif
6495 > #endif
6496 > int
6497 > main ()
6498 > {
6499 > main ();
6500 >  ;
6501 >  return 0;
6502 > }
6503 > _ACEOF
6504 > rm -f conftest.$ac_objext conftest$ac_exeext
6505 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6506 >  (eval $ac_link) 2>conftest.er1
6507 >  ac_status=$?
6508 >  grep -v '^ *+' conftest.er1 >conftest.err
6509 >  rm -f conftest.er1
6510 >  cat conftest.err >&5
6511 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6512 >  (exit $ac_status); } &&
6513 >         { ac_try='test -z "$ac_c_werror_flag"
6514 >                         || test ! -s conftest.err'
6515 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6516 >  (eval $ac_try) 2>&5
6517 >  ac_status=$?
6518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519 >  (exit $ac_status); }; } &&
6520 >         { ac_try='test -s conftest$ac_exeext'
6521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6522 >  (eval $ac_try) 2>&5
6523 >  ac_status=$?
6524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6525 >  (exit $ac_status); }; }; then
6526 >  eval "$as_ac_Lib=yes"
6527 > else
6528 >  echo "$as_me: failed program was:" >&5
6529 > sed 's/^/| /' conftest.$ac_ext >&5
6530 >
6531 > eval "$as_ac_Lib=no"
6532 > fi
6533 > rm -f conftest.err conftest.$ac_objext \
6534 >      conftest$ac_exeext conftest.$ac_ext
6535 > LIBS=$ac_check_lib_save_LIBS
6536 > fi
6537 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
6538 > echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
6539 > if test `eval echo '${'$as_ac_Lib'}'` = yes; then
6540 >  cat >>confdefs.h <<_ACEOF
6541 > #define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
6542 > _ACEOF
6543 >
6544 >  LIBS="-l$fftwname $LIBS"
6545 >
6546 > else
6547 >  { { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
6548 > echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
6549 >   { (exit 1); exit 1; }; }
6550 > fi
6551 >
6552 > ac_fftw_savedprefix=$usedprefix
6553 > ac_fftw_firstname=$fftwname
6554 >
6555 > else
6556 >
6557 > fftwname=${ac_fftw_savedprefix}fftw3
6558 > echo "$as_me:$LINENO: checking for $fftwname.h" >&5
6559 > echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
6560 > cat >conftest.$ac_ext <<_ACEOF
6561 > /* confdefs.h.  */
6562 > _ACEOF
6563 > cat confdefs.h >>conftest.$ac_ext
6564 > cat >>conftest.$ac_ext <<_ACEOF
6565 > /* end confdefs.h.  */
6566 > #include <$fftwname.h>
6567 > #ifdef FC_DUMMY_MAIN
6568 > #ifndef FC_DUMMY_MAIN_EQ_F77
6569 > #  ifdef __cplusplus
6570 >     extern "C"
6571 > #  endif
6572 >   int FC_DUMMY_MAIN() { return 1; }
6573 > #endif
6574 > #endif
6575 > int
6576 > main ()
6577 > {
6578 >
6579 >  ;
6580 >  return 0;
6581 > }
6582 > _ACEOF
6583 > rm -f conftest.$ac_objext
6584 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6585 >  (eval $ac_compile) 2>conftest.er1
6586 >  ac_status=$?
6587 >  grep -v '^ *+' conftest.er1 >conftest.err
6588 >  rm -f conftest.er1
6589 >  cat conftest.err >&5
6590 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6591 >  (exit $ac_status); } &&
6592 >         { ac_try='test -z "$ac_c_werror_flag"
6593 >                         || test ! -s conftest.err'
6594 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6595 >  (eval $ac_try) 2>&5
6596 >  ac_status=$?
6597 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6598 >  (exit $ac_status); }; } &&
6599 >         { ac_try='test -s conftest.$ac_objext'
6600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6601 >  (eval $ac_try) 2>&5
6602 >  ac_status=$?
6603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6604 >  (exit $ac_status); }; }; then
6605 >  echo "$as_me:$LINENO: result: yes" >&5
6606 > echo "${ECHO_T}yes" >&6
6607 > LIBS="-l$fftwname $LIBS"
6608 > cat >conftest.$ac_ext <<_ACEOF
6609 > /* confdefs.h.  */
6610 > _ACEOF
6611 > cat confdefs.h >>conftest.$ac_ext
6612 > cat >>conftest.$ac_ext <<_ACEOF
6613 > /* end confdefs.h.  */
6614 >
6615 >
6616 > #ifdef FC_DUMMY_MAIN
6617 > #ifndef FC_DUMMY_MAIN_EQ_F77
6618 > #  ifdef __cplusplus
6619 >     extern "C"
6620 > #  endif
6621 >   int FC_DUMMY_MAIN() { return 1; }
6622 > #endif
6623 > #endif
6624 > int
6625 > main ()
6626 > {
6627 > main ();
6628 >  ;
6629 >  return 0;
6630 > }
6631 > _ACEOF
6632 > rm -f conftest.$ac_objext conftest$ac_exeext
6633 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6634 >  (eval $ac_link) 2>conftest.er1
6635 >  ac_status=$?
6636 >  grep -v '^ *+' conftest.er1 >conftest.err
6637 >  rm -f conftest.er1
6638 >  cat conftest.err >&5
6639 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6640 >  (exit $ac_status); } &&
6641 >         { ac_try='test -z "$ac_c_werror_flag"
6642 >                         || test ! -s conftest.err'
6643 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6644 >  (eval $ac_try) 2>&5
6645 >  ac_status=$?
6646 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647 >  (exit $ac_status); }; } &&
6648 >         { ac_try='test -s conftest$ac_exeext'
6649 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650 >  (eval $ac_try) 2>&5
6651 >  ac_status=$?
6652 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653 >  (exit $ac_status); }; }; then
6654 >  :
6655 > else
6656 >  echo "$as_me: failed program was:" >&5
6657 > sed 's/^/| /' conftest.$ac_ext >&5
6658 >
6659 > fi
6660 > rm -f conftest.err conftest.$ac_objext \
6661 >      conftest$ac_exeext conftest.$ac_ext
6662 > else
6663 >  echo "$as_me: failed program was:" >&5
6664 > sed 's/^/| /' conftest.$ac_ext >&5
6665 >
6666 >
6667 > echo "$as_me:$LINENO: result: no" >&5
6668 > echo "${ECHO_T}no" >&6
6669 > { { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
6670 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
6671 > echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
6672 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
6673 >   { (exit 1); exit 1; }; }
6674 >
6675 > fi
6676 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6677 >
6678 > fi
6679 >
6680 >
6681 >
6682 >  if test "$with_mpi" = "yes"; then
6683 >
6684 > if test -z "$ac_fftw_firstname"; then
6685 >
6686 > sizeof_real=$sizeof_real
6687 > if test $sizeof_real = 8; then
6688 >  prec="double"
6689 >  fftwcheckprefix=d
6690 > else
6691 >  prec="single"
6692 >  fftwcheckprefix=s
6693 > fi
6694 >
6695 > xfftwname=${fftwcheckprefix}fftw3_mpi
6696 >
6697 > ok="no"
6698 > # check header doesn't work, since we must use mpicc to get includes,
6699 > # we cant trust cpp.
6700 > echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6701 > echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6702 > cat >conftest.$ac_ext <<_ACEOF
6703 > /* confdefs.h.  */
6704 > _ACEOF
6705 > cat confdefs.h >>conftest.$ac_ext
6706 > cat >>conftest.$ac_ext <<_ACEOF
6707 > /* end confdefs.h.  */
6708 > #include <$xfftwname.h>
6709 > #ifdef FC_DUMMY_MAIN
6710 > #ifndef FC_DUMMY_MAIN_EQ_F77
6711 > #  ifdef __cplusplus
6712 >     extern "C"
6713 > #  endif
6714 >   int FC_DUMMY_MAIN() { return 1; }
6715 > #endif
6716 > #endif
6717 > int
6718 > main ()
6719 > {
6720 >
6721 >  ;
6722 >  return 0;
6723 > }
6724 > _ACEOF
6725 > rm -f conftest.$ac_objext
6726 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727 >  (eval $ac_compile) 2>conftest.er1
6728 >  ac_status=$?
6729 >  grep -v '^ *+' conftest.er1 >conftest.err
6730 >  rm -f conftest.er1
6731 >  cat conftest.err >&5
6732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733 >  (exit $ac_status); } &&
6734 >         { ac_try='test -z "$ac_c_werror_flag"
6735 >                         || test ! -s conftest.err'
6736 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737 >  (eval $ac_try) 2>&5
6738 >  ac_status=$?
6739 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740 >  (exit $ac_status); }; } &&
6741 >         { ac_try='test -s conftest.$ac_objext'
6742 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743 >  (eval $ac_try) 2>&5
6744 >  ac_status=$?
6745 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746 >  (exit $ac_status); }; }; then
6747 >
6748 > fftwname=$xfftwname
6749 > echo "$as_me:$LINENO: result: yes" >&5
6750 > echo "${ECHO_T}yes" >&6
6751 >
6752 > else
6753 >  echo "$as_me: failed program was:" >&5
6754 > sed 's/^/| /' conftest.$ac_ext >&5
6755 >
6756 > echo "$as_me:$LINENO: result: no" >&5
6757 > echo "${ECHO_T}no" >&6
6758 > fi
6759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760 >
6761 > # fftwname was set if we found a header
6762 >
6763 > if test -n "$fftwname"; then
6764 > # we cannot run the code since an MPI program might not be allowed
6765 > # on a login node of a supercomputer
6766 > cat >conftest.$ac_ext <<_ACEOF
6767 > /* confdefs.h.  */
6768 > _ACEOF
6769 > cat confdefs.h >>conftest.$ac_ext
6770 > cat >>conftest.$ac_ext <<_ACEOF
6771 > /* end confdefs.h.  */
6772 > #include <$fftwname.h>
6773 > #ifdef FC_DUMMY_MAIN
6774 > #ifndef FC_DUMMY_MAIN_EQ_F77
6775 > #  ifdef __cplusplus
6776 >     extern "C"
6777 > #  endif
6778 >   int FC_DUMMY_MAIN() { return 1; }
6779 > #endif
6780 > #endif
6781 > int
6782 > main ()
6783 > {
6784 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6785 >  ;
6786 >  return 0;
6787 > }
6788 > _ACEOF
6789 > rm -f conftest.$ac_objext
6790 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791 >  (eval $ac_compile) 2>conftest.er1
6792 >  ac_status=$?
6793 >  grep -v '^ *+' conftest.er1 >conftest.err
6794 >  rm -f conftest.er1
6795 >  cat conftest.err >&5
6796 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6797 >  (exit $ac_status); } &&
6798 >         { ac_try='test -z "$ac_c_werror_flag"
6799 >                         || test ! -s conftest.err'
6800 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6801 >  (eval $ac_try) 2>&5
6802 >  ac_status=$?
6803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6804 >  (exit $ac_status); }; } &&
6805 >         { ac_try='test -s conftest.$ac_objext'
6806 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6807 >  (eval $ac_try) 2>&5
6808 >  ac_status=$?
6809 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6810 >  (exit $ac_status); }; }; then
6811 >
6812 > ok=yes
6813 > usedprefix=$fftwcheckprefix
6814 >
6815 > else
6816 >  echo "$as_me: failed program was:" >&5
6817 > sed 's/^/| /' conftest.$ac_ext >&5
6818 >
6819 > ok=no
6820 > fi
6821 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6822 > fi
6823 >
6824 > if test "$ok" != "yes"; then
6825 >  echo "$as_me:$LINENO: checking for fftw3_mpi.h" >&5
6826 > echo $ECHO_N "checking for fftw3_mpi.h... $ECHO_C" >&6
6827 >  cat >conftest.$ac_ext <<_ACEOF
6828 > /* confdefs.h.  */
6829 > _ACEOF
6830 > cat confdefs.h >>conftest.$ac_ext
6831 > cat >>conftest.$ac_ext <<_ACEOF
6832 > /* end confdefs.h.  */
6833 > #include <fftw3_mpi.h>
6834 > #ifdef FC_DUMMY_MAIN
6835 > #ifndef FC_DUMMY_MAIN_EQ_F77
6836 > #  ifdef __cplusplus
6837 >     extern "C"
6838 > #  endif
6839 >   int FC_DUMMY_MAIN() { return 1; }
6840 > #endif
6841 > #endif
6842 > int
6843 > main ()
6844 > {
6845 >
6846 >  ;
6847 >  return 0;
6848 > }
6849 > _ACEOF
6850 > rm -f conftest.$ac_objext
6851 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6852 >  (eval $ac_compile) 2>conftest.er1
6853 >  ac_status=$?
6854 >  grep -v '^ *+' conftest.er1 >conftest.err
6855 >  rm -f conftest.er1
6856 >  cat conftest.err >&5
6857 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6858 >  (exit $ac_status); } &&
6859 >         { ac_try='test -z "$ac_c_werror_flag"
6860 >                         || test ! -s conftest.err'
6861 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6862 >  (eval $ac_try) 2>&5
6863 >  ac_status=$?
6864 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6865 >  (exit $ac_status); }; } &&
6866 >         { ac_try='test -s conftest.$ac_objext'
6867 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6868 >  (eval $ac_try) 2>&5
6869 >  ac_status=$?
6870 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871 >  (exit $ac_status); }; }; then
6872 >  echo "$as_me:$LINENO: result: yes" >&5
6873 > echo "${ECHO_T}yes" >&6
6874 > else
6875 >  echo "$as_me: failed program was:" >&5
6876 > sed 's/^/| /' conftest.$ac_ext >&5
6877 >
6878 >
6879 > echo "$as_me:$LINENO: result: no" >&5
6880 > echo "${ECHO_T}no" >&6
6881 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6882 > Do you have $prec precision FFTW installed? If you are using packages,
6883 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6884 > software at www.fftw.org.
6885 > If you compiled FFTW yourself:
6886 > Note that the default FFTW setup is double precision.  If you want MPI support,
6887 > use --with-mpi. It is a good idea to install both single & double.
6888 > If you have installed FFTW in a non-standard location, you should
6889 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6890 > variables before running configure.
6891 > That is also necessary to do if your compiler doesn't search
6892 > /usr/local/include and /usr/local/lib by default." >&5
6893 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6894 > Do you have $prec precision FFTW installed? If you are using packages,
6895 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6896 > software at www.fftw.org.
6897 > If you compiled FFTW yourself:
6898 > Note that the default FFTW setup is double precision.  If you want MPI support,
6899 > use --with-mpi. It is a good idea to install both single & double.
6900 > If you have installed FFTW in a non-standard location, you should
6901 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6902 > variables before running configure.
6903 > That is also necessary to do if your compiler doesn't search
6904 > /usr/local/include and /usr/local/lib by default." >&2;}
6905 >   { (exit 1); exit 1; }; }
6906 >
6907 > fi
6908 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6909 > cat >conftest.$ac_ext <<_ACEOF
6910 > /* confdefs.h.  */
6911 > _ACEOF
6912 > cat confdefs.h >>conftest.$ac_ext
6913 > cat >>conftest.$ac_ext <<_ACEOF
6914 > /* end confdefs.h.  */
6915 > #include <fftw3_mpi.h>
6916 > #ifdef FC_DUMMY_MAIN
6917 > #ifndef FC_DUMMY_MAIN_EQ_F77
6918 > #  ifdef __cplusplus
6919 >     extern "C"
6920 > #  endif
6921 >   int FC_DUMMY_MAIN() { return 1; }
6922 > #endif
6923 > #endif
6924 > int
6925 > main ()
6926 > {
6927 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6928 >  ;
6929 >  return 0;
6930 > }
6931 > _ACEOF
6932 > rm -f conftest.$ac_objext
6933 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6934 >  (eval $ac_compile) 2>conftest.er1
6935 >  ac_status=$?
6936 >  grep -v '^ *+' conftest.er1 >conftest.err
6937 >  rm -f conftest.er1
6938 >  cat conftest.err >&5
6939 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6940 >  (exit $ac_status); } &&
6941 >         { ac_try='test -z "$ac_c_werror_flag"
6942 >                         || test ! -s conftest.err'
6943 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6944 >  (eval $ac_try) 2>&5
6945 >  ac_status=$?
6946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947 >  (exit $ac_status); }; } &&
6948 >         { ac_try='test -s conftest.$ac_objext'
6949 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950 >  (eval $ac_try) 2>&5
6951 >  ac_status=$?
6952 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953 >  (exit $ac_status); }; }; then
6954 >
6955 > usedprefix=""
6956 > fftwname=fftw3_mpi
6957 >
6958 > else
6959 >  echo "$as_me: failed program was:" >&5
6960 > sed 's/^/| /' conftest.$ac_ext >&5
6961 >
6962 >
6963 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6964 > Do you have $prec precision FFTW installed? If you are using packages,
6965 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6966 > software at www.fftw.org.
6967 > If you compiled FFTW yourself:
6968 > Note that the default FFTW setup is double precision.  If you want MPI support,
6969 > use --with-mpi. It is a good idea to install both single & double.
6970 > If you have installed FFTW in a non-standard location, you should
6971 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6972 > variables before running configure.
6973 > That is also necessary to do if your compiler doesn't search
6974 > /usr/local/include and /usr/local/lib by default." >&5
6975 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6976 > Do you have $prec precision FFTW installed? If you are using packages,
6977 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6978 > software at www.fftw.org.
6979 > If you compiled FFTW yourself:
6980 > Note that the default FFTW setup is double precision.  If you want MPI support,
6981 > use --with-mpi. It is a good idea to install both single & double.
6982 > If you have installed FFTW in a non-standard location, you should
6983 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6984 > variables before running configure.
6985 > That is also necessary to do if your compiler doesn't search
6986 > /usr/local/include and /usr/local/lib by default." >&2;}
6987 >   { (exit 1); exit 1; }; }
6988 > fi
6989 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6990 > fi
6991 >
6992 >
6993 > as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6994 > echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6995 > echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6996 > if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6997 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6998 > else
6999 >  ac_check_lib_save_LIBS=$LIBS
7000 > LIBS="-l$fftwname  $LIBS"
7001 > cat >conftest.$ac_ext <<_ACEOF
7002 > /* confdefs.h.  */
7003 > _ACEOF
7004 > cat confdefs.h >>conftest.$ac_ext
7005 > cat >>conftest.$ac_ext <<_ACEOF
7006 > /* end confdefs.h.  */
7007 >
7008 >
7009 > #ifdef FC_DUMMY_MAIN
7010 > #ifndef FC_DUMMY_MAIN_EQ_F77
7011 > #  ifdef __cplusplus
7012 >     extern "C"
7013 > #  endif
7014 >   int FC_DUMMY_MAIN() { return 1; }
7015 > #endif
7016 > #endif
7017 > int
7018 > main ()
7019 > {
7020 > main ();
7021 >  ;
7022 >  return 0;
7023 > }
7024 > _ACEOF
7025 > rm -f conftest.$ac_objext conftest$ac_exeext
7026 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7027 >  (eval $ac_link) 2>conftest.er1
7028 >  ac_status=$?
7029 >  grep -v '^ *+' conftest.er1 >conftest.err
7030 >  rm -f conftest.er1
7031 >  cat conftest.err >&5
7032 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033 >  (exit $ac_status); } &&
7034 >         { ac_try='test -z "$ac_c_werror_flag"
7035 >                         || test ! -s conftest.err'
7036 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7037 >  (eval $ac_try) 2>&5
7038 >  ac_status=$?
7039 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040 >  (exit $ac_status); }; } &&
7041 >         { ac_try='test -s conftest$ac_exeext'
7042 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7043 >  (eval $ac_try) 2>&5
7044 >  ac_status=$?
7045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7046 >  (exit $ac_status); }; }; then
7047 >  eval "$as_ac_Lib=yes"
7048 > else
7049 >  echo "$as_me: failed program was:" >&5
7050 > sed 's/^/| /' conftest.$ac_ext >&5
7051 >
7052 > eval "$as_ac_Lib=no"
7053 > fi
7054 > rm -f conftest.err conftest.$ac_objext \
7055 >      conftest$ac_exeext conftest.$ac_ext
7056 > LIBS=$ac_check_lib_save_LIBS
7057 > fi
7058 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
7059 > echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
7060 > if test `eval echo '${'$as_ac_Lib'}'` = yes; then
7061 >  cat >>confdefs.h <<_ACEOF
7062 > #define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
7063 > _ACEOF
7064 >
7065 >  LIBS="-l$fftwname $LIBS"
7066 >
7067 > else
7068 >  { { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
7069 > echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
7070 >   { (exit 1); exit 1; }; }
7071 > fi
7072 >
7073 > ac_fftw_savedprefix=$usedprefix
7074 > ac_fftw_firstname=$fftwname
7075 >
7076 > else
7077 >
7078 > fftwname=${ac_fftw_savedprefix}fftw3_mpi
7079 > echo "$as_me:$LINENO: checking for $fftwname.h" >&5
7080 > echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
7081 > cat >conftest.$ac_ext <<_ACEOF
7082 > /* confdefs.h.  */
7083 > _ACEOF
7084 > cat confdefs.h >>conftest.$ac_ext
7085 > cat >>conftest.$ac_ext <<_ACEOF
7086 > /* end confdefs.h.  */
7087 > #include <$fftwname.h>
7088 > #ifdef FC_DUMMY_MAIN
7089 > #ifndef FC_DUMMY_MAIN_EQ_F77
7090 > #  ifdef __cplusplus
7091 >     extern "C"
7092 > #  endif
7093 >   int FC_DUMMY_MAIN() { return 1; }
7094 > #endif
7095 > #endif
7096 > int
7097 > main ()
7098 > {
7099 >
7100 >  ;
7101 >  return 0;
7102 > }
7103 > _ACEOF
7104 > rm -f conftest.$ac_objext
7105 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106 >  (eval $ac_compile) 2>conftest.er1
7107 >  ac_status=$?
7108 >  grep -v '^ *+' conftest.er1 >conftest.err
7109 >  rm -f conftest.er1
7110 >  cat conftest.err >&5
7111 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112 >  (exit $ac_status); } &&
7113 >         { ac_try='test -z "$ac_c_werror_flag"
7114 >                         || test ! -s conftest.err'
7115 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116 >  (eval $ac_try) 2>&5
7117 >  ac_status=$?
7118 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119 >  (exit $ac_status); }; } &&
7120 >         { ac_try='test -s conftest.$ac_objext'
7121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122 >  (eval $ac_try) 2>&5
7123 >  ac_status=$?
7124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125 >  (exit $ac_status); }; }; then
7126 >  echo "$as_me:$LINENO: result: yes" >&5
7127 > echo "${ECHO_T}yes" >&6
7128 > LIBS="-l$fftwname $LIBS"
7129 > cat >conftest.$ac_ext <<_ACEOF
7130 > /* confdefs.h.  */
7131 > _ACEOF
7132 > cat confdefs.h >>conftest.$ac_ext
7133 > cat >>conftest.$ac_ext <<_ACEOF
7134 > /* end confdefs.h.  */
7135 >
7136 >
7137 > #ifdef FC_DUMMY_MAIN
7138 > #ifndef FC_DUMMY_MAIN_EQ_F77
7139 > #  ifdef __cplusplus
7140 >     extern "C"
7141 > #  endif
7142 >   int FC_DUMMY_MAIN() { return 1; }
7143 > #endif
7144 > #endif
7145 > int
7146 > main ()
7147 > {
7148 > main ();
7149 >  ;
7150 >  return 0;
7151 > }
7152 > _ACEOF
7153 > rm -f conftest.$ac_objext conftest$ac_exeext
7154 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7155 >  (eval $ac_link) 2>conftest.er1
7156 >  ac_status=$?
7157 >  grep -v '^ *+' conftest.er1 >conftest.err
7158 >  rm -f conftest.er1
7159 >  cat conftest.err >&5
7160 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7161 >  (exit $ac_status); } &&
7162 >         { ac_try='test -z "$ac_c_werror_flag"
7163 >                         || test ! -s conftest.err'
7164 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7165 >  (eval $ac_try) 2>&5
7166 >  ac_status=$?
7167 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168 >  (exit $ac_status); }; } &&
7169 >         { ac_try='test -s conftest$ac_exeext'
7170 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171 >  (eval $ac_try) 2>&5
7172 >  ac_status=$?
7173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174 >  (exit $ac_status); }; }; then
7175 >  :
7176 > else
7177 >  echo "$as_me: failed program was:" >&5
7178 > sed 's/^/| /' conftest.$ac_ext >&5
7179 >
7180 > fi
7181 > rm -f conftest.err conftest.$ac_objext \
7182 >      conftest$ac_exeext conftest.$ac_ext
7183 > else
7184 >  echo "$as_me: failed program was:" >&5
7185 > sed 's/^/| /' conftest.$ac_ext >&5
7186 >
7187 >
7188 > echo "$as_me:$LINENO: result: no" >&5
7189 > echo "${ECHO_T}no" >&6
7190 > { { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
7191 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
7192 > echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
7193 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
7194 >   { (exit 1); exit 1; }; }
7195 >
7196 > fi
7197 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198 >
7199 > fi
7200 >
7201 >
7202 >  fi
7203 >
7204 >  case ${ac_fftw_savedprefix} in
7205 >   d)
7206 > cat >>confdefs.h <<\_ACEOF
7207 > #define FFTW_NAME_DFFTW
7208 > _ACEOF
7209 > ;;
7210 >   *)
7211 > cat >>confdefs.h <<\_ACEOF
7212 > #define FFTW_NAME_FFTW
7213 > _ACEOF
7214 > ;;
7215 >  esac
7216 > else
7217 >  echo "*******************************************************************"
7218 >  echo "* FFTW libraries and include files are required for computing     *"
7219 >  echo "* undulation spectra with the staticProps program.  If you don't  *"
7220 >  echo "* fftw turned on, OOPSE will still work, but you won't be able to *"
7221 >  echo "* analyze your trajectories for this property.                    *"
7222 >  echo "*******************************************************************"
7223 > fi # end of fftw check
7224 >
7225 > # Checks for header files.
7226 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7227 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7228 > if test "${ac_cv_header_stdc+set}" = set; then
7229 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7230 > else
7231 >  cat >conftest.$ac_ext <<_ACEOF
7232 > /* confdefs.h.  */
7233 > _ACEOF
7234 > cat confdefs.h >>conftest.$ac_ext
7235 > cat >>conftest.$ac_ext <<_ACEOF
7236 > /* end confdefs.h.  */
7237 > #include <stdlib.h>
7238 > #include <stdarg.h>
7239 > #include <string.h>
7240 > #include <float.h>
7241 >
7242 > #ifdef FC_DUMMY_MAIN
7243 > #ifndef FC_DUMMY_MAIN_EQ_F77
7244 > #  ifdef __cplusplus
7245 >     extern "C"
7246 > #  endif
7247 >   int FC_DUMMY_MAIN() { return 1; }
7248 > #endif
7249 > #endif
7250 > int
7251 > main ()
7252 > {
7253 >
7254 >  ;
7255 >  return 0;
7256 > }
7257 > _ACEOF
7258 > rm -f conftest.$ac_objext
7259 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7260 >  (eval $ac_compile) 2>conftest.er1
7261 >  ac_status=$?
7262 >  grep -v '^ *+' conftest.er1 >conftest.err
7263 >  rm -f conftest.er1
7264 >  cat conftest.err >&5
7265 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7266 >  (exit $ac_status); } &&
7267 >         { ac_try='test -z "$ac_c_werror_flag"
7268 >                         || test ! -s conftest.err'
7269 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7270 >  (eval $ac_try) 2>&5
7271 >  ac_status=$?
7272 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7273 >  (exit $ac_status); }; } &&
7274 >         { ac_try='test -s conftest.$ac_objext'
7275 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7276 >  (eval $ac_try) 2>&5
7277 >  ac_status=$?
7278 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7279 >  (exit $ac_status); }; }; then
7280 >  ac_cv_header_stdc=yes
7281 > else
7282 >  echo "$as_me: failed program was:" >&5
7283 > sed 's/^/| /' conftest.$ac_ext >&5
7284 >
7285 > ac_cv_header_stdc=no
7286 > fi
7287 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7288 >
7289 > if test $ac_cv_header_stdc = yes; then
7290 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7291 >  cat >conftest.$ac_ext <<_ACEOF
7292 > /* confdefs.h.  */
7293 > _ACEOF
7294 > cat confdefs.h >>conftest.$ac_ext
7295 > cat >>conftest.$ac_ext <<_ACEOF
7296 > /* end confdefs.h.  */
7297 > #include <string.h>
7298 >
7299 > _ACEOF
7300 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7301 >  $EGREP "memchr" >/dev/null 2>&1; then
7302 >  :
7303 > else
7304 >  ac_cv_header_stdc=no
7305 > fi
7306 > rm -f conftest*
7307 >
7308 > fi
7309 >
7310 > if test $ac_cv_header_stdc = yes; then
7311 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7312 >  cat >conftest.$ac_ext <<_ACEOF
7313 > /* confdefs.h.  */
7314 > _ACEOF
7315 > cat confdefs.h >>conftest.$ac_ext
7316 > cat >>conftest.$ac_ext <<_ACEOF
7317 > /* end confdefs.h.  */
7318 > #include <stdlib.h>
7319 >
7320 > _ACEOF
7321 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7322 >  $EGREP "free" >/dev/null 2>&1; then
7323 >  :
7324 > else
7325 >  ac_cv_header_stdc=no
7326 > fi
7327 > rm -f conftest*
7328 >
7329 > fi
7330 >
7331 > if test $ac_cv_header_stdc = yes; then
7332 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7333 >  if test "$cross_compiling" = yes; then
7334 >  :
7335 > else
7336 >  cat >conftest.$ac_ext <<_ACEOF
7337 > /* confdefs.h.  */
7338 > _ACEOF
7339 > cat confdefs.h >>conftest.$ac_ext
7340 > cat >>conftest.$ac_ext <<_ACEOF
7341 > /* end confdefs.h.  */
7342 > #include <ctype.h>
7343 > #if ((' ' & 0x0FF) == 0x020)
7344 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7345 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7346 > #else
7347 > # define ISLOWER(c) \
7348 >                   (('a' <= (c) && (c) <= 'i') \
7349 >                     || ('j' <= (c) && (c) <= 'r') \
7350 >                     || ('s' <= (c) && (c) <= 'z'))
7351 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7352 > #endif
7353 >
7354 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7355 > int
7356 > main ()
7357 > {
7358 >  int i;
7359 >  for (i = 0; i < 256; i++)
7360 >    if (XOR (islower (i), ISLOWER (i))
7361 >        || toupper (i) != TOUPPER (i))
7362 >      exit(2);
7363 >  exit (0);
7364 > }
7365 > _ACEOF
7366 > rm -f conftest$ac_exeext
7367 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7368 >  (eval $ac_link) 2>&5
7369 >  ac_status=$?
7370 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7372 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373 >  (eval $ac_try) 2>&5
7374 >  ac_status=$?
7375 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376 >  (exit $ac_status); }; }; then
7377 >  :
7378 > else
7379 >  echo "$as_me: program exited with status $ac_status" >&5
7380 > echo "$as_me: failed program was:" >&5
7381 > sed 's/^/| /' conftest.$ac_ext >&5
7382 >
7383 > ( exit $ac_status )
7384 > ac_cv_header_stdc=no
7385 > fi
7386 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7387 > fi
7388 > fi
7389 > fi
7390 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7391 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7392 > if test $ac_cv_header_stdc = yes; then
7393 >
7394 > cat >>confdefs.h <<\_ACEOF
7395 > #define STDC_HEADERS 1
7396 > _ACEOF
7397 >
7398 > fi
7399 >
7400 >
7401 >
7402 >
7403 >
7404 >
7405 >
7406 >
7407 >
7408 >
7409 >
7410 >
7411 >
7412 >
7413 >
7414 >
7415 >
7416 >
7417 >
7418 >
7419 >
7420 >
7421 >
7422 >
7423 >
7424 >
7425 > 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
7426 > do
7427 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7428 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7429 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7430 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7431 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7432 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7433 > fi
7434 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7435 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7436 > else
7437 >  # Is the header compilable?
7438 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7439 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7440 > cat >conftest.$ac_ext <<_ACEOF
7441 > /* confdefs.h.  */
7442 > _ACEOF
7443 > cat confdefs.h >>conftest.$ac_ext
7444 > cat >>conftest.$ac_ext <<_ACEOF
7445 > /* end confdefs.h.  */
7446 > $ac_includes_default
7447 > #include <$ac_header>
7448 > _ACEOF
7449 > rm -f conftest.$ac_objext
7450 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451 >  (eval $ac_compile) 2>conftest.er1
7452 >  ac_status=$?
7453 >  grep -v '^ *+' conftest.er1 >conftest.err
7454 >  rm -f conftest.er1
7455 >  cat conftest.err >&5
7456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457 >  (exit $ac_status); } &&
7458 >         { ac_try='test -z "$ac_c_werror_flag"
7459 >                         || test ! -s conftest.err'
7460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461 >  (eval $ac_try) 2>&5
7462 >  ac_status=$?
7463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464 >  (exit $ac_status); }; } &&
7465 >         { ac_try='test -s conftest.$ac_objext'
7466 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467 >  (eval $ac_try) 2>&5
7468 >  ac_status=$?
7469 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470 >  (exit $ac_status); }; }; then
7471 >  ac_header_compiler=yes
7472 > else
7473 >  echo "$as_me: failed program was:" >&5
7474 > sed 's/^/| /' conftest.$ac_ext >&5
7475 >
7476 > ac_header_compiler=no
7477 > fi
7478 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7480 > echo "${ECHO_T}$ac_header_compiler" >&6
7481 >
7482 > # Is the header present?
7483 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7484 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7485 > cat >conftest.$ac_ext <<_ACEOF
7486 > /* confdefs.h.  */
7487 > _ACEOF
7488 > cat confdefs.h >>conftest.$ac_ext
7489 > cat >>conftest.$ac_ext <<_ACEOF
7490 > /* end confdefs.h.  */
7491 > #include <$ac_header>
7492 > _ACEOF
7493 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7494 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7495 >  ac_status=$?
7496 >  grep -v '^ *+' conftest.er1 >conftest.err
7497 >  rm -f conftest.er1
7498 >  cat conftest.err >&5
7499 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500 >  (exit $ac_status); } >/dev/null; then
7501 >  if test -s conftest.err; then
7502 >    ac_cpp_err=$ac_c_preproc_warn_flag
7503 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7504 >  else
7505 >    ac_cpp_err=
7506 >  fi
7507 > else
7508 >  ac_cpp_err=yes
7509 > fi
7510 > if test -z "$ac_cpp_err"; then
7511 >  ac_header_preproc=yes
7512 > else
7513 >  echo "$as_me: failed program was:" >&5
7514 > sed 's/^/| /' conftest.$ac_ext >&5
7515 >
7516 >  ac_header_preproc=no
7517 > fi
7518 > rm -f conftest.err conftest.$ac_ext
7519 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7520 > echo "${ECHO_T}$ac_header_preproc" >&6
7521 >
7522 > # So?  What about this header?
7523 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7524 >  yes:no: )
7525 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7526 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7527 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7528 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7529 >    ac_header_preproc=yes
7530 >    ;;
7531 >  no:yes:* )
7532 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7533 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7534 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7535 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7536 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7537 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7538 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7539 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7540 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7541 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7542 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7543 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7544 >    (
7545 >      cat <<\_ASBOX
7546 > ## ------------------------------ ##
7547 > ## Report this to gezelter@nd.edu ##
7548 > ## ------------------------------ ##
7549 > _ASBOX
7550 >    ) |
7551 >      sed "s/^/$as_me: WARNING:     /" >&2
7552 >    ;;
7553 > esac
7554 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7555 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7556 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7557 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7558 > else
7559 >  eval "$as_ac_Header=\$ac_header_preproc"
7560 > fi
7561 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7562 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7563 >
7564 > fi
7565 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7566 >  cat >>confdefs.h <<_ACEOF
7567 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7568 > _ACEOF
7569 >
7570 > fi
7571 >
7572 > done
7573 >
7574 >
7575 > # Checks for typedefs, structures, and compiler characteristics.
7576 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7577 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7578 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7579 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7580 > else
7581 >  cat >conftest.$ac_ext <<_ACEOF
7582 > /* confdefs.h.  */
7583 > _ACEOF
7584 > cat confdefs.h >>conftest.$ac_ext
7585 > cat >>conftest.$ac_ext <<_ACEOF
7586 > /* end confdefs.h.  */
7587 >
7588 > #include <stdbool.h>
7589 > #ifndef bool
7590 > # error bool is not defined
7591 > #endif
7592 > #ifndef false
7593 > # error false is not defined
7594 > #endif
7595 > #if false
7596 > # error false is not 0
7597 > #endif
7598 > #ifndef true
7599 > # error true is not defined
7600 > #endif
7601 > #if true != 1
7602 > # error true is not 1
7603 > #endif
7604 > #ifndef __bool_true_false_are_defined
7605 > # error __bool_true_false_are_defined is not defined
7606 > #endif
7607 >
7608 >        struct s { _Bool s: 1; _Bool t; } s;
7609 >
7610 >        char a[true == 1 ? 1 : -1];
7611 >        char b[false == 0 ? 1 : -1];
7612 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7613 >        char d[(bool) -0.5 == true ? 1 : -1];
7614 >        bool e = &s;
7615 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7616 >        char g[true];
7617 >        char h[sizeof (_Bool)];
7618 >        char i[sizeof s.t];
7619 >
7620 > #ifdef FC_DUMMY_MAIN
7621 > #ifndef FC_DUMMY_MAIN_EQ_F77
7622 > #  ifdef __cplusplus
7623 >     extern "C"
7624 > #  endif
7625 >   int FC_DUMMY_MAIN() { return 1; }
7626 > #endif
7627 > #endif
7628 > int
7629 > main ()
7630 > {
7631 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7632 >  ;
7633 >  return 0;
7634 > }
7635 > _ACEOF
7636 > rm -f conftest.$ac_objext
7637 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7638 >  (eval $ac_compile) 2>conftest.er1
7639 >  ac_status=$?
7640 >  grep -v '^ *+' conftest.er1 >conftest.err
7641 >  rm -f conftest.er1
7642 >  cat conftest.err >&5
7643 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644 >  (exit $ac_status); } &&
7645 >         { ac_try='test -z "$ac_c_werror_flag"
7646 >                         || test ! -s conftest.err'
7647 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7648 >  (eval $ac_try) 2>&5
7649 >  ac_status=$?
7650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7651 >  (exit $ac_status); }; } &&
7652 >         { ac_try='test -s conftest.$ac_objext'
7653 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654 >  (eval $ac_try) 2>&5
7655 >  ac_status=$?
7656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657 >  (exit $ac_status); }; }; then
7658 >  ac_cv_header_stdbool_h=yes
7659 > else
7660 >  echo "$as_me: failed program was:" >&5
7661 > sed 's/^/| /' conftest.$ac_ext >&5
7662 >
7663 > ac_cv_header_stdbool_h=no
7664 > fi
7665 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666 > fi
7667 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7668 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7669 > echo "$as_me:$LINENO: checking for _Bool" >&5
7670 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7671 > if test "${ac_cv_type__Bool+set}" = set; then
7672 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7673 > else
7674 >  cat >conftest.$ac_ext <<_ACEOF
7675 > /* confdefs.h.  */
7676 > _ACEOF
7677 > cat confdefs.h >>conftest.$ac_ext
7678 > cat >>conftest.$ac_ext <<_ACEOF
7679 > /* end confdefs.h.  */
7680 > $ac_includes_default
7681 > #ifdef FC_DUMMY_MAIN
7682 > #ifndef FC_DUMMY_MAIN_EQ_F77
7683 > #  ifdef __cplusplus
7684 >     extern "C"
7685 > #  endif
7686 >   int FC_DUMMY_MAIN() { return 1; }
7687 > #endif
7688 > #endif
7689 > int
7690 > main ()
7691 > {
7692 > if ((_Bool *) 0)
7693 >  return 0;
7694 > if (sizeof (_Bool))
7695 >  return 0;
7696 >  ;
7697 >  return 0;
7698 > }
7699 > _ACEOF
7700 > rm -f conftest.$ac_objext
7701 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7702 >  (eval $ac_compile) 2>conftest.er1
7703 >  ac_status=$?
7704 >  grep -v '^ *+' conftest.er1 >conftest.err
7705 >  rm -f conftest.er1
7706 >  cat conftest.err >&5
7707 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7708 >  (exit $ac_status); } &&
7709 >         { ac_try='test -z "$ac_c_werror_flag"
7710 >                         || test ! -s conftest.err'
7711 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7712 >  (eval $ac_try) 2>&5
7713 >  ac_status=$?
7714 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7715 >  (exit $ac_status); }; } &&
7716 >         { ac_try='test -s conftest.$ac_objext'
7717 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718 >  (eval $ac_try) 2>&5
7719 >  ac_status=$?
7720 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721 >  (exit $ac_status); }; }; then
7722 >  ac_cv_type__Bool=yes
7723 > else
7724 >  echo "$as_me: failed program was:" >&5
7725 > sed 's/^/| /' conftest.$ac_ext >&5
7726 >
7727 > ac_cv_type__Bool=no
7728 > fi
7729 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730 > fi
7731 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7732 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7733 > if test $ac_cv_type__Bool = yes; then
7734 >
7735 > cat >>confdefs.h <<_ACEOF
7736 > #define HAVE__BOOL 1
7737 > _ACEOF
7738 >
7739 >
7740 > fi
7741 >
7742 > if test $ac_cv_header_stdbool_h = yes; then
7743 >
7744 > cat >>confdefs.h <<\_ACEOF
7745 > #define HAVE_STDBOOL_H 1
7746 > _ACEOF
7747 >
7748 > fi
7749 >
7750 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7751 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7752 > if test "${ac_cv_c_const+set}" = set; then
7753 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7754 > else
7755 >  cat >conftest.$ac_ext <<_ACEOF
7756 > /* confdefs.h.  */
7757 > _ACEOF
7758 > cat confdefs.h >>conftest.$ac_ext
7759 > cat >>conftest.$ac_ext <<_ACEOF
7760 > /* end confdefs.h.  */
7761 >
7762 > #ifdef FC_DUMMY_MAIN
7763 > #ifndef FC_DUMMY_MAIN_EQ_F77
7764 > #  ifdef __cplusplus
7765 >     extern "C"
7766 > #  endif
7767 >   int FC_DUMMY_MAIN() { return 1; }
7768 > #endif
7769 > #endif
7770 > int
7771 > main ()
7772 > {
7773 > /* FIXME: Include the comments suggested by Paul. */
7774 > #ifndef __cplusplus
7775 >  /* Ultrix mips cc rejects this.  */
7776 >  typedef int charset[2];
7777 >  const charset x;
7778 >  /* SunOS 4.1.1 cc rejects this.  */
7779 >  char const *const *ccp;
7780 >  char **p;
7781 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7782 >  struct point {int x, y;};
7783 >  static struct point const zero = {0,0};
7784 >  /* AIX XL C 1.02.0.0 rejects this.
7785 >     It does not let you subtract one const X* pointer from another in
7786 >     an arm of an if-expression whose if-part is not a constant
7787 >     expression */
7788 >  const char *g = "string";
7789 >  ccp = &g + (g ? g-g : 0);
7790 >  /* HPUX 7.0 cc rejects these. */
7791 >  ++ccp;
7792 >  p = (char**) ccp;
7793 >  ccp = (char const *const *) p;
7794 >  { /* SCO 3.2v4 cc rejects this.  */
7795 >    char *t;
7796 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7797 >
7798 >    *t++ = 0;
7799 >  }
7800 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7801 >    int x[] = {25, 17};
7802 >    const int *foo = &x[0];
7803 >    ++foo;
7804 >  }
7805 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7806 >    typedef const int *iptr;
7807 >    iptr p = 0;
7808 >    ++p;
7809 >  }
7810 >  { /* AIX XL C 1.02.0.0 rejects this saying
7811 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7812 >    struct s { int j; const int *ap[3]; };
7813 >    struct s *b; b->j = 5;
7814 >  }
7815 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7816 >    const int foo = 10;
7817 >  }
7818 > #endif
7819 >
7820 >  ;
7821 >  return 0;
7822 > }
7823 > _ACEOF
7824 > rm -f conftest.$ac_objext
7825 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7826 >  (eval $ac_compile) 2>conftest.er1
7827 >  ac_status=$?
7828 >  grep -v '^ *+' conftest.er1 >conftest.err
7829 >  rm -f conftest.er1
7830 >  cat conftest.err >&5
7831 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832 >  (exit $ac_status); } &&
7833 >         { ac_try='test -z "$ac_c_werror_flag"
7834 >                         || test ! -s conftest.err'
7835 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7836 >  (eval $ac_try) 2>&5
7837 >  ac_status=$?
7838 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7839 >  (exit $ac_status); }; } &&
7840 >         { ac_try='test -s conftest.$ac_objext'
7841 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7842 >  (eval $ac_try) 2>&5
7843 >  ac_status=$?
7844 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7845 >  (exit $ac_status); }; }; then
7846 >  ac_cv_c_const=yes
7847 > else
7848 >  echo "$as_me: failed program was:" >&5
7849 > sed 's/^/| /' conftest.$ac_ext >&5
7850 >
7851 > ac_cv_c_const=no
7852 > fi
7853 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7854 > fi
7855 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7856 > echo "${ECHO_T}$ac_cv_c_const" >&6
7857 > if test $ac_cv_c_const = no; then
7858 >
7859 > cat >>confdefs.h <<\_ACEOF
7860 > #define const
7861 > _ACEOF
7862 >
7863 > fi
7864 >
7865 > echo "$as_me:$LINENO: checking for inline" >&5
7866 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7867 > if test "${ac_cv_c_inline+set}" = set; then
7868 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7869 > else
7870 >  ac_cv_c_inline=no
7871 > for ac_kw in inline __inline__ __inline; do
7872 >  cat >conftest.$ac_ext <<_ACEOF
7873 > /* confdefs.h.  */
7874 > _ACEOF
7875 > cat confdefs.h >>conftest.$ac_ext
7876 > cat >>conftest.$ac_ext <<_ACEOF
7877 > /* end confdefs.h.  */
7878 > #ifndef __cplusplus
7879 > typedef int foo_t;
7880 > static $ac_kw foo_t static_foo () {return 0; }
7881 > $ac_kw foo_t foo () {return 0; }
7882 > #endif
7883 >
7884 > _ACEOF
7885 > rm -f conftest.$ac_objext
7886 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7887 >  (eval $ac_compile) 2>conftest.er1
7888 >  ac_status=$?
7889 >  grep -v '^ *+' conftest.er1 >conftest.err
7890 >  rm -f conftest.er1
7891 >  cat conftest.err >&5
7892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7893 >  (exit $ac_status); } &&
7894 >         { ac_try='test -z "$ac_c_werror_flag"
7895 >                         || test ! -s conftest.err'
7896 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7897 >  (eval $ac_try) 2>&5
7898 >  ac_status=$?
7899 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7900 >  (exit $ac_status); }; } &&
7901 >         { ac_try='test -s conftest.$ac_objext'
7902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7903 >  (eval $ac_try) 2>&5
7904 >  ac_status=$?
7905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906 >  (exit $ac_status); }; }; then
7907 >  ac_cv_c_inline=$ac_kw; break
7908 > else
7909 >  echo "$as_me: failed program was:" >&5
7910 > sed 's/^/| /' conftest.$ac_ext >&5
7911 >
7912 > fi
7913 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914 > done
7915 >
7916 > fi
7917 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7918 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7919 >
7920 >
7921 > case $ac_cv_c_inline in
7922 >  inline | yes) ;;
7923 >  *)
7924 >    case $ac_cv_c_inline in
7925 >      no) ac_val=;;
7926 >      *) ac_val=$ac_cv_c_inline;;
7927 >    esac
7928 >    cat >>confdefs.h <<_ACEOF
7929 > #ifndef __cplusplus
7930 > #define inline $ac_val
7931 > #endif
7932 > _ACEOF
7933 >    ;;
7934 > esac
7935 >
7936 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7937 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7938 > if test "${ac_cv_c_restrict+set}" = set; then
7939 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7940 > else
7941 >  ac_cv_c_restrict=no
7942 >   # Try the official restrict keyword, then gcc's __restrict, and
7943 >   # the less common variants.
7944 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7945 >     cat >conftest.$ac_ext <<_ACEOF
7946 > /* confdefs.h.  */
7947 > _ACEOF
7948 > cat confdefs.h >>conftest.$ac_ext
7949 > cat >>conftest.$ac_ext <<_ACEOF
7950 > /* end confdefs.h.  */
7951 > float * $ac_kw x;
7952 > _ACEOF
7953 > rm -f conftest.$ac_objext
7954 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7955 >  (eval $ac_compile) 2>conftest.er1
7956 >  ac_status=$?
7957 >  grep -v '^ *+' conftest.er1 >conftest.err
7958 >  rm -f conftest.er1
7959 >  cat conftest.err >&5
7960 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7961 >  (exit $ac_status); } &&
7962 >         { ac_try='test -z "$ac_c_werror_flag"
7963 >                         || test ! -s conftest.err'
7964 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7965 >  (eval $ac_try) 2>&5
7966 >  ac_status=$?
7967 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968 >  (exit $ac_status); }; } &&
7969 >         { ac_try='test -s conftest.$ac_objext'
7970 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7971 >  (eval $ac_try) 2>&5
7972 >  ac_status=$?
7973 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7974 >  (exit $ac_status); }; }; then
7975 >  ac_cv_c_restrict=$ac_kw; break
7976 > else
7977 >  echo "$as_me: failed program was:" >&5
7978 > sed 's/^/| /' conftest.$ac_ext >&5
7979 >
7980 > fi
7981 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7982 >   done
7983 >
7984 > fi
7985 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7986 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7987 > case $ac_cv_c_restrict in
7988 >   restrict) ;;
7989 >   no)
7990 > cat >>confdefs.h <<\_ACEOF
7991 > #define restrict
7992 > _ACEOF
7993 > ;;
7994 >   *)  cat >>confdefs.h <<_ACEOF
7995 > #define restrict $ac_cv_c_restrict
7996 > _ACEOF
7997 > ;;
7998 > esac
7999 >
8000 > echo "$as_me:$LINENO: checking for size_t" >&5
8001 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8002 > if test "${ac_cv_type_size_t+set}" = set; then
8003 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8004 > else
8005 >  cat >conftest.$ac_ext <<_ACEOF
8006 > /* confdefs.h.  */
8007 > _ACEOF
8008 > cat confdefs.h >>conftest.$ac_ext
8009 > cat >>conftest.$ac_ext <<_ACEOF
8010 > /* end confdefs.h.  */
8011 > $ac_includes_default
8012 > #ifdef FC_DUMMY_MAIN
8013 > #ifndef FC_DUMMY_MAIN_EQ_F77
8014 > #  ifdef __cplusplus
8015 >     extern "C"
8016 > #  endif
8017 >   int FC_DUMMY_MAIN() { return 1; }
8018 > #endif
8019 > #endif
8020 > int
8021 > main ()
8022 > {
8023 > if ((size_t *) 0)
8024 >  return 0;
8025 > if (sizeof (size_t))
8026 >  return 0;
8027 >  ;
8028 >  return 0;
8029 > }
8030 > _ACEOF
8031 > rm -f conftest.$ac_objext
8032 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8033 >  (eval $ac_compile) 2>conftest.er1
8034 >  ac_status=$?
8035 >  grep -v '^ *+' conftest.er1 >conftest.err
8036 >  rm -f conftest.er1
8037 >  cat conftest.err >&5
8038 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8039 >  (exit $ac_status); } &&
8040 >         { ac_try='test -z "$ac_c_werror_flag"
8041 >                         || test ! -s conftest.err'
8042 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8043 >  (eval $ac_try) 2>&5
8044 >  ac_status=$?
8045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8046 >  (exit $ac_status); }; } &&
8047 >         { ac_try='test -s conftest.$ac_objext'
8048 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8049 >  (eval $ac_try) 2>&5
8050 >  ac_status=$?
8051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8052 >  (exit $ac_status); }; }; then
8053 >  ac_cv_type_size_t=yes
8054 > else
8055 >  echo "$as_me: failed program was:" >&5
8056 > sed 's/^/| /' conftest.$ac_ext >&5
8057 >
8058 > ac_cv_type_size_t=no
8059 > fi
8060 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8061 > fi
8062 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8063 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
8064 > if test $ac_cv_type_size_t = yes; then
8065 >  :
8066 > else
8067 >
8068 > cat >>confdefs.h <<_ACEOF
8069 > #define size_t unsigned
8070 > _ACEOF
8071 >
8072 > fi
8073 >
8074 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8075 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8076 > if test "${ac_cv_header_time+set}" = set; then
8077 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8078 > else
8079 >  cat >conftest.$ac_ext <<_ACEOF
8080 > /* confdefs.h.  */
8081 > _ACEOF
8082 > cat confdefs.h >>conftest.$ac_ext
8083 > cat >>conftest.$ac_ext <<_ACEOF
8084 > /* end confdefs.h.  */
8085 > #include <sys/types.h>
8086 > #include <sys/time.h>
8087 > #include <time.h>
8088 >
8089 > #ifdef FC_DUMMY_MAIN
8090 > #ifndef FC_DUMMY_MAIN_EQ_F77
8091 > #  ifdef __cplusplus
8092 >     extern "C"
8093 > #  endif
8094 >   int FC_DUMMY_MAIN() { return 1; }
8095 > #endif
8096 > #endif
8097 > int
8098 > main ()
8099 > {
8100 > if ((struct tm *) 0)
8101 > return 0;
8102 >  ;
8103 >  return 0;
8104 > }
8105 > _ACEOF
8106 > rm -f conftest.$ac_objext
8107 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8108 >  (eval $ac_compile) 2>conftest.er1
8109 >  ac_status=$?
8110 >  grep -v '^ *+' conftest.er1 >conftest.err
8111 >  rm -f conftest.er1
8112 >  cat conftest.err >&5
8113 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8114 >  (exit $ac_status); } &&
8115 >         { ac_try='test -z "$ac_c_werror_flag"
8116 >                         || test ! -s conftest.err'
8117 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8118 >  (eval $ac_try) 2>&5
8119 >  ac_status=$?
8120 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121 >  (exit $ac_status); }; } &&
8122 >         { ac_try='test -s conftest.$ac_objext'
8123 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8124 >  (eval $ac_try) 2>&5
8125 >  ac_status=$?
8126 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8127 >  (exit $ac_status); }; }; then
8128 >  ac_cv_header_time=yes
8129 > else
8130 >  echo "$as_me: failed program was:" >&5
8131 > sed 's/^/| /' conftest.$ac_ext >&5
8132 >
8133 > ac_cv_header_time=no
8134 > fi
8135 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136 > fi
8137 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8138 > echo "${ECHO_T}$ac_cv_header_time" >&6
8139 > if test $ac_cv_header_time = yes; then
8140 >
8141 > cat >>confdefs.h <<\_ACEOF
8142 > #define TIME_WITH_SYS_TIME 1
8143 > _ACEOF
8144 >
8145 > fi
8146 >
8147 > echo "$as_me:$LINENO: checking for clock_t" >&5
8148 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8149 > if test "${ac_cv_type_clock_t+set}" = set; then
8150 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8151 > else
8152 >  cat >conftest.$ac_ext <<_ACEOF
8153 > /* confdefs.h.  */
8154 > _ACEOF
8155 > cat confdefs.h >>conftest.$ac_ext
8156 > cat >>conftest.$ac_ext <<_ACEOF
8157 > /* end confdefs.h.  */
8158 > $ac_includes_default
8159 > #ifdef FC_DUMMY_MAIN
8160 > #ifndef FC_DUMMY_MAIN_EQ_F77
8161 > #  ifdef __cplusplus
8162 >     extern "C"
8163 > #  endif
8164 >   int FC_DUMMY_MAIN() { return 1; }
8165 > #endif
8166 > #endif
8167 > int
8168 > main ()
8169 > {
8170 > if ((clock_t *) 0)
8171 >  return 0;
8172 > if (sizeof (clock_t))
8173 >  return 0;
8174 >  ;
8175 >  return 0;
8176 > }
8177 > _ACEOF
8178 > rm -f conftest.$ac_objext
8179 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180 >  (eval $ac_compile) 2>conftest.er1
8181 >  ac_status=$?
8182 >  grep -v '^ *+' conftest.er1 >conftest.err
8183 >  rm -f conftest.er1
8184 >  cat conftest.err >&5
8185 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186 >  (exit $ac_status); } &&
8187 >         { ac_try='test -z "$ac_c_werror_flag"
8188 >                         || test ! -s conftest.err'
8189 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190 >  (eval $ac_try) 2>&5
8191 >  ac_status=$?
8192 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193 >  (exit $ac_status); }; } &&
8194 >         { ac_try='test -s conftest.$ac_objext'
8195 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196 >  (eval $ac_try) 2>&5
8197 >  ac_status=$?
8198 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199 >  (exit $ac_status); }; }; then
8200 >  ac_cv_type_clock_t=yes
8201 > else
8202 >  echo "$as_me: failed program was:" >&5
8203 > sed 's/^/| /' conftest.$ac_ext >&5
8204 >
8205 > ac_cv_type_clock_t=no
8206 > fi
8207 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8208 > fi
8209 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8210 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8211 > if test $ac_cv_type_clock_t = yes; then
8212 >
8213 > cat >>confdefs.h <<_ACEOF
8214 > #define HAVE_CLOCK_T 1
8215 > _ACEOF
8216 >
8217 >
8218 > fi
8219 >
8220 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8221 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8222 > if test "${ac_cv_c_const+set}" = set; then
8223 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8224 > else
8225 >  cat >conftest.$ac_ext <<_ACEOF
8226 > /* confdefs.h.  */
8227 > _ACEOF
8228 > cat confdefs.h >>conftest.$ac_ext
8229 > cat >>conftest.$ac_ext <<_ACEOF
8230 > /* end confdefs.h.  */
8231 >
8232 > #ifdef FC_DUMMY_MAIN
8233 > #ifndef FC_DUMMY_MAIN_EQ_F77
8234 > #  ifdef __cplusplus
8235 >     extern "C"
8236 > #  endif
8237 >   int FC_DUMMY_MAIN() { return 1; }
8238 > #endif
8239 > #endif
8240 > int
8241 > main ()
8242 > {
8243 > /* FIXME: Include the comments suggested by Paul. */
8244 > #ifndef __cplusplus
8245 >  /* Ultrix mips cc rejects this.  */
8246 >  typedef int charset[2];
8247 >  const charset x;
8248 >  /* SunOS 4.1.1 cc rejects this.  */
8249 >  char const *const *ccp;
8250 >  char **p;
8251 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8252 >  struct point {int x, y;};
8253 >  static struct point const zero = {0,0};
8254 >  /* AIX XL C 1.02.0.0 rejects this.
8255 >     It does not let you subtract one const X* pointer from another in
8256 >     an arm of an if-expression whose if-part is not a constant
8257 >     expression */
8258 >  const char *g = "string";
8259 >  ccp = &g + (g ? g-g : 0);
8260 >  /* HPUX 7.0 cc rejects these. */
8261 >  ++ccp;
8262 >  p = (char**) ccp;
8263 >  ccp = (char const *const *) p;
8264 >  { /* SCO 3.2v4 cc rejects this.  */
8265 >    char *t;
8266 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8267 >
8268 >    *t++ = 0;
8269 >  }
8270 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8271 >    int x[] = {25, 17};
8272 >    const int *foo = &x[0];
8273 >    ++foo;
8274 >  }
8275 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8276 >    typedef const int *iptr;
8277 >    iptr p = 0;
8278 >    ++p;
8279 >  }
8280 >  { /* AIX XL C 1.02.0.0 rejects this saying
8281 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8282 >    struct s { int j; const int *ap[3]; };
8283 >    struct s *b; b->j = 5;
8284 >  }
8285 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8286 >    const int foo = 10;
8287 >  }
8288 > #endif
8289 >
8290 >  ;
8291 >  return 0;
8292 > }
8293 > _ACEOF
8294 > rm -f conftest.$ac_objext
8295 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8296 >  (eval $ac_compile) 2>conftest.er1
8297 >  ac_status=$?
8298 >  grep -v '^ *+' conftest.er1 >conftest.err
8299 >  rm -f conftest.er1
8300 >  cat conftest.err >&5
8301 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302 >  (exit $ac_status); } &&
8303 >         { ac_try='test -z "$ac_c_werror_flag"
8304 >                         || test ! -s conftest.err'
8305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306 >  (eval $ac_try) 2>&5
8307 >  ac_status=$?
8308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309 >  (exit $ac_status); }; } &&
8310 >         { ac_try='test -s conftest.$ac_objext'
8311 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8312 >  (eval $ac_try) 2>&5
8313 >  ac_status=$?
8314 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8315 >  (exit $ac_status); }; }; then
8316 >  ac_cv_c_const=yes
8317 > else
8318 >  echo "$as_me: failed program was:" >&5
8319 > sed 's/^/| /' conftest.$ac_ext >&5
8320 >
8321 > ac_cv_c_const=no
8322 > fi
8323 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8324 > fi
8325 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8326 > echo "${ECHO_T}$ac_cv_c_const" >&6
8327 > if test $ac_cv_c_const = no; then
8328 >
8329 > cat >>confdefs.h <<\_ACEOF
8330 > #define const
8331 > _ACEOF
8332 >
8333 > fi
8334 >
8335 > echo "$as_me:$LINENO: checking for inline" >&5
8336 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8337 > if test "${ac_cv_c_inline+set}" = set; then
8338 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8339 > else
8340 >  ac_cv_c_inline=no
8341 > for ac_kw in inline __inline__ __inline; do
8342 >  cat >conftest.$ac_ext <<_ACEOF
8343 > /* confdefs.h.  */
8344 > _ACEOF
8345 > cat confdefs.h >>conftest.$ac_ext
8346 > cat >>conftest.$ac_ext <<_ACEOF
8347 > /* end confdefs.h.  */
8348 > #ifndef __cplusplus
8349 > typedef int foo_t;
8350 > static $ac_kw foo_t static_foo () {return 0; }
8351 > $ac_kw foo_t foo () {return 0; }
8352 > #endif
8353 >
8354 > _ACEOF
8355 > rm -f conftest.$ac_objext
8356 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8357 >  (eval $ac_compile) 2>conftest.er1
8358 >  ac_status=$?
8359 >  grep -v '^ *+' conftest.er1 >conftest.err
8360 >  rm -f conftest.er1
8361 >  cat conftest.err >&5
8362 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8363 >  (exit $ac_status); } &&
8364 >         { ac_try='test -z "$ac_c_werror_flag"
8365 >                         || test ! -s conftest.err'
8366 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8367 >  (eval $ac_try) 2>&5
8368 >  ac_status=$?
8369 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370 >  (exit $ac_status); }; } &&
8371 >         { ac_try='test -s conftest.$ac_objext'
8372 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373 >  (eval $ac_try) 2>&5
8374 >  ac_status=$?
8375 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376 >  (exit $ac_status); }; }; then
8377 >  ac_cv_c_inline=$ac_kw; break
8378 > else
8379 >  echo "$as_me: failed program was:" >&5
8380 > sed 's/^/| /' conftest.$ac_ext >&5
8381 >
8382 > fi
8383 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8384 > done
8385 >
8386 > fi
8387 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8388 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8389 >
8390 >
8391 > case $ac_cv_c_inline in
8392 >  inline | yes) ;;
8393 >  *)
8394 >    case $ac_cv_c_inline in
8395 >      no) ac_val=;;
8396 >      *) ac_val=$ac_cv_c_inline;;
8397 >    esac
8398 >    cat >>confdefs.h <<_ACEOF
8399 > #ifndef __cplusplus
8400 > #define inline $ac_val
8401 > #endif
8402 > _ACEOF
8403 >    ;;
8404 > esac
8405 >
8406 >
8407 > # Checks for library functions.
8408 >
8409 > for ac_header in stdlib.h
8410 > do
8411 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8412 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8413 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8414 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8415 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8416 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8417 > fi
8418 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8419 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8420 > else
8421 >  # Is the header compilable?
8422 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8423 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8424 > cat >conftest.$ac_ext <<_ACEOF
8425 > /* confdefs.h.  */
8426 > _ACEOF
8427 > cat confdefs.h >>conftest.$ac_ext
8428 > cat >>conftest.$ac_ext <<_ACEOF
8429 > /* end confdefs.h.  */
8430 > $ac_includes_default
8431 > #include <$ac_header>
8432 > _ACEOF
8433 > rm -f conftest.$ac_objext
8434 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8435 >  (eval $ac_compile) 2>conftest.er1
8436 >  ac_status=$?
8437 >  grep -v '^ *+' conftest.er1 >conftest.err
8438 >  rm -f conftest.er1
8439 >  cat conftest.err >&5
8440 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8441 >  (exit $ac_status); } &&
8442 >         { ac_try='test -z "$ac_c_werror_flag"
8443 >                         || test ! -s conftest.err'
8444 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445 >  (eval $ac_try) 2>&5
8446 >  ac_status=$?
8447 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448 >  (exit $ac_status); }; } &&
8449 >         { ac_try='test -s conftest.$ac_objext'
8450 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451 >  (eval $ac_try) 2>&5
8452 >  ac_status=$?
8453 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454 >  (exit $ac_status); }; }; then
8455 >  ac_header_compiler=yes
8456 > else
8457 >  echo "$as_me: failed program was:" >&5
8458 > sed 's/^/| /' conftest.$ac_ext >&5
8459 >
8460 > ac_header_compiler=no
8461 > fi
8462 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8463 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8464 > echo "${ECHO_T}$ac_header_compiler" >&6
8465 >
8466 > # Is the header present?
8467 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8468 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8469 > cat >conftest.$ac_ext <<_ACEOF
8470 > /* confdefs.h.  */
8471 > _ACEOF
8472 > cat confdefs.h >>conftest.$ac_ext
8473 > cat >>conftest.$ac_ext <<_ACEOF
8474 > /* end confdefs.h.  */
8475 > #include <$ac_header>
8476 > _ACEOF
8477 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8478 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8479 >  ac_status=$?
8480 >  grep -v '^ *+' conftest.er1 >conftest.err
8481 >  rm -f conftest.er1
8482 >  cat conftest.err >&5
8483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484 >  (exit $ac_status); } >/dev/null; then
8485 >  if test -s conftest.err; then
8486 >    ac_cpp_err=$ac_c_preproc_warn_flag
8487 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8488 >  else
8489 >    ac_cpp_err=
8490 >  fi
8491 > else
8492 >  ac_cpp_err=yes
8493 > fi
8494 > if test -z "$ac_cpp_err"; then
8495 >  ac_header_preproc=yes
8496 > else
8497 >  echo "$as_me: failed program was:" >&5
8498 > sed 's/^/| /' conftest.$ac_ext >&5
8499 >
8500 >  ac_header_preproc=no
8501 > fi
8502 > rm -f conftest.err conftest.$ac_ext
8503 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8504 > echo "${ECHO_T}$ac_header_preproc" >&6
8505 >
8506 > # So?  What about this header?
8507 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8508 >  yes:no: )
8509 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8510 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8511 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8512 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8513 >    ac_header_preproc=yes
8514 >    ;;
8515 >  no:yes:* )
8516 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8517 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8518 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8519 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8520 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8521 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8522 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8523 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8524 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8525 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8526 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8527 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8528 >    (
8529 >      cat <<\_ASBOX
8530 > ## ------------------------------ ##
8531 > ## Report this to gezelter@nd.edu ##
8532 > ## ------------------------------ ##
8533 > _ASBOX
8534 >    ) |
8535 >      sed "s/^/$as_me: WARNING:     /" >&2
8536 >    ;;
8537 > esac
8538 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8539 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8540 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8541 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8542 > else
8543 >  eval "$as_ac_Header=\$ac_header_preproc"
8544 > fi
8545 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8546 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8547 >
8548 > fi
8549 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8550 >  cat >>confdefs.h <<_ACEOF
8551 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8552 > _ACEOF
8553 >
8554 > fi
8555 >
8556 > done
8557 >
8558 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8559 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8560 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8561 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8562 > else
8563 >  if test "$cross_compiling" = yes; then
8564 >  ac_cv_func_malloc_0_nonnull=no
8565 > else
8566 >  cat >conftest.$ac_ext <<_ACEOF
8567 > /* confdefs.h.  */
8568 > _ACEOF
8569 > cat confdefs.h >>conftest.$ac_ext
8570 > cat >>conftest.$ac_ext <<_ACEOF
8571 > /* end confdefs.h.  */
8572 > #if STDC_HEADERS || HAVE_STDLIB_H
8573 > # include <stdlib.h>
8574 > #else
8575 > char *malloc ();
8576 > #endif
8577 >
8578 > #ifdef FC_DUMMY_MAIN
8579 > #ifndef FC_DUMMY_MAIN_EQ_F77
8580 > #  ifdef __cplusplus
8581 >     extern "C"
8582 > #  endif
8583 >   int FC_DUMMY_MAIN() { return 1; }
8584 > #endif
8585 > #endif
8586 > int
8587 > main ()
8588 > {
8589 > exit (malloc (0) ? 0 : 1);
8590 >  ;
8591 >  return 0;
8592 > }
8593 > _ACEOF
8594 > rm -f conftest$ac_exeext
8595 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8596 >  (eval $ac_link) 2>&5
8597 >  ac_status=$?
8598 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8601 >  (eval $ac_try) 2>&5
8602 >  ac_status=$?
8603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604 >  (exit $ac_status); }; }; then
8605 >  ac_cv_func_malloc_0_nonnull=yes
8606 > else
8607 >  echo "$as_me: program exited with status $ac_status" >&5
8608 > echo "$as_me: failed program was:" >&5
8609 > sed 's/^/| /' conftest.$ac_ext >&5
8610 >
8611 > ( exit $ac_status )
8612 > ac_cv_func_malloc_0_nonnull=no
8613 > fi
8614 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8615 > fi
8616 > fi
8617 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8618 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8619 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8620 >
8621 > cat >>confdefs.h <<\_ACEOF
8622 > #define HAVE_MALLOC 1
8623 > _ACEOF
8624 >
8625 > else
8626 >  cat >>confdefs.h <<\_ACEOF
8627 > #define HAVE_MALLOC 0
8628 > _ACEOF
8629 >
8630 >   case $LIBOBJS in
8631 >    "malloc.$ac_objext"   | \
8632 >  *" malloc.$ac_objext"   | \
8633 >    "malloc.$ac_objext "* | \
8634 >  *" malloc.$ac_objext "* ) ;;
8635 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8636 > esac
8637 >
8638 >
8639 > cat >>confdefs.h <<\_ACEOF
8640 > #define malloc rpl_malloc
8641 > _ACEOF
8642 >
8643 > fi
8644 >
8645 >
8646 >
8647 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8648 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8649 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8650 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8651 > else
8652 >  if test "$cross_compiling" = yes; then
8653 >  ac_cv_func_memcmp_working=no
8654 > else
8655 >  cat >conftest.$ac_ext <<_ACEOF
8656 > /* confdefs.h.  */
8657 > _ACEOF
8658 > cat confdefs.h >>conftest.$ac_ext
8659 > cat >>conftest.$ac_ext <<_ACEOF
8660 > /* end confdefs.h.  */
8661 > $ac_includes_default
8662 > #ifdef FC_DUMMY_MAIN
8663 > #ifndef FC_DUMMY_MAIN_EQ_F77
8664 > #  ifdef __cplusplus
8665 >     extern "C"
8666 > #  endif
8667 >   int FC_DUMMY_MAIN() { return 1; }
8668 > #endif
8669 > #endif
8670 > int
8671 > main ()
8672 > {
8673 >
8674 >  /* Some versions of memcmp are not 8-bit clean.  */
8675 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8676 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8677 >    exit (1);
8678 >
8679 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8680 >     or more and with at least one buffer not starting on a 4-byte boundary.
8681 >     William Lewis provided this test program.   */
8682 >  {
8683 >    char foo[21];
8684 >    char bar[21];
8685 >    int i;
8686 >    for (i = 0; i < 4; i++)
8687 >      {
8688 >        char *a = foo + i;
8689 >        char *b = bar + i;
8690 >        strcpy (a, "--------01111111");
8691 >        strcpy (b, "--------10000000");
8692 >        if (memcmp (a, b, 16) >= 0)
8693 >          exit (1);
8694 >      }
8695 >    exit (0);
8696 >  }
8697 >
8698 >  ;
8699 >  return 0;
8700 > }
8701 > _ACEOF
8702 > rm -f conftest$ac_exeext
8703 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8704 >  (eval $ac_link) 2>&5
8705 >  ac_status=$?
8706 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8707 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8708 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709 >  (eval $ac_try) 2>&5
8710 >  ac_status=$?
8711 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712 >  (exit $ac_status); }; }; then
8713 >  ac_cv_func_memcmp_working=yes
8714 > else
8715 >  echo "$as_me: program exited with status $ac_status" >&5
8716 > echo "$as_me: failed program was:" >&5
8717 > sed 's/^/| /' conftest.$ac_ext >&5
8718 >
8719 > ( exit $ac_status )
8720 > ac_cv_func_memcmp_working=no
8721 > fi
8722 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8723 > fi
8724 > fi
8725 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8726 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8727 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8728 >    "memcmp.$ac_objext"   | \
8729 >  *" memcmp.$ac_objext"   | \
8730 >    "memcmp.$ac_objext "* | \
8731 >  *" memcmp.$ac_objext "* ) ;;
8732 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8733 > esac
8734 >
8735 >
8736 >
8737 > for ac_header in stdlib.h
8738 > do
8739 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8740 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8741 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8742 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8743 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8744 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8745 > fi
8746 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8747 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8748 > else
8749 >  # Is the header compilable?
8750 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8751 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8752 > cat >conftest.$ac_ext <<_ACEOF
8753 > /* confdefs.h.  */
8754 > _ACEOF
8755 > cat confdefs.h >>conftest.$ac_ext
8756 > cat >>conftest.$ac_ext <<_ACEOF
8757 > /* end confdefs.h.  */
8758 > $ac_includes_default
8759 > #include <$ac_header>
8760 > _ACEOF
8761 > rm -f conftest.$ac_objext
8762 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8763 >  (eval $ac_compile) 2>conftest.er1
8764 >  ac_status=$?
8765 >  grep -v '^ *+' conftest.er1 >conftest.err
8766 >  rm -f conftest.er1
8767 >  cat conftest.err >&5
8768 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8769 >  (exit $ac_status); } &&
8770 >         { ac_try='test -z "$ac_c_werror_flag"
8771 >                         || test ! -s conftest.err'
8772 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8773 >  (eval $ac_try) 2>&5
8774 >  ac_status=$?
8775 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8776 >  (exit $ac_status); }; } &&
8777 >         { ac_try='test -s conftest.$ac_objext'
8778 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779 >  (eval $ac_try) 2>&5
8780 >  ac_status=$?
8781 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782 >  (exit $ac_status); }; }; then
8783 >  ac_header_compiler=yes
8784 > else
8785 >  echo "$as_me: failed program was:" >&5
8786 > sed 's/^/| /' conftest.$ac_ext >&5
8787 >
8788 > ac_header_compiler=no
8789 > fi
8790 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8791 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8792 > echo "${ECHO_T}$ac_header_compiler" >&6
8793 >
8794 > # Is the header present?
8795 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8796 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8797 > cat >conftest.$ac_ext <<_ACEOF
8798 > /* confdefs.h.  */
8799 > _ACEOF
8800 > cat confdefs.h >>conftest.$ac_ext
8801 > cat >>conftest.$ac_ext <<_ACEOF
8802 > /* end confdefs.h.  */
8803 > #include <$ac_header>
8804 > _ACEOF
8805 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8806 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8807 >  ac_status=$?
8808 >  grep -v '^ *+' conftest.er1 >conftest.err
8809 >  rm -f conftest.er1
8810 >  cat conftest.err >&5
8811 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8812 >  (exit $ac_status); } >/dev/null; then
8813 >  if test -s conftest.err; then
8814 >    ac_cpp_err=$ac_c_preproc_warn_flag
8815 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8816 >  else
8817 >    ac_cpp_err=
8818 >  fi
8819 > else
8820 >  ac_cpp_err=yes
8821 > fi
8822 > if test -z "$ac_cpp_err"; then
8823 >  ac_header_preproc=yes
8824 > else
8825 >  echo "$as_me: failed program was:" >&5
8826 > sed 's/^/| /' conftest.$ac_ext >&5
8827 >
8828 >  ac_header_preproc=no
8829 > fi
8830 > rm -f conftest.err conftest.$ac_ext
8831 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8832 > echo "${ECHO_T}$ac_header_preproc" >&6
8833 >
8834 > # So?  What about this header?
8835 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8836 >  yes:no: )
8837 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8838 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8839 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8840 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8841 >    ac_header_preproc=yes
8842 >    ;;
8843 >  no:yes:* )
8844 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8845 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8846 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8847 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8848 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8849 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8850 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8851 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8852 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8853 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8854 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8855 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8856 >    (
8857 >      cat <<\_ASBOX
8858 > ## ------------------------------ ##
8859 > ## Report this to gezelter@nd.edu ##
8860 > ## ------------------------------ ##
8861 > _ASBOX
8862 >    ) |
8863 >      sed "s/^/$as_me: WARNING:     /" >&2
8864 >    ;;
8865 > esac
8866 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8867 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8868 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8869 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8870 > else
8871 >  eval "$as_ac_Header=\$ac_header_preproc"
8872 > fi
8873 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8874 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8875 >
8876 > fi
8877 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8878 >  cat >>confdefs.h <<_ACEOF
8879 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8880 > _ACEOF
8881 >
8882 > fi
8883 >
8884 > done
8885 >
8886 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8887 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8888 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8890 > else
8891 >  if test "$cross_compiling" = yes; then
8892 >  ac_cv_func_realloc_0_nonnull=no
8893 > else
8894 >  cat >conftest.$ac_ext <<_ACEOF
8895 > /* confdefs.h.  */
8896 > _ACEOF
8897 > cat confdefs.h >>conftest.$ac_ext
8898 > cat >>conftest.$ac_ext <<_ACEOF
8899 > /* end confdefs.h.  */
8900 > #if STDC_HEADERS || HAVE_STDLIB_H
8901 > # include <stdlib.h>
8902 > #else
8903 > char *realloc ();
8904 > #endif
8905 >
8906 > #ifdef FC_DUMMY_MAIN
8907 > #ifndef FC_DUMMY_MAIN_EQ_F77
8908 > #  ifdef __cplusplus
8909 >     extern "C"
8910 > #  endif
8911 >   int FC_DUMMY_MAIN() { return 1; }
8912 > #endif
8913 > #endif
8914 > int
8915 > main ()
8916 > {
8917 > exit (realloc (0, 0) ? 0 : 1);
8918 >  ;
8919 >  return 0;
8920 > }
8921 > _ACEOF
8922 > rm -f conftest$ac_exeext
8923 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8924 >  (eval $ac_link) 2>&5
8925 >  ac_status=$?
8926 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8928 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929 >  (eval $ac_try) 2>&5
8930 >  ac_status=$?
8931 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932 >  (exit $ac_status); }; }; then
8933 >  ac_cv_func_realloc_0_nonnull=yes
8934 > else
8935 >  echo "$as_me: program exited with status $ac_status" >&5
8936 > echo "$as_me: failed program was:" >&5
8937 > sed 's/^/| /' conftest.$ac_ext >&5
8938 >
8939 > ( exit $ac_status )
8940 > ac_cv_func_realloc_0_nonnull=no
8941 > fi
8942 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8943 > fi
8944 > fi
8945 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8946 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8947 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8948 >
8949 > cat >>confdefs.h <<\_ACEOF
8950 > #define HAVE_REALLOC 1
8951 > _ACEOF
8952 >
8953 > else
8954 >  cat >>confdefs.h <<\_ACEOF
8955 > #define HAVE_REALLOC 0
8956 > _ACEOF
8957 >
8958 >   case $LIBOBJS in
8959 >    "realloc.$ac_objext"   | \
8960 >  *" realloc.$ac_objext"   | \
8961 >    "realloc.$ac_objext "* | \
8962 >  *" realloc.$ac_objext "* ) ;;
8963 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8964 > esac
8965 >
8966 >
8967 > cat >>confdefs.h <<\_ACEOF
8968 > #define realloc rpl_realloc
8969 > _ACEOF
8970 >
8971 > fi
8972 >
8973 >
8974 >
8975 >
8976 >
8977 > for ac_header in sys/select.h sys/socket.h
8978 > do
8979 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8980 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8981 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8982 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8983 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8984 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8985 > fi
8986 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8987 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8988 > else
8989 >  # Is the header compilable?
8990 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8991 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8992 > cat >conftest.$ac_ext <<_ACEOF
8993 > /* confdefs.h.  */
8994 > _ACEOF
8995 > cat confdefs.h >>conftest.$ac_ext
8996 > cat >>conftest.$ac_ext <<_ACEOF
8997 > /* end confdefs.h.  */
8998 > $ac_includes_default
8999 > #include <$ac_header>
9000 > _ACEOF
9001 > rm -f conftest.$ac_objext
9002 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9003 >  (eval $ac_compile) 2>conftest.er1
9004 >  ac_status=$?
9005 >  grep -v '^ *+' conftest.er1 >conftest.err
9006 >  rm -f conftest.er1
9007 >  cat conftest.err >&5
9008 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009 >  (exit $ac_status); } &&
9010 >         { ac_try='test -z "$ac_c_werror_flag"
9011 >                         || test ! -s conftest.err'
9012 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9013 >  (eval $ac_try) 2>&5
9014 >  ac_status=$?
9015 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9016 >  (exit $ac_status); }; } &&
9017 >         { ac_try='test -s conftest.$ac_objext'
9018 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9019 >  (eval $ac_try) 2>&5
9020 >  ac_status=$?
9021 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022 >  (exit $ac_status); }; }; then
9023 >  ac_header_compiler=yes
9024 > else
9025 >  echo "$as_me: failed program was:" >&5
9026 > sed 's/^/| /' conftest.$ac_ext >&5
9027 >
9028 > ac_header_compiler=no
9029 > fi
9030 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9031 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9032 > echo "${ECHO_T}$ac_header_compiler" >&6
9033 >
9034 > # Is the header present?
9035 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9036 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9037 > cat >conftest.$ac_ext <<_ACEOF
9038 > /* confdefs.h.  */
9039 > _ACEOF
9040 > cat confdefs.h >>conftest.$ac_ext
9041 > cat >>conftest.$ac_ext <<_ACEOF
9042 > /* end confdefs.h.  */
9043 > #include <$ac_header>
9044 > _ACEOF
9045 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9046 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9047 >  ac_status=$?
9048 >  grep -v '^ *+' conftest.er1 >conftest.err
9049 >  rm -f conftest.er1
9050 >  cat conftest.err >&5
9051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9052 >  (exit $ac_status); } >/dev/null; then
9053 >  if test -s conftest.err; then
9054 >    ac_cpp_err=$ac_c_preproc_warn_flag
9055 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9056 >  else
9057 >    ac_cpp_err=
9058 >  fi
9059 > else
9060 >  ac_cpp_err=yes
9061 > fi
9062 > if test -z "$ac_cpp_err"; then
9063 >  ac_header_preproc=yes
9064 > else
9065 >  echo "$as_me: failed program was:" >&5
9066 > sed 's/^/| /' conftest.$ac_ext >&5
9067 >
9068 >  ac_header_preproc=no
9069 > fi
9070 > rm -f conftest.err conftest.$ac_ext
9071 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9072 > echo "${ECHO_T}$ac_header_preproc" >&6
9073 >
9074 > # So?  What about this header?
9075 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9076 >  yes:no: )
9077 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9078 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9079 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9080 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9081 >    ac_header_preproc=yes
9082 >    ;;
9083 >  no:yes:* )
9084 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9085 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9086 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9087 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9088 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9089 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9090 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9091 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9092 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9093 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9094 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9095 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9096 >    (
9097 >      cat <<\_ASBOX
9098 > ## ------------------------------ ##
9099 > ## Report this to gezelter@nd.edu ##
9100 > ## ------------------------------ ##
9101 > _ASBOX
9102 >    ) |
9103 >      sed "s/^/$as_me: WARNING:     /" >&2
9104 >    ;;
9105 > esac
9106 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9107 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9108 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9109 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9110 > else
9111 >  eval "$as_ac_Header=\$ac_header_preproc"
9112 > fi
9113 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9114 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9115 >
9116 > fi
9117 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9118 >  cat >>confdefs.h <<_ACEOF
9119 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9120 > _ACEOF
9121 >
9122 > fi
9123 >
9124 > done
9125 >
9126 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
9127 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9128 > if test "${ac_cv_func_select_args+set}" = set; then
9129 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9130 > else
9131 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9132 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9133 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9134 >   cat >conftest.$ac_ext <<_ACEOF
9135 > /* confdefs.h.  */
9136 > _ACEOF
9137 > cat confdefs.h >>conftest.$ac_ext
9138 > cat >>conftest.$ac_ext <<_ACEOF
9139 > /* end confdefs.h.  */
9140 > $ac_includes_default
9141 > #if HAVE_SYS_SELECT_H
9142 > # include <sys/select.h>
9143 > #endif
9144 > #if HAVE_SYS_SOCKET_H
9145 > # include <sys/socket.h>
9146 > #endif
9147 >
9148 > #ifdef FC_DUMMY_MAIN
9149 > #ifndef FC_DUMMY_MAIN_EQ_F77
9150 > #  ifdef __cplusplus
9151 >     extern "C"
9152 > #  endif
9153 >   int FC_DUMMY_MAIN() { return 1; }
9154 > #endif
9155 > #endif
9156 > int
9157 > main ()
9158 > {
9159 > extern int select ($ac_arg1,
9160 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
9161 >                                            $ac_arg5);
9162 >  ;
9163 >  return 0;
9164 > }
9165 > _ACEOF
9166 > rm -f conftest.$ac_objext
9167 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9168 >  (eval $ac_compile) 2>conftest.er1
9169 >  ac_status=$?
9170 >  grep -v '^ *+' conftest.er1 >conftest.err
9171 >  rm -f conftest.er1
9172 >  cat conftest.err >&5
9173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174 >  (exit $ac_status); } &&
9175 >         { ac_try='test -z "$ac_c_werror_flag"
9176 >                         || test ! -s conftest.err'
9177 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9178 >  (eval $ac_try) 2>&5
9179 >  ac_status=$?
9180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181 >  (exit $ac_status); }; } &&
9182 >         { ac_try='test -s conftest.$ac_objext'
9183 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9184 >  (eval $ac_try) 2>&5
9185 >  ac_status=$?
9186 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9187 >  (exit $ac_status); }; }; then
9188 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9189 > else
9190 >  echo "$as_me: failed program was:" >&5
9191 > sed 's/^/| /' conftest.$ac_ext >&5
9192 >
9193 > fi
9194 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9195 >  done
9196 > done
9197 > done
9198 > # Provide a safe default value.
9199 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
9200 >
9201 > fi
9202 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9203 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
9204 > ac_save_IFS=$IFS; IFS=','
9205 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9206 > IFS=$ac_save_IFS
9207 > shift
9208 >
9209 > cat >>confdefs.h <<_ACEOF
9210 > #define SELECT_TYPE_ARG1 $1
9211 > _ACEOF
9212 >
9213 >
9214 > cat >>confdefs.h <<_ACEOF
9215 > #define SELECT_TYPE_ARG234 ($2)
9216 > _ACEOF
9217 >
9218 >
9219 > cat >>confdefs.h <<_ACEOF
9220 > #define SELECT_TYPE_ARG5 ($3)
9221 > _ACEOF
9222 >
9223 > rm -f conftest*
9224 >
9225 >
9226 > for ac_func in strftime
9227 > do
9228 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9229 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9230 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9231 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9232 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9233 > else
9234 >  cat >conftest.$ac_ext <<_ACEOF
9235 > /* confdefs.h.  */
9236 > _ACEOF
9237 > cat confdefs.h >>conftest.$ac_ext
9238 > cat >>conftest.$ac_ext <<_ACEOF
9239 > /* end confdefs.h.  */
9240 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9241 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9242 > #define $ac_func innocuous_$ac_func
9243 >
9244 > /* System header to define __stub macros and hopefully few prototypes,
9245 >    which can conflict with char $ac_func (); below.
9246 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9247 >    <limits.h> exists even on freestanding compilers.  */
9248 >
9249 > #ifdef __STDC__
9250 > # include <limits.h>
9251 > #else
9252 > # include <assert.h>
9253 > #endif
9254 >
9255 > #undef $ac_func
9256 >
9257 > /* Override any gcc2 internal prototype to avoid an error.  */
9258 > #ifdef __cplusplus
9259 > extern "C"
9260 > {
9261 > #endif
9262 > /* We use char because int might match the return type of a gcc2
9263 >   builtin and then its argument prototype would still apply.  */
9264 > char $ac_func ();
9265 > /* The GNU C library defines this for functions which it implements
9266 >    to always fail with ENOSYS.  Some functions are actually named
9267 >    something starting with __ and the normal name is an alias.  */
9268 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9269 > choke me
9270 > #else
9271 > char (*f) () = $ac_func;
9272 > #endif
9273 > #ifdef __cplusplus
9274 > }
9275 > #endif
9276 >
9277 > #ifdef FC_DUMMY_MAIN
9278 > #ifndef FC_DUMMY_MAIN_EQ_F77
9279 > #  ifdef __cplusplus
9280 >     extern "C"
9281 > #  endif
9282 >   int FC_DUMMY_MAIN() { return 1; }
9283 > #endif
9284 > #endif
9285 > int
9286 > main ()
9287 > {
9288 > return f != $ac_func;
9289 >  ;
9290 >  return 0;
9291 > }
9292 > _ACEOF
9293 > rm -f conftest.$ac_objext conftest$ac_exeext
9294 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9295 >  (eval $ac_link) 2>conftest.er1
9296 >  ac_status=$?
9297 >  grep -v '^ *+' conftest.er1 >conftest.err
9298 >  rm -f conftest.er1
9299 >  cat conftest.err >&5
9300 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301 >  (exit $ac_status); } &&
9302 >         { ac_try='test -z "$ac_c_werror_flag"
9303 >                         || test ! -s conftest.err'
9304 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305 >  (eval $ac_try) 2>&5
9306 >  ac_status=$?
9307 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308 >  (exit $ac_status); }; } &&
9309 >         { ac_try='test -s conftest$ac_exeext'
9310 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311 >  (eval $ac_try) 2>&5
9312 >  ac_status=$?
9313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314 >  (exit $ac_status); }; }; then
9315 >  eval "$as_ac_var=yes"
9316 > else
9317 >  echo "$as_me: failed program was:" >&5
9318 > sed 's/^/| /' conftest.$ac_ext >&5
9319 >
9320 > eval "$as_ac_var=no"
9321 > fi
9322 > rm -f conftest.err conftest.$ac_objext \
9323 >      conftest$ac_exeext conftest.$ac_ext
9324 > fi
9325 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9326 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9327 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9328 >  cat >>confdefs.h <<_ACEOF
9329 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9330 > _ACEOF
9331 >
9332 > else
9333 >  # strftime is in -lintl on SCO UNIX.
9334 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9335 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9336 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9337 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9338 > else
9339 >  ac_check_lib_save_LIBS=$LIBS
9340 > LIBS="-lintl  $LIBS"
9341 > cat >conftest.$ac_ext <<_ACEOF
9342 > /* confdefs.h.  */
9343 > _ACEOF
9344 > cat confdefs.h >>conftest.$ac_ext
9345 > cat >>conftest.$ac_ext <<_ACEOF
9346 > /* end confdefs.h.  */
9347 >
9348 > /* Override any gcc2 internal prototype to avoid an error.  */
9349 > #ifdef __cplusplus
9350 > extern "C"
9351 > #endif
9352 > /* We use char because int might match the return type of a gcc2
9353 >   builtin and then its argument prototype would still apply.  */
9354 > char strftime ();
9355 > #ifdef FC_DUMMY_MAIN
9356 > #ifndef FC_DUMMY_MAIN_EQ_F77
9357 > #  ifdef __cplusplus
9358 >     extern "C"
9359 > #  endif
9360 >   int FC_DUMMY_MAIN() { return 1; }
9361 > #endif
9362 > #endif
9363 > int
9364 > main ()
9365 > {
9366 > strftime ();
9367 >  ;
9368 >  return 0;
9369 > }
9370 > _ACEOF
9371 > rm -f conftest.$ac_objext conftest$ac_exeext
9372 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9373 >  (eval $ac_link) 2>conftest.er1
9374 >  ac_status=$?
9375 >  grep -v '^ *+' conftest.er1 >conftest.err
9376 >  rm -f conftest.er1
9377 >  cat conftest.err >&5
9378 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9379 >  (exit $ac_status); } &&
9380 >         { ac_try='test -z "$ac_c_werror_flag"
9381 >                         || test ! -s conftest.err'
9382 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9383 >  (eval $ac_try) 2>&5
9384 >  ac_status=$?
9385 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9386 >  (exit $ac_status); }; } &&
9387 >         { ac_try='test -s conftest$ac_exeext'
9388 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9389 >  (eval $ac_try) 2>&5
9390 >  ac_status=$?
9391 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392 >  (exit $ac_status); }; }; then
9393 >  ac_cv_lib_intl_strftime=yes
9394 > else
9395 >  echo "$as_me: failed program was:" >&5
9396 > sed 's/^/| /' conftest.$ac_ext >&5
9397 >
9398 > ac_cv_lib_intl_strftime=no
9399 > fi
9400 > rm -f conftest.err conftest.$ac_objext \
9401 >      conftest$ac_exeext conftest.$ac_ext
9402 > LIBS=$ac_check_lib_save_LIBS
9403 > fi
9404 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9405 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9406 > if test $ac_cv_lib_intl_strftime = yes; then
9407 >  cat >>confdefs.h <<\_ACEOF
9408 > #define HAVE_STRFTIME 1
9409 > _ACEOF
9410 >
9411 > LIBS="-lintl $LIBS"
9412 > fi
9413 >
9414 > fi
9415 > done
9416 >
9417 > echo "$as_me:$LINENO: checking for working strtod" >&5
9418 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9419 > if test "${ac_cv_func_strtod+set}" = set; then
9420 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9421 > else
9422 >  if test "$cross_compiling" = yes; then
9423 >  ac_cv_func_strtod=no
9424 > else
9425 >  cat >conftest.$ac_ext <<_ACEOF
9426 > /* confdefs.h.  */
9427 > _ACEOF
9428 > cat confdefs.h >>conftest.$ac_ext
9429 > cat >>conftest.$ac_ext <<_ACEOF
9430 > /* end confdefs.h.  */
9431 >
9432 > double strtod ();
9433 > int
9434 > main()
9435 > {
9436 >  {
9437 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9438 >    char *string = " +69";
9439 >    char *term;
9440 >    double value;
9441 >    value = strtod (string, &term);
9442 >    if (value != 69 || term != (string + 4))
9443 >      exit (1);
9444 >  }
9445 >
9446 >  {
9447 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9448 >       terminating character under some conditions.  */
9449 >    char *string = "NaN";
9450 >    char *term;
9451 >    strtod (string, &term);
9452 >    if (term != string && *(term - 1) == 0)
9453 >      exit (1);
9454 >  }
9455 >  exit (0);
9456 > }
9457 >
9458 > _ACEOF
9459 > rm -f conftest$ac_exeext
9460 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9461 >  (eval $ac_link) 2>&5
9462 >  ac_status=$?
9463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9465 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9466 >  (eval $ac_try) 2>&5
9467 >  ac_status=$?
9468 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469 >  (exit $ac_status); }; }; then
9470 >  ac_cv_func_strtod=yes
9471 > else
9472 >  echo "$as_me: program exited with status $ac_status" >&5
9473 > echo "$as_me: failed program was:" >&5
9474 > sed 's/^/| /' conftest.$ac_ext >&5
9475 >
9476 > ( exit $ac_status )
9477 > ac_cv_func_strtod=no
9478 > fi
9479 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9480 > fi
9481 > fi
9482 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9483 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9484 > if test $ac_cv_func_strtod = no; then
9485 >  case $LIBOBJS in
9486 >    "strtod.$ac_objext"   | \
9487 >  *" strtod.$ac_objext"   | \
9488 >    "strtod.$ac_objext "* | \
9489 >  *" strtod.$ac_objext "* ) ;;
9490 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9491 > esac
9492 >
9493 > echo "$as_me:$LINENO: checking for pow" >&5
9494 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495 > if test "${ac_cv_func_pow+set}" = set; then
9496 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9497 > else
9498 >  cat >conftest.$ac_ext <<_ACEOF
9499 > /* confdefs.h.  */
9500 > _ACEOF
9501 > cat confdefs.h >>conftest.$ac_ext
9502 > cat >>conftest.$ac_ext <<_ACEOF
9503 > /* end confdefs.h.  */
9504 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506 > #define pow innocuous_pow
9507 >
9508 > /* System header to define __stub macros and hopefully few prototypes,
9509 >    which can conflict with char pow (); below.
9510 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511 >    <limits.h> exists even on freestanding compilers.  */
9512 >
9513 > #ifdef __STDC__
9514 > # include <limits.h>
9515 > #else
9516 > # include <assert.h>
9517 > #endif
9518 >
9519 > #undef pow
9520 >
9521 > /* Override any gcc2 internal prototype to avoid an error.  */
9522 > #ifdef __cplusplus
9523 > extern "C"
9524 > {
9525 > #endif
9526 > /* We use char because int might match the return type of a gcc2
9527 >   builtin and then its argument prototype would still apply.  */
9528 > char pow ();
9529 > /* The GNU C library defines this for functions which it implements
9530 >    to always fail with ENOSYS.  Some functions are actually named
9531 >    something starting with __ and the normal name is an alias.  */
9532 > #if defined (__stub_pow) || defined (__stub___pow)
9533 > choke me
9534 > #else
9535 > char (*f) () = pow;
9536 > #endif
9537 > #ifdef __cplusplus
9538 > }
9539 > #endif
9540 >
9541 > #ifdef FC_DUMMY_MAIN
9542 > #ifndef FC_DUMMY_MAIN_EQ_F77
9543 > #  ifdef __cplusplus
9544 >     extern "C"
9545 > #  endif
9546 >   int FC_DUMMY_MAIN() { return 1; }
9547 > #endif
9548 > #endif
9549 > int
9550 > main ()
9551 > {
9552 > return f != pow;
9553 >  ;
9554 >  return 0;
9555 > }
9556 > _ACEOF
9557 > rm -f conftest.$ac_objext conftest$ac_exeext
9558 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9559 >  (eval $ac_link) 2>conftest.er1
9560 >  ac_status=$?
9561 >  grep -v '^ *+' conftest.er1 >conftest.err
9562 >  rm -f conftest.er1
9563 >  cat conftest.err >&5
9564 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565 >  (exit $ac_status); } &&
9566 >         { ac_try='test -z "$ac_c_werror_flag"
9567 >                         || test ! -s conftest.err'
9568 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569 >  (eval $ac_try) 2>&5
9570 >  ac_status=$?
9571 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9572 >  (exit $ac_status); }; } &&
9573 >         { ac_try='test -s conftest$ac_exeext'
9574 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9575 >  (eval $ac_try) 2>&5
9576 >  ac_status=$?
9577 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578 >  (exit $ac_status); }; }; then
9579 >  ac_cv_func_pow=yes
9580 > else
9581 >  echo "$as_me: failed program was:" >&5
9582 > sed 's/^/| /' conftest.$ac_ext >&5
9583 >
9584 > ac_cv_func_pow=no
9585 > fi
9586 > rm -f conftest.err conftest.$ac_objext \
9587 >      conftest$ac_exeext conftest.$ac_ext
9588 > fi
9589 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9591 >
9592 > if test $ac_cv_func_pow = no; then
9593 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595 > if test "${ac_cv_lib_m_pow+set}" = set; then
9596 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9597 > else
9598 >  ac_check_lib_save_LIBS=$LIBS
9599 > LIBS="-lm  $LIBS"
9600 > cat >conftest.$ac_ext <<_ACEOF
9601 > /* confdefs.h.  */
9602 > _ACEOF
9603 > cat confdefs.h >>conftest.$ac_ext
9604 > cat >>conftest.$ac_ext <<_ACEOF
9605 > /* end confdefs.h.  */
9606 >
9607 > /* Override any gcc2 internal prototype to avoid an error.  */
9608 > #ifdef __cplusplus
9609 > extern "C"
9610 > #endif
9611 > /* We use char because int might match the return type of a gcc2
9612 >   builtin and then its argument prototype would still apply.  */
9613 > char pow ();
9614 > #ifdef FC_DUMMY_MAIN
9615 > #ifndef FC_DUMMY_MAIN_EQ_F77
9616 > #  ifdef __cplusplus
9617 >     extern "C"
9618 > #  endif
9619 >   int FC_DUMMY_MAIN() { return 1; }
9620 > #endif
9621 > #endif
9622 > int
9623 > main ()
9624 > {
9625 > pow ();
9626 >  ;
9627 >  return 0;
9628 > }
9629 > _ACEOF
9630 > rm -f conftest.$ac_objext conftest$ac_exeext
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632 >  (eval $ac_link) 2>conftest.er1
9633 >  ac_status=$?
9634 >  grep -v '^ *+' conftest.er1 >conftest.err
9635 >  rm -f conftest.er1
9636 >  cat conftest.err >&5
9637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638 >  (exit $ac_status); } &&
9639 >         { ac_try='test -z "$ac_c_werror_flag"
9640 >                         || test ! -s conftest.err'
9641 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642 >  (eval $ac_try) 2>&5
9643 >  ac_status=$?
9644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645 >  (exit $ac_status); }; } &&
9646 >         { ac_try='test -s conftest$ac_exeext'
9647 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648 >  (eval $ac_try) 2>&5
9649 >  ac_status=$?
9650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651 >  (exit $ac_status); }; }; then
9652 >  ac_cv_lib_m_pow=yes
9653 > else
9654 >  echo "$as_me: failed program was:" >&5
9655 > sed 's/^/| /' conftest.$ac_ext >&5
9656 >
9657 > ac_cv_lib_m_pow=no
9658 > fi
9659 > rm -f conftest.err conftest.$ac_objext \
9660 >      conftest$ac_exeext conftest.$ac_ext
9661 > LIBS=$ac_check_lib_save_LIBS
9662 > fi
9663 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665 > if test $ac_cv_lib_m_pow = yes; then
9666 >  POW_LIB=-lm
9667 > else
9668 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670 > fi
9671 >
9672 > fi
9673 >
9674 > fi
9675 >
9676 >
9677 >
9678 >
9679 >
9680 >
9681 >
9682 >
9683 >
9684 >
9685 >
9686 >
9687 >
9688 >
9689 >
9690 >
9691 >
9692 >
9693 >
9694 >
9695 >
9696 >
9697 >
9698 >
9699 >
9700 >
9701 >
9702 >
9703 > 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
9704 > do
9705 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9707 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9709 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9710 > else
9711 >  cat >conftest.$ac_ext <<_ACEOF
9712 > /* confdefs.h.  */
9713 > _ACEOF
9714 > cat confdefs.h >>conftest.$ac_ext
9715 > cat >>conftest.$ac_ext <<_ACEOF
9716 > /* end confdefs.h.  */
9717 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719 > #define $ac_func innocuous_$ac_func
9720 >
9721 > /* System header to define __stub macros and hopefully few prototypes,
9722 >    which can conflict with char $ac_func (); below.
9723 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724 >    <limits.h> exists even on freestanding compilers.  */
9725 >
9726 > #ifdef __STDC__
9727 > # include <limits.h>
9728 > #else
9729 > # include <assert.h>
9730 > #endif
9731 >
9732 > #undef $ac_func
9733 >
9734 > /* Override any gcc2 internal prototype to avoid an error.  */
9735 > #ifdef __cplusplus
9736 > extern "C"
9737 > {
9738 > #endif
9739 > /* We use char because int might match the return type of a gcc2
9740 >   builtin and then its argument prototype would still apply.  */
9741 > char $ac_func ();
9742 > /* The GNU C library defines this for functions which it implements
9743 >    to always fail with ENOSYS.  Some functions are actually named
9744 >    something starting with __ and the normal name is an alias.  */
9745 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746 > choke me
9747 > #else
9748 > char (*f) () = $ac_func;
9749 > #endif
9750 > #ifdef __cplusplus
9751 > }
9752 > #endif
9753 >
9754 > #ifdef FC_DUMMY_MAIN
9755 > #ifndef FC_DUMMY_MAIN_EQ_F77
9756 > #  ifdef __cplusplus
9757 >     extern "C"
9758 > #  endif
9759 >   int FC_DUMMY_MAIN() { return 1; }
9760 > #endif
9761 > #endif
9762 > int
9763 > main ()
9764 > {
9765 > return f != $ac_func;
9766 >  ;
9767 >  return 0;
9768 > }
9769 > _ACEOF
9770 > rm -f conftest.$ac_objext conftest$ac_exeext
9771 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772 >  (eval $ac_link) 2>conftest.er1
9773 >  ac_status=$?
9774 >  grep -v '^ *+' conftest.er1 >conftest.err
9775 >  rm -f conftest.er1
9776 >  cat conftest.err >&5
9777 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9778 >  (exit $ac_status); } &&
9779 >         { ac_try='test -z "$ac_c_werror_flag"
9780 >                         || test ! -s conftest.err'
9781 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9782 >  (eval $ac_try) 2>&5
9783 >  ac_status=$?
9784 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785 >  (exit $ac_status); }; } &&
9786 >         { ac_try='test -s conftest$ac_exeext'
9787 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788 >  (eval $ac_try) 2>&5
9789 >  ac_status=$?
9790 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791 >  (exit $ac_status); }; }; then
9792 >  eval "$as_ac_var=yes"
9793 > else
9794 >  echo "$as_me: failed program was:" >&5
9795 > sed 's/^/| /' conftest.$ac_ext >&5
9796 >
9797 > eval "$as_ac_var=no"
9798 > fi
9799 > rm -f conftest.err conftest.$ac_objext \
9800 >      conftest$ac_exeext conftest.$ac_ext
9801 > fi
9802 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9805 >  cat >>confdefs.h <<_ACEOF
9806 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807 > _ACEOF
9808 >
9809 > fi
9810 > done
9811 >
9812 >
9813 > # special check for _system_configuration because AIX <4.3.2 do not
9814 > # contain the `physmem' member.
9815 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817 > cat >conftest.$ac_ext <<_ACEOF
9818 > /* confdefs.h.  */
9819 > _ACEOF
9820 > cat confdefs.h >>conftest.$ac_ext
9821 > cat >>conftest.$ac_ext <<_ACEOF
9822 > /* end confdefs.h.  */
9823 > #include <sys/systemcfg.h>
9824 > #ifdef FC_DUMMY_MAIN
9825 > #ifndef FC_DUMMY_MAIN_EQ_F77
9826 > #  ifdef __cplusplus
9827 >     extern "C"
9828 > #  endif
9829 >   int FC_DUMMY_MAIN() { return 1; }
9830 > #endif
9831 > #endif
9832 > int
9833 > main ()
9834 > {
9835 > double x = _system_configuration.physmem;
9836 >  ;
9837 >  return 0;
9838 > }
9839 > _ACEOF
9840 > rm -f conftest.$ac_objext
9841 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842 >  (eval $ac_compile) 2>conftest.er1
9843 >  ac_status=$?
9844 >  grep -v '^ *+' conftest.er1 >conftest.err
9845 >  rm -f conftest.er1
9846 >  cat conftest.err >&5
9847 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848 >  (exit $ac_status); } &&
9849 >         { ac_try='test -z "$ac_c_werror_flag"
9850 >                         || test ! -s conftest.err'
9851 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852 >  (eval $ac_try) 2>&5
9853 >  ac_status=$?
9854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855 >  (exit $ac_status); }; } &&
9856 >         { ac_try='test -s conftest.$ac_objext'
9857 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858 >  (eval $ac_try) 2>&5
9859 >  ac_status=$?
9860 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861 >  (exit $ac_status); }; }; then
9862 >  echo "$as_me:$LINENO: result: yes" >&5
9863 > echo "${ECHO_T}yes" >&6
9864 >
9865 > cat >>confdefs.h <<\_ACEOF
9866 > #define HAVE__SYSTEM_CONFIGURATION 1
9867 > _ACEOF
9868 >
9869 > else
9870 >  echo "$as_me: failed program was:" >&5
9871 > sed 's/^/| /' conftest.$ac_ext >&5
9872 >
9873 > echo "$as_me:$LINENO: result: no" >&5
9874 > echo "${ECHO_T}no" >&6
9875 > fi
9876 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877 >
9878 >  # clean out junk possibly left behind by a previous configuration
9879 >  rm -f src/getopt.h
9880 >  # Check for getopt_long support
9881 >
9882 > for ac_header in getopt.h
9883 > do
9884 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9887 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9890 > fi
9891 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893 > else
9894 >  # Is the header compilable?
9895 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897 > cat >conftest.$ac_ext <<_ACEOF
9898 > /* confdefs.h.  */
9899 > _ACEOF
9900 > cat confdefs.h >>conftest.$ac_ext
9901 > cat >>conftest.$ac_ext <<_ACEOF
9902 > /* end confdefs.h.  */
9903 > $ac_includes_default
9904 > #include <$ac_header>
9905 > _ACEOF
9906 > rm -f conftest.$ac_objext
9907 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9908 >  (eval $ac_compile) 2>conftest.er1
9909 >  ac_status=$?
9910 >  grep -v '^ *+' conftest.er1 >conftest.err
9911 >  rm -f conftest.er1
9912 >  cat conftest.err >&5
9913 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914 >  (exit $ac_status); } &&
9915 >         { ac_try='test -z "$ac_c_werror_flag"
9916 >                         || test ! -s conftest.err'
9917 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9918 >  (eval $ac_try) 2>&5
9919 >  ac_status=$?
9920 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921 >  (exit $ac_status); }; } &&
9922 >         { ac_try='test -s conftest.$ac_objext'
9923 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924 >  (eval $ac_try) 2>&5
9925 >  ac_status=$?
9926 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927 >  (exit $ac_status); }; }; then
9928 >  ac_header_compiler=yes
9929 > else
9930 >  echo "$as_me: failed program was:" >&5
9931 > sed 's/^/| /' conftest.$ac_ext >&5
9932 >
9933 > ac_header_compiler=no
9934 > fi
9935 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9936 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937 > echo "${ECHO_T}$ac_header_compiler" >&6
9938 >
9939 > # Is the header present?
9940 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942 > cat >conftest.$ac_ext <<_ACEOF
9943 > /* confdefs.h.  */
9944 > _ACEOF
9945 > cat confdefs.h >>conftest.$ac_ext
9946 > cat >>conftest.$ac_ext <<_ACEOF
9947 > /* end confdefs.h.  */
9948 > #include <$ac_header>
9949 > _ACEOF
9950 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9952 >  ac_status=$?
9953 >  grep -v '^ *+' conftest.er1 >conftest.err
9954 >  rm -f conftest.er1
9955 >  cat conftest.err >&5
9956 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9957 >  (exit $ac_status); } >/dev/null; then
9958 >  if test -s conftest.err; then
9959 >    ac_cpp_err=$ac_c_preproc_warn_flag
9960 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9961 >  else
9962 >    ac_cpp_err=
9963 >  fi
9964 > else
9965 >  ac_cpp_err=yes
9966 > fi
9967 > if test -z "$ac_cpp_err"; then
9968 >  ac_header_preproc=yes
9969 > else
9970 >  echo "$as_me: failed program was:" >&5
9971 > sed 's/^/| /' conftest.$ac_ext >&5
9972 >
9973 >  ac_header_preproc=no
9974 > fi
9975 > rm -f conftest.err conftest.$ac_ext
9976 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9977 > echo "${ECHO_T}$ac_header_preproc" >&6
9978 >
9979 > # So?  What about this header?
9980 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981 >  yes:no: )
9982 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986 >    ac_header_preproc=yes
9987 >    ;;
9988 >  no:yes:* )
9989 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001 >    (
10002 >      cat <<\_ASBOX
10003 > ## ------------------------------ ##
10004 > ## Report this to gezelter@nd.edu ##
10005 > ## ------------------------------ ##
10006 > _ASBOX
10007 >    ) |
10008 >      sed "s/^/$as_me: WARNING:     /" >&2
10009 >    ;;
10010 > esac
10011 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10012 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10015 > else
10016 >  eval "$as_ac_Header=\$ac_header_preproc"
10017 > fi
10018 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020 >
10021 > fi
10022 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023 >  cat >>confdefs.h <<_ACEOF
10024 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025 > _ACEOF
10026 >
10027 > fi
10028 >
10029 > done
10030 >
10031 >
10032 > for ac_func in getopt_long
10033 > do
10034 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10036 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10038 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10039 > else
10040 >  cat >conftest.$ac_ext <<_ACEOF
10041 > /* confdefs.h.  */
10042 > _ACEOF
10043 > cat confdefs.h >>conftest.$ac_ext
10044 > cat >>conftest.$ac_ext <<_ACEOF
10045 > /* end confdefs.h.  */
10046 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048 > #define $ac_func innocuous_$ac_func
10049 >
10050 > /* System header to define __stub macros and hopefully few prototypes,
10051 >    which can conflict with char $ac_func (); below.
10052 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053 >    <limits.h> exists even on freestanding compilers.  */
10054 >
10055 > #ifdef __STDC__
10056 > # include <limits.h>
10057 > #else
10058 > # include <assert.h>
10059 > #endif
10060 >
10061 > #undef $ac_func
10062 >
10063 > /* Override any gcc2 internal prototype to avoid an error.  */
10064 > #ifdef __cplusplus
10065 > extern "C"
10066 > {
10067 > #endif
10068 > /* We use char because int might match the return type of a gcc2
10069 >   builtin and then its argument prototype would still apply.  */
10070 > char $ac_func ();
10071 > /* The GNU C library defines this for functions which it implements
10072 >    to always fail with ENOSYS.  Some functions are actually named
10073 >    something starting with __ and the normal name is an alias.  */
10074 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075 > choke me
10076 > #else
10077 > char (*f) () = $ac_func;
10078 > #endif
10079 > #ifdef __cplusplus
10080 > }
10081 > #endif
10082 >
10083 > #ifdef FC_DUMMY_MAIN
10084 > #ifndef FC_DUMMY_MAIN_EQ_F77
10085 > #  ifdef __cplusplus
10086 >     extern "C"
10087 > #  endif
10088 >   int FC_DUMMY_MAIN() { return 1; }
10089 > #endif
10090 > #endif
10091 > int
10092 > main ()
10093 > {
10094 > return f != $ac_func;
10095 >  ;
10096 >  return 0;
10097 > }
10098 > _ACEOF
10099 > rm -f conftest.$ac_objext conftest$ac_exeext
10100 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10101 >  (eval $ac_link) 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); } &&
10108 >         { ac_try='test -z "$ac_c_werror_flag"
10109 >                         || test ! -s conftest.err'
10110 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10111 >  (eval $ac_try) 2>&5
10112 >  ac_status=$?
10113 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10114 >  (exit $ac_status); }; } &&
10115 >         { ac_try='test -s conftest$ac_exeext'
10116 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10117 >  (eval $ac_try) 2>&5
10118 >  ac_status=$?
10119 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120 >  (exit $ac_status); }; }; then
10121 >  eval "$as_ac_var=yes"
10122 > else
10123 >  echo "$as_me: failed program was:" >&5
10124 > sed 's/^/| /' conftest.$ac_ext >&5
10125 >
10126 > eval "$as_ac_var=no"
10127 > fi
10128 > rm -f conftest.err conftest.$ac_objext \
10129 >      conftest$ac_exeext conftest.$ac_ext
10130 > fi
10131 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10132 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10133 > if test `eval echo '${'$as_ac_var'}'` = yes; then
10134 >  cat >>confdefs.h <<_ACEOF
10135 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10136 > _ACEOF
10137 >
10138 > else
10139 >  # FreeBSD has a gnugetopt library for this
10140 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10141 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10142 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10143 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10144 > else
10145 >  ac_check_lib_save_LIBS=$LIBS
10146 > LIBS="-lgnugetopt  $LIBS"
10147 > cat >conftest.$ac_ext <<_ACEOF
10148 > /* confdefs.h.  */
10149 > _ACEOF
10150 > cat confdefs.h >>conftest.$ac_ext
10151 > cat >>conftest.$ac_ext <<_ACEOF
10152 > /* end confdefs.h.  */
10153 >
10154 > /* Override any gcc2 internal prototype to avoid an error.  */
10155 > #ifdef __cplusplus
10156 > extern "C"
10157 > #endif
10158 > /* We use char because int might match the return type of a gcc2
10159 >   builtin and then its argument prototype would still apply.  */
10160 > char getopt_long ();
10161 > #ifdef FC_DUMMY_MAIN
10162 > #ifndef FC_DUMMY_MAIN_EQ_F77
10163 > #  ifdef __cplusplus
10164 >     extern "C"
10165 > #  endif
10166 >   int FC_DUMMY_MAIN() { return 1; }
10167 > #endif
10168 > #endif
10169 > int
10170 > main ()
10171 > {
10172 > getopt_long ();
10173 >  ;
10174 >  return 0;
10175 > }
10176 > _ACEOF
10177 > rm -f conftest.$ac_objext conftest$ac_exeext
10178 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10179 >  (eval $ac_link) 2>conftest.er1
10180 >  ac_status=$?
10181 >  grep -v '^ *+' conftest.er1 >conftest.err
10182 >  rm -f conftest.er1
10183 >  cat conftest.err >&5
10184 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10185 >  (exit $ac_status); } &&
10186 >         { ac_try='test -z "$ac_c_werror_flag"
10187 >                         || test ! -s conftest.err'
10188 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10189 >  (eval $ac_try) 2>&5
10190 >  ac_status=$?
10191 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192 >  (exit $ac_status); }; } &&
10193 >         { ac_try='test -s conftest$ac_exeext'
10194 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10195 >  (eval $ac_try) 2>&5
10196 >  ac_status=$?
10197 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198 >  (exit $ac_status); }; }; then
10199 >  ac_cv_lib_gnugetopt_getopt_long=yes
10200 > else
10201 >  echo "$as_me: failed program was:" >&5
10202 > sed 's/^/| /' conftest.$ac_ext >&5
10203 >
10204 > ac_cv_lib_gnugetopt_getopt_long=no
10205 > fi
10206 > rm -f conftest.err conftest.$ac_objext \
10207 >      conftest$ac_exeext conftest.$ac_ext
10208 > LIBS=$ac_check_lib_save_LIBS
10209 > fi
10210 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10211 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10212 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10213 >  cat >>confdefs.h <<\_ACEOF
10214 > #define HAVE_GETOPT_LONG 1
10215 > _ACEOF
10216 >
10217 > else
10218 >  # use the GNU replacement
10219 >      case $LIBOBJS in
10220 >    "getopt.$ac_objext"   | \
10221 >  *" getopt.$ac_objext"   | \
10222 >    "getopt.$ac_objext "* | \
10223 >  *" getopt.$ac_objext "* ) ;;
10224 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10225 > esac
10226 >
10227 >      case $LIBOBJS in
10228 >    "getopt1.$ac_objext"   | \
10229 >  *" getopt1.$ac_objext"   | \
10230 >    "getopt1.$ac_objext "* | \
10231 >  *" getopt1.$ac_objext "* ) ;;
10232 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10233 > esac
10234 >
10235 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10236 >
10237 > fi
10238 >
10239 > fi
10240 > done
10241 >
10242 >
10243 > ac_ext=cc
10244 > ac_cpp='$CXXCPP $CPPFLAGS'
10245 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10246 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10247 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10248 >
10249 >
10250 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10251 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10252 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10253 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10254 > else
10255 >
10256 >
10257 > ac_ext=cc
10258 > ac_cpp='$CXXCPP $CPPFLAGS'
10259 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262 >
10263 > cat >conftest.$ac_ext <<_ACEOF
10264 > /* confdefs.h.  */
10265 > _ACEOF
10266 > cat confdefs.h >>conftest.$ac_ext
10267 > cat >>conftest.$ac_ext <<_ACEOF
10268 > /* end confdefs.h.  */
10269 > namespace Outer { namespace Inner { int i = 0; }}
10270 > #ifdef FC_DUMMY_MAIN
10271 > #ifndef FC_DUMMY_MAIN_EQ_F77
10272 > #  ifdef __cplusplus
10273 >     extern "C"
10274 > #  endif
10275 >   int FC_DUMMY_MAIN() { return 1; }
10276 > #endif
10277 > #endif
10278 > int
10279 > main ()
10280 > {
10281 > using namespace Outer::Inner; return i;
10282 >  ;
10283 >  return 0;
10284 > }
10285 > _ACEOF
10286 > rm -f conftest.$ac_objext
10287 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10288 >  (eval $ac_compile) 2>conftest.er1
10289 >  ac_status=$?
10290 >  grep -v '^ *+' conftest.er1 >conftest.err
10291 >  rm -f conftest.er1
10292 >  cat conftest.err >&5
10293 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10294 >  (exit $ac_status); } &&
10295 >         { ac_try='test -z "$ac_cxx_werror_flag"
10296 >                         || test ! -s conftest.err'
10297 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10298 >  (eval $ac_try) 2>&5
10299 >  ac_status=$?
10300 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10301 >  (exit $ac_status); }; } &&
10302 >         { ac_try='test -s conftest.$ac_objext'
10303 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10304 >  (eval $ac_try) 2>&5
10305 >  ac_status=$?
10306 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307 >  (exit $ac_status); }; }; then
10308 >  ac_cv_cxx_namespaces=yes
10309 > else
10310 >  echo "$as_me: failed program was:" >&5
10311 > sed 's/^/| /' conftest.$ac_ext >&5
10312 >
10313 > ac_cv_cxx_namespaces=no
10314 > fi
10315 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316 > ac_ext=cc
10317 > ac_cpp='$CXXCPP $CPPFLAGS'
10318 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10319 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10320 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10321 >
10322 >
10323 > fi
10324 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326 > if test "$ac_cv_cxx_namespaces" = yes; then
10327 >
10328 > cat >>confdefs.h <<\_ACEOF
10329 > #define HAVE_NAMESPACES
10330 > _ACEOF
10331 >
10332 > fi
10333 >
10334 > ac_ext=cc
10335 > ac_cpp='$CXXCPP $CPPFLAGS'
10336 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341 > if test -z "$CXXCPP"; then
10342 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10343 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10344 > else
10345 >      # Double quotes because CXXCPP needs to be expanded
10346 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10347 >    do
10348 >      ac_preproc_ok=false
10349 > for ac_cxx_preproc_warn_flag in '' yes
10350 > do
10351 >  # Use a header file that comes with gcc, so configuring glibc
10352 >  # with a fresh cross-compiler works.
10353 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10354 >  # <limits.h> exists even on freestanding compilers.
10355 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10356 >  # not just through cpp. "Syntax error" is here to catch this case.
10357 >  cat >conftest.$ac_ext <<_ACEOF
10358 > /* confdefs.h.  */
10359 > _ACEOF
10360 > cat confdefs.h >>conftest.$ac_ext
10361 > cat >>conftest.$ac_ext <<_ACEOF
10362 > /* end confdefs.h.  */
10363 > #ifdef __STDC__
10364 > # include <limits.h>
10365 > #else
10366 > # include <assert.h>
10367 > #endif
10368 >                     Syntax error
10369 > _ACEOF
10370 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10371 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10372 >  ac_status=$?
10373 >  grep -v '^ *+' conftest.er1 >conftest.err
10374 >  rm -f conftest.er1
10375 >  cat conftest.err >&5
10376 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377 >  (exit $ac_status); } >/dev/null; then
10378 >  if test -s conftest.err; then
10379 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10380 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10381 >  else
10382 >    ac_cpp_err=
10383 >  fi
10384 > else
10385 >  ac_cpp_err=yes
10386 > fi
10387 > if test -z "$ac_cpp_err"; then
10388 >  :
10389 > else
10390 >  echo "$as_me: failed program was:" >&5
10391 > sed 's/^/| /' conftest.$ac_ext >&5
10392 >
10393 >  # Broken: fails on valid input.
10394 > continue
10395 > fi
10396 > rm -f conftest.err conftest.$ac_ext
10397 >
10398 >  # OK, works on sane cases.  Now check whether non-existent headers
10399 >  # can be detected and how.
10400 >  cat >conftest.$ac_ext <<_ACEOF
10401 > /* confdefs.h.  */
10402 > _ACEOF
10403 > cat confdefs.h >>conftest.$ac_ext
10404 > cat >>conftest.$ac_ext <<_ACEOF
10405 > /* end confdefs.h.  */
10406 > #include <ac_nonexistent.h>
10407 > _ACEOF
10408 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10409 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10410 >  ac_status=$?
10411 >  grep -v '^ *+' conftest.er1 >conftest.err
10412 >  rm -f conftest.er1
10413 >  cat conftest.err >&5
10414 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10415 >  (exit $ac_status); } >/dev/null; then
10416 >  if test -s conftest.err; then
10417 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10418 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10419 >  else
10420 >    ac_cpp_err=
10421 >  fi
10422 > else
10423 >  ac_cpp_err=yes
10424 > fi
10425 > if test -z "$ac_cpp_err"; then
10426 >  # Broken: success on invalid input.
10427 > continue
10428 > else
10429 >  echo "$as_me: failed program was:" >&5
10430 > sed 's/^/| /' conftest.$ac_ext >&5
10431 >
10432 >  # Passes both tests.
10433 > ac_preproc_ok=:
10434 > break
10435 > fi
10436 > rm -f conftest.err conftest.$ac_ext
10437 >
10438 > done
10439 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10440 > rm -f conftest.err conftest.$ac_ext
10441 > if $ac_preproc_ok; then
10442 >  break
10443 > fi
10444 >
10445 >    done
10446 >    ac_cv_prog_CXXCPP=$CXXCPP
10447 >
10448 > fi
10449 >  CXXCPP=$ac_cv_prog_CXXCPP
10450 > else
10451 >  ac_cv_prog_CXXCPP=$CXXCPP
10452 > fi
10453 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10454 > echo "${ECHO_T}$CXXCPP" >&6
10455 > ac_preproc_ok=false
10456 > for ac_cxx_preproc_warn_flag in '' yes
10457 > do
10458 >  # Use a header file that comes with gcc, so configuring glibc
10459 >  # with a fresh cross-compiler works.
10460 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10461 >  # <limits.h> exists even on freestanding compilers.
10462 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10463 >  # not just through cpp. "Syntax error" is here to catch this case.
10464 >  cat >conftest.$ac_ext <<_ACEOF
10465 > /* confdefs.h.  */
10466 > _ACEOF
10467 > cat confdefs.h >>conftest.$ac_ext
10468 > cat >>conftest.$ac_ext <<_ACEOF
10469 > /* end confdefs.h.  */
10470 > #ifdef __STDC__
10471 > # include <limits.h>
10472 > #else
10473 > # include <assert.h>
10474 > #endif
10475 >                     Syntax error
10476 > _ACEOF
10477 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10478 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10479 >  ac_status=$?
10480 >  grep -v '^ *+' conftest.er1 >conftest.err
10481 >  rm -f conftest.er1
10482 >  cat conftest.err >&5
10483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10484 >  (exit $ac_status); } >/dev/null; then
10485 >  if test -s conftest.err; then
10486 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10487 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10488 >  else
10489 >    ac_cpp_err=
10490 >  fi
10491 > else
10492 >  ac_cpp_err=yes
10493 > fi
10494 > if test -z "$ac_cpp_err"; then
10495 >  :
10496 > else
10497 >  echo "$as_me: failed program was:" >&5
10498 > sed 's/^/| /' conftest.$ac_ext >&5
10499 >
10500 >  # Broken: fails on valid input.
10501 > continue
10502 > fi
10503 > rm -f conftest.err conftest.$ac_ext
10504 >
10505 >  # OK, works on sane cases.  Now check whether non-existent headers
10506 >  # can be detected and how.
10507 >  cat >conftest.$ac_ext <<_ACEOF
10508 > /* confdefs.h.  */
10509 > _ACEOF
10510 > cat confdefs.h >>conftest.$ac_ext
10511 > cat >>conftest.$ac_ext <<_ACEOF
10512 > /* end confdefs.h.  */
10513 > #include <ac_nonexistent.h>
10514 > _ACEOF
10515 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10516 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10517 >  ac_status=$?
10518 >  grep -v '^ *+' conftest.er1 >conftest.err
10519 >  rm -f conftest.er1
10520 >  cat conftest.err >&5
10521 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10522 >  (exit $ac_status); } >/dev/null; then
10523 >  if test -s conftest.err; then
10524 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10525 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10526 >  else
10527 >    ac_cpp_err=
10528 >  fi
10529 > else
10530 >  ac_cpp_err=yes
10531 > fi
10532 > if test -z "$ac_cpp_err"; then
10533 >  # Broken: success on invalid input.
10534 > continue
10535 > else
10536 >  echo "$as_me: failed program was:" >&5
10537 > sed 's/^/| /' conftest.$ac_ext >&5
10538 >
10539 >  # Passes both tests.
10540 > ac_preproc_ok=:
10541 > break
10542 > fi
10543 > rm -f conftest.err conftest.$ac_ext
10544 >
10545 > done
10546 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10547 > rm -f conftest.err conftest.$ac_ext
10548 > if $ac_preproc_ok; then
10549 >  :
10550 > else
10551 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10552 > See \`config.log' for more details." >&5
10553 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10554 > See \`config.log' for more details." >&2;}
10555 >   { (exit 1); exit 1; }; }
10556   fi
10557 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10558 <        ac_ext=cc
10557 >
10558 > ac_ext=cc
10559   ac_cpp='$CXXCPP $CPPFLAGS'
10560   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10561   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10562   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10563  
6360 –      fi
10564  
10565 < fi
10566 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
10567 < echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
6365 <  if test "$ac_cv_cxx_have_std_stl" = yes; then
6366 <
6367 < cat >>confdefs.h <<\_ACEOF
6368 < #define HAVE_STD_STL 1
6369 < _ACEOF
6370 <
6371 <  fi
6372 <
6373 <
6374 <
6375 <  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
10565 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10566 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10567 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10568    echo $ECHO_N "(cached) $ECHO_C" >&6
10569   else
10570  
6381 –    ac_cv_cxx_have_fstream_attach=no
10571  
10572  
10573 <    ac_ext=cc
10573 > ac_ext=cc
10574   ac_cpp='$CXXCPP $CPPFLAGS'
10575   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10576   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10577   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10578  
10579 <    cat >conftest.$ac_ext <<_ACEOF
10579 > cat >conftest.$ac_ext <<_ACEOF
10580   /* confdefs.h.  */
10581   _ACEOF
10582   cat confdefs.h >>conftest.$ac_ext
10583   cat >>conftest.$ac_ext <<_ACEOF
10584   /* end confdefs.h.  */
10585 <
10586 < #ifdef HAVE_IOSTREAM
10587 < #include <fstream>
6399 < #else
6400 < #include <fstream.h>
6401 < #endif
6402 < #ifdef HAVE_STD_IOSTREAM
10585 > #include <list>
10586 > #include <deque>
10587 > #ifdef HAVE_NAMESPACES
10588   using namespace std;
10589   #endif
10590 <
10590 > #ifdef FC_DUMMY_MAIN
10591 > #ifndef FC_DUMMY_MAIN_EQ_F77
10592 > #  ifdef __cplusplus
10593 >     extern "C"
10594 > #  endif
10595 >   int FC_DUMMY_MAIN() { return 1; }
10596 > #endif
10597 > #endif
10598   int
10599   main ()
10600   {
10601 < int fd=0;ofstream s;s.attach(fd);
10601 > list<int> x; x.push_back(5);
10602 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10603    ;
10604    return 0;
10605   }
# Line 6433 | Line 10626 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10626    ac_status=$?
10627    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628    (exit $ac_status); }; }; then
10629 <  ac_cv_cxx_have_fstream_attach=yes
10629 >  ac_cv_cxx_have_stl=yes
10630   else
10631    echo "$as_me: failed program was:" >&5
10632   sed 's/^/| /' conftest.$ac_ext >&5
10633  
10634 + ac_cv_cxx_have_stl=no
10635   fi
10636   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10637 <    ac_ext=cc
10637 > ac_ext=cc
10638   ac_cpp='$CXXCPP $CPPFLAGS'
10639   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10640   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
# Line 6448 | Line 10642 | fi
10642  
10643  
10644   fi
10645 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
10646 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
10647 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
10645 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10646 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10647 > if test "$ac_cv_cxx_have_stl" = yes; then
10648  
10649   cat >>confdefs.h <<\_ACEOF
10650 < #define HAVE_FSTREAM_ATTACH 1
10650 > #define HAVE_STL
10651   _ACEOF
10652  
10653 <  fi
10653 > fi
10654  
10655  
10656  
10657 <  echo "$as_me:$LINENO: checking for fstream::open()" >&5
10658 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
10659 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
10657 >  if test "${ac_cv_header_iostream+set}" = set; then
10658 >  echo "$as_me:$LINENO: checking for iostream" >&5
10659 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660 > if test "${ac_cv_header_iostream+set}" = set; then
10661    echo $ECHO_N "(cached) $ECHO_C" >&6
10662 + fi
10663 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665   else
10666 <
10667 <    ac_cv_cxx_have_fstream_open=no
10668 <    ac_cv_cxx_fstream_open_prot=no
10669 <
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
10666 >  # Is the header compilable?
10667 > echo "$as_me:$LINENO: checking iostream usability" >&5
10668 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669 > cat >conftest.$ac_ext <<_ACEOF
10670   /* confdefs.h.  */
10671   _ACEOF
10672   cat confdefs.h >>conftest.$ac_ext
10673   cat >>conftest.$ac_ext <<_ACEOF
10674   /* end confdefs.h.  */
10675 <
10676 < #ifdef HAVE_IOSTREAM
6488 < #include <fstream>
6489 < #else
6490 < #include <fstream.h>
6491 < #endif
6492 < #ifdef HAVE_STD_IOSTREAM
6493 < using namespace std;
6494 < #endif
6495 <
6496 < int
6497 < main ()
6498 < {
6499 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
6500 <  ;
6501 <  return 0;
6502 < }
10675 > $ac_includes_default
10676 > #include <iostream>
10677   _ACEOF
10678   rm -f conftest.$ac_objext
10679   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6523 | Line 10697 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10697    ac_status=$?
10698    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10699    (exit $ac_status); }; }; then
10700 <  ac_cv_cxx_have_fstream_open=yes
10700 >  ac_header_compiler=yes
10701   else
10702    echo "$as_me: failed program was:" >&5
10703   sed 's/^/| /' conftest.$ac_ext >&5
10704  
10705 + ac_header_compiler=no
10706   fi
10707   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10708 <    # Try with mode parameter
10709 <    cat >conftest.$ac_ext <<_ACEOF
10708 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10709 > echo "${ECHO_T}$ac_header_compiler" >&6
10710 >
10711 > # Is the header present?
10712 > echo "$as_me:$LINENO: checking iostream presence" >&5
10713 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714 > cat >conftest.$ac_ext <<_ACEOF
10715   /* confdefs.h.  */
10716   _ACEOF
10717   cat confdefs.h >>conftest.$ac_ext
10718   cat >>conftest.$ac_ext <<_ACEOF
10719   /* end confdefs.h.  */
10720 <
6541 < #ifdef HAVE_IOSTREAM
6542 < #include <fstream>
6543 < #else
6544 < #include <fstream.h>
6545 < #endif
6546 < #ifdef HAVE_STD_IOSTREAM
6547 < using namespace std;
6548 < #endif
6549 <
6550 < int
6551 < main ()
6552 < {
6553 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
6554 <  ;
6555 <  return 0;
6556 < }
10720 > #include <iostream>
10721   _ACEOF
10722 < rm -f conftest.$ac_objext
10723 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6560 <  (eval $ac_compile) 2>conftest.er1
10722 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10723 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10724    ac_status=$?
10725    grep -v '^ *+' conftest.er1 >conftest.err
10726    rm -f conftest.er1
10727    cat conftest.err >&5
10728    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10729 <  (exit $ac_status); } &&
10730 <         { ac_try='test -z "$ac_cxx_werror_flag"
10731 <                         || test ! -s conftest.err'
10732 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10733 <  (eval $ac_try) 2>&5
10734 <  ac_status=$?
10735 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6573 <  (exit $ac_status); }; } &&
6574 <         { ac_try='test -s conftest.$ac_objext'
6575 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6576 <  (eval $ac_try) 2>&5
6577 <  ac_status=$?
6578 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6579 <  (exit $ac_status); }; }; then
6580 <  ac_cv_cxx_fstream_open_prot=yes
10729 >  (exit $ac_status); } >/dev/null; then
10730 >  if test -s conftest.err; then
10731 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10732 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10733 >  else
10734 >    ac_cpp_err=
10735 >  fi
10736   else
10737 +  ac_cpp_err=yes
10738 + fi
10739 + if test -z "$ac_cpp_err"; then
10740 +  ac_header_preproc=yes
10741 + else
10742    echo "$as_me: failed program was:" >&5
10743   sed 's/^/| /' conftest.$ac_ext >&5
10744  
10745 +  ac_header_preproc=no
10746   fi
10747 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10748 <    ac_ext=cc
10749 < 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
10747 > rm -f conftest.err conftest.$ac_ext
10748 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10749 > echo "${ECHO_T}$ac_header_preproc" >&6
10750  
10751 + # So?  What about this header?
10752 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753 +  yes:no: )
10754 +    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755 + echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756 +    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757 + echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758 +    ac_header_preproc=yes
10759 +    ;;
10760 +  no:yes:* )
10761 +    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762 + echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763 +    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764 + echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765 +    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766 + echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767 +    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768 + echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769 +    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770 + echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771 +    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772 + echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773 +    (
10774 +      cat <<\_ASBOX
10775 + ## ------------------------------ ##
10776 + ## Report this to gezelter@nd.edu ##
10777 + ## ------------------------------ ##
10778 + _ASBOX
10779 +    ) |
10780 +      sed "s/^/$as_me: WARNING:     /" >&2
10781 +    ;;
10782 + esac
10783 + echo "$as_me:$LINENO: checking for iostream" >&5
10784 + echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785 + if test "${ac_cv_header_iostream+set}" = set; then
10786 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10787 + else
10788 +  ac_cv_header_iostream=$ac_header_preproc
10789 + fi
10790 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792  
10793   fi
10794 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
6596 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
6597 <  if test "$ac_cv_cxx_have_fstream_open" = yes; then
10794 > if test $ac_cv_header_iostream = yes; then
10795  
6599 – cat >>confdefs.h <<\_ACEOF
6600 – #define HAVE_FSTREAM_OPEN 1
6601 – _ACEOF
10796  
6603 –  fi
6604 –  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
6605 –
10797   cat >>confdefs.h <<\_ACEOF
10798 < #define FSTREAM_OPEN_PROT 1
10798 > #define HAVE_IOSTREAM 1
10799   _ACEOF
10800  
6610 –  fi
10801  
10802 + else
10803  
10804  
10805 <
10806 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
10807 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
10808 < if test "${ac_cv_lib_m_asin+set}" = set; then
10805 > for ac_header in iostream.h
10806 > do
10807 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10809 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10810 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10811 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10812    echo $ECHO_N "(cached) $ECHO_C" >&6
10813 + fi
10814 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10815 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10816   else
10817 <  ac_check_lib_save_LIBS=$LIBS
10818 < LIBS="-lm  $LIBS"
10817 >  # Is the header compilable?
10818 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10819 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10820   cat >conftest.$ac_ext <<_ACEOF
10821   /* confdefs.h.  */
10822   _ACEOF
10823   cat confdefs.h >>conftest.$ac_ext
10824   cat >>conftest.$ac_ext <<_ACEOF
10825   /* end confdefs.h.  */
10826 <
10827 < /* Override any gcc2 internal prototype to avoid an error.  */
6630 < #ifdef __cplusplus
6631 < extern "C"
6632 < #endif
6633 < /* 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 ();
6636 < int
6637 < main ()
6638 < {
6639 < asin ();
6640 <  ;
6641 <  return 0;
6642 < }
10826 > $ac_includes_default
10827 > #include <$ac_header>
10828   _ACEOF
10829 < rm -f conftest.$ac_objext conftest$ac_exeext
10830 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10831 <  (eval $ac_link) 2>conftest.er1
10829 > rm -f conftest.$ac_objext
10830 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831 >  (eval $ac_compile) 2>conftest.er1
10832    ac_status=$?
10833    grep -v '^ *+' conftest.er1 >conftest.err
10834    rm -f conftest.er1
# Line 6657 | Line 10842 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10842    ac_status=$?
10843    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10844    (exit $ac_status); }; } &&
10845 <         { ac_try='test -s conftest$ac_exeext'
10845 >         { ac_try='test -s conftest.$ac_objext'
10846    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10847    (eval $ac_try) 2>&5
10848    ac_status=$?
10849    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10850    (exit $ac_status); }; }; then
10851 <  ac_cv_lib_m_asin=yes
10851 >  ac_header_compiler=yes
10852   else
10853    echo "$as_me: failed program was:" >&5
10854   sed 's/^/| /' conftest.$ac_ext >&5
10855  
10856 < ac_cv_lib_m_asin=no
10856 > ac_header_compiler=no
10857   fi
10858 < rm -f conftest.err conftest.$ac_objext \
10859 <      conftest$ac_exeext conftest.$ac_ext
10860 < LIBS=$ac_check_lib_save_LIBS
6676 < fi
6677 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
6678 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
6679 < if test $ac_cv_lib_m_asin = yes; then
6680 <  cat >>confdefs.h <<_ACEOF
6681 < #define HAVE_LIBM 1
6682 < _ACEOF
10858 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10859 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10860 > echo "${ECHO_T}$ac_header_compiler" >&6
10861  
10862 <  LIBS="-lm $LIBS"
10863 <
10864 < else
6687 <  exit
6688 < fi
6689 <
6690 <
6691 < ac_ext=c
6692 < ac_cpp='$CPP $CPPFLAGS'
6693 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6694 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6695 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6696 <
6697 <
6698 < #
6699 < # Handle user hints
6700 < #
6701 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
6702 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
6703 <
6704 < # Check whether --with-zlib or --without-zlib was given.
6705 < if test "${with_zlib+set}" = set; then
6706 <  withval="$with_zlib"
6707 <  if test "$withval" != no ; then
6708 <  echo "$as_me:$LINENO: result: yes" >&5
6709 < echo "${ECHO_T}yes" >&6
6710 <  if test -d "$withval"
6711 <  then
6712 <    ZLIB_HOME="$withval"
6713 <  else
6714 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
6715 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
6716 <  fi
6717 < else
6718 <  echo "$as_me:$LINENO: result: no" >&5
6719 < echo "${ECHO_T}no" >&6
6720 < fi
6721 < fi;
6722 <
6723 < ZLIB_HOME=/usr/local
6724 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
6725 < then
6726 <        ZLIB_HOME=/usr
6727 < fi
6728 <
6729 < #
6730 < # Locate zlib, if wanted
6731 < #
6732 < if test -n "${ZLIB_HOME}"
6733 < then
6734 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
6735 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
6736 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
6737 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
6738 <
6739 <
6740 <        ac_ext=c
6741 < ac_cpp='$CPP $CPPFLAGS'
6742 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6743 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6744 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6745 <
6746 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6747 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6748 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6749 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6750 < else
6751 <  ac_check_lib_save_LIBS=$LIBS
6752 < LIBS="-lz  $LIBS"
10862 > # Is the header present?
10863 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10864 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10865   cat >conftest.$ac_ext <<_ACEOF
10866   /* confdefs.h.  */
10867   _ACEOF
10868   cat confdefs.h >>conftest.$ac_ext
10869   cat >>conftest.$ac_ext <<_ACEOF
10870   /* end confdefs.h.  */
10871 <
6760 < /* Override any gcc2 internal prototype to avoid an error.  */
6761 < #ifdef __cplusplus
6762 < extern "C"
6763 < #endif
6764 < /* We use char because int might match the return type of a gcc2
6765 <   builtin and then its argument prototype would still apply.  */
6766 < char inflateEnd ();
6767 < int
6768 < main ()
6769 < {
6770 < inflateEnd ();
6771 <  ;
6772 <  return 0;
6773 < }
10871 > #include <$ac_header>
10872   _ACEOF
10873 < rm -f conftest.$ac_objext conftest$ac_exeext
10874 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6777 <  (eval $ac_link) 2>conftest.er1
10873 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10874 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10875    ac_status=$?
10876    grep -v '^ *+' conftest.er1 >conftest.err
10877    rm -f conftest.er1
10878    cat conftest.err >&5
10879    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880 <  (exit $ac_status); } &&
10881 <         { ac_try='test -z "$ac_c_werror_flag"
10882 <                         || test ! -s conftest.err'
10883 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10884 <  (eval $ac_try) 2>&5
10885 <  ac_status=$?
10886 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6790 <  (exit $ac_status); }; } &&
6791 <         { ac_try='test -s conftest$ac_exeext'
6792 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6793 <  (eval $ac_try) 2>&5
6794 <  ac_status=$?
6795 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6796 <  (exit $ac_status); }; }; then
6797 <  ac_cv_lib_z_inflateEnd=yes
10880 >  (exit $ac_status); } >/dev/null; then
10881 >  if test -s conftest.err; then
10882 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10883 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10884 >  else
10885 >    ac_cpp_err=
10886 >  fi
10887   else
10888 +  ac_cpp_err=yes
10889 + fi
10890 + if test -z "$ac_cpp_err"; then
10891 +  ac_header_preproc=yes
10892 + else
10893    echo "$as_me: failed program was:" >&5
10894   sed 's/^/| /' conftest.$ac_ext >&5
10895  
10896 < ac_cv_lib_z_inflateEnd=no
10896 >  ac_header_preproc=no
10897   fi
10898 < rm -f conftest.err conftest.$ac_objext \
10899 <      conftest$ac_exeext conftest.$ac_ext
10900 < LIBS=$ac_check_lib_save_LIBS
10901 < fi
10902 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
10903 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
10904 < if test $ac_cv_lib_z_inflateEnd = yes; then
10905 <  zlib_cv_libz=yes
10898 > rm -f conftest.err conftest.$ac_ext
10899 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10900 > echo "${ECHO_T}$ac_header_preproc" >&6
10901 >
10902 > # So?  What about this header?
10903 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904 >  yes:no: )
10905 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10907 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10908 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10909 >    ac_header_preproc=yes
10910 >    ;;
10911 >  no:yes:* )
10912 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10913 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10914 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10915 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10916 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10917 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10918 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10919 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10920 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10921 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10922 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10923 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10924 >    (
10925 >      cat <<\_ASBOX
10926 > ## ------------------------------ ##
10927 > ## Report this to gezelter@nd.edu ##
10928 > ## ------------------------------ ##
10929 > _ASBOX
10930 >    ) |
10931 >      sed "s/^/$as_me: WARNING:     /" >&2
10932 >    ;;
10933 > esac
10934 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10935 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10936 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10937 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10938   else
10939 <  zlib_cv_libz=no
10939 >  eval "$as_ac_Header=\$ac_header_preproc"
10940   fi
10941 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10942 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10943  
10944 <        if test "${ac_cv_header_zlib_h+set}" = set; then
10945 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
10946 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10947 < if test "${ac_cv_header_zlib_h+set}" = set; then
10944 > fi
10945 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10946 >  cat >>confdefs.h <<_ACEOF
10947 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10948 > _ACEOF
10949 >
10950 > fi
10951 >
10952 > done
10953 >
10954 >
10955 > fi
10956 >
10957 >
10958 >
10959 >
10960 >  if test "${ac_cv_header_iomanip+set}" = set; then
10961 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10962 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963 > if test "${ac_cv_header_iomanip+set}" = set; then
10964    echo $ECHO_N "(cached) $ECHO_C" >&6
10965   fi
10966 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10967 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10966 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968   else
10969    # Is the header compilable?
10970 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
10971 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
10970 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10971 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10972   cat >conftest.$ac_ext <<_ACEOF
10973   /* confdefs.h.  */
10974   _ACEOF
# Line 6832 | Line 10976 | $ac_includes_default
10976   cat >>conftest.$ac_ext <<_ACEOF
10977   /* end confdefs.h.  */
10978   $ac_includes_default
10979 < #include <zlib.h>
10979 > #include <iomanip>
10980   _ACEOF
10981   rm -f conftest.$ac_objext
10982   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6843 | Line 10987 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10987    cat conftest.err >&5
10988    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989    (exit $ac_status); } &&
10990 <         { ac_try='test -z "$ac_c_werror_flag"
10990 >         { ac_try='test -z "$ac_cxx_werror_flag"
10991                           || test ! -s conftest.err'
10992    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10993    (eval $ac_try) 2>&5
# Line 6868 | Line 11012 | echo "${ECHO_T}$ac_header_compiler" >&6
11012   echo "${ECHO_T}$ac_header_compiler" >&6
11013  
11014   # Is the header present?
11015 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
11016 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
11015 > echo "$as_me:$LINENO: checking iomanip presence" >&5
11016 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017   cat >conftest.$ac_ext <<_ACEOF
11018   /* confdefs.h.  */
11019   _ACEOF
11020   cat confdefs.h >>conftest.$ac_ext
11021   cat >>conftest.$ac_ext <<_ACEOF
11022   /* end confdefs.h.  */
11023 < #include <zlib.h>
11023 > #include <iomanip>
11024   _ACEOF
11025   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11026    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6887 | Line 11031 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11031    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032    (exit $ac_status); } >/dev/null; then
11033    if test -s conftest.err; then
11034 <    ac_cpp_err=$ac_c_preproc_warn_flag
11035 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11034 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11035 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11036    else
11037      ac_cpp_err=
11038    fi
# Line 6908 | Line 11052 | echo "${ECHO_T}$ac_header_preproc" >&6
11052   echo "${ECHO_T}$ac_header_preproc" >&6
11053  
11054   # So?  What about this header?
11055 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11055 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11056    yes:no: )
11057 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
11058 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
11060 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
11057 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11058 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11060 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11061      ac_header_preproc=yes
11062      ;;
11063    no:yes:* )
11064 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
11065 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
11066 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
11067 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
11068 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
11069 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
11070 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
11071 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
11072 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
11073 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
11074 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
11075 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
11064 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11065 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11066 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11067 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11068 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11069 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11070 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11071 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11072 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11073 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11074 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11075 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11076      (
11077        cat <<\_ASBOX
11078   ## ------------------------------ ##
# Line 6939 | Line 11083 | esac
11083        sed "s/^/$as_me: WARNING:     /" >&2
11084      ;;
11085   esac
11086 < echo "$as_me:$LINENO: checking for zlib.h" >&5
11087 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
11088 < if test "${ac_cv_header_zlib_h+set}" = set; then
11086 > echo "$as_me:$LINENO: checking for iomanip" >&5
11087 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11088 > if test "${ac_cv_header_iomanip+set}" = set; then
11089    echo $ECHO_N "(cached) $ECHO_C" >&6
11090   else
11091 <  ac_cv_header_zlib_h=$ac_header_preproc
11091 >  ac_cv_header_iomanip=$ac_header_preproc
11092   fi
11093 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
11094 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
11093 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095  
11096   fi
11097 < if test $ac_cv_header_zlib_h = yes; then
6954 <  zlib_cv_zlib_h=yes
6955 < else
6956 <  zlib_cv_zlib_h=no
6957 < fi
11097 > if test $ac_cv_header_iomanip = yes; then
11098  
11099  
11100 <        ac_ext=c
11101 < ac_cpp='$CPP $CPPFLAGS'
6962 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6963 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6964 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6965 <
6966 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6967 <        then
6968 <                #
6969 <                # If both library and header were found, use them
6970 <                #
6971 <
6972 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6973 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6974 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6975 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6976 < else
6977 <  ac_check_lib_save_LIBS=$LIBS
6978 < LIBS="-lz  $LIBS"
6979 < cat >conftest.$ac_ext <<_ACEOF
6980 < /* confdefs.h.  */
6981 < _ACEOF
6982 < cat confdefs.h >>conftest.$ac_ext
6983 < cat >>conftest.$ac_ext <<_ACEOF
6984 < /* end confdefs.h.  */
6985 <
6986 < /* Override any gcc2 internal prototype to avoid an error.  */
6987 < #ifdef __cplusplus
6988 < extern "C"
6989 < #endif
6990 < /* We use char because int might match the return type of a gcc2
6991 <   builtin and then its argument prototype would still apply.  */
6992 < char inflateEnd ();
6993 < int
6994 < main ()
6995 < {
6996 < inflateEnd ();
6997 <  ;
6998 <  return 0;
6999 < }
7000 < _ACEOF
7001 < rm -f conftest.$ac_objext conftest$ac_exeext
7002 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7003 <  (eval $ac_link) 2>conftest.er1
7004 <  ac_status=$?
7005 <  grep -v '^ *+' conftest.er1 >conftest.err
7006 <  rm -f conftest.er1
7007 <  cat conftest.err >&5
7008 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7009 <  (exit $ac_status); } &&
7010 <         { ac_try='test -z "$ac_c_werror_flag"
7011 <                         || test ! -s conftest.err'
7012 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7013 <  (eval $ac_try) 2>&5
7014 <  ac_status=$?
7015 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7016 <  (exit $ac_status); }; } &&
7017 <         { ac_try='test -s conftest$ac_exeext'
7018 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7019 <  (eval $ac_try) 2>&5
7020 <  ac_status=$?
7021 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7022 <  (exit $ac_status); }; }; then
7023 <  ac_cv_lib_z_inflateEnd=yes
7024 < else
7025 <  echo "$as_me: failed program was:" >&5
7026 < sed 's/^/| /' conftest.$ac_ext >&5
7027 <
7028 < ac_cv_lib_z_inflateEnd=no
7029 < fi
7030 < rm -f conftest.err conftest.$ac_objext \
7031 <      conftest$ac_exeext conftest.$ac_ext
7032 < LIBS=$ac_check_lib_save_LIBS
7033 < fi
7034 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7035 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
7036 < if test $ac_cv_lib_z_inflateEnd = yes; then
7037 <  cat >>confdefs.h <<_ACEOF
7038 < #define HAVE_LIBZ 1
11100 > cat >>confdefs.h <<\_ACEOF
11101 > #define HAVE_IOMANIP 1
11102   _ACEOF
7040 –
7041 –  LIBS="-lz $LIBS"
7042 –
7043 – fi
7044 –
7045 –                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7046 – echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7047 –                echo "$as_me:$LINENO: result: ok" >&5
7048 – echo "${ECHO_T}ok" >&6
7049 –        else
7050 –                #
7051 –                # If either header or library was not found, revert and bomb
7052 –                #
7053 –                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7054 – echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7055 –                LDFLAGS="$ZLIB_OLD_LDFLAGS"
7056 –                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
7057 –                echo "$as_me:$LINENO: result: failed" >&5
7058 – echo "${ECHO_T}failed" >&6
7059 –                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
7060 – echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
7061 –   { (exit 1); exit 1; }; }
7062 –        fi
7063 – fi
7064 –
7065 –
7066 –
7067 –
7068 –
7069 –
7070 –
7071 –
7072 –
7073 –
7074 –
11103  
11104  
11105 + else
11106  
11107  
11108 <
7080 <
7081 <
7082 <
7083 <
7084 <
7085 < 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
11108 > for ac_header in iomanip.h
11109   do
11110   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7115 | Line 11138 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11138    cat conftest.err >&5
11139    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11140    (exit $ac_status); } &&
11141 <         { ac_try='test -z "$ac_c_werror_flag"
11141 >         { ac_try='test -z "$ac_cxx_werror_flag"
11142                           || test ! -s conftest.err'
11143    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11144    (eval $ac_try) 2>&5
# Line 7159 | Line 11182 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11182    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11183    (exit $ac_status); } >/dev/null; then
11184    if test -s conftest.err; then
11185 <    ac_cpp_err=$ac_c_preproc_warn_flag
11186 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11185 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11186 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187    else
11188      ac_cpp_err=
11189    fi
# Line 7180 | Line 11203 | echo "${ECHO_T}$ac_header_preproc" >&6
11203   echo "${ECHO_T}$ac_header_preproc" >&6
11204  
11205   # So?  What about this header?
11206 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11206 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11207    yes:no: )
11208      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11209   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7231 | Line 11254 | done
11254  
11255   done
11256  
7234 – ac_ext=cc
7235 – ac_cpp='$CXXCPP $CPPFLAGS'
7236 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7237 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7238 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11257  
11258 + fi
11259  
11260  
11261  
11262  
11263 <
7245 < for ac_header in ctype.h iostream fstream sstream strstream
11263 > for ac_header in cmath
11264   do
11265   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11266   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7391 | Line 11409 | done
11409  
11410   done
11411  
7394 – ac_ext=c
7395 – ac_cpp='$CPP $CPPFLAGS'
7396 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7397 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7398 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
11412  
11413  
11414  
11415 +  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11416 + echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11417 + if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11418 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11419 + else
11420  
11421 +      ac_cv_cxx_have_std_iostream=no
11422 +      ac_cv_cxx_need_use_std_iostream=no
11423 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11424  
11425  
11426 +        ac_ext=cc
11427 + ac_cpp='$CXXCPP $CPPFLAGS'
11428 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431  
11432 <
7407 <
7408 <
7409 <
7410 <
7411 <
7412 < for ac_func in rint snprintf sranddev strcasecmp strncasecmp stricmp strnicmp pstat_getstatic sysmp getsysinfo sysctl table
7413 < do
7414 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7415 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7416 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7417 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7418 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7419 < else
7420 <  cat >conftest.$ac_ext <<_ACEOF
11432 >        cat >conftest.$ac_ext <<_ACEOF
11433   /* confdefs.h.  */
11434   _ACEOF
11435   cat confdefs.h >>conftest.$ac_ext
11436   cat >>conftest.$ac_ext <<_ACEOF
11437   /* end confdefs.h.  */
11438 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11439 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11440 < #define $ac_func innocuous_$ac_func
7429 <
7430 < /* System header to define __stub macros and hopefully few prototypes,
7431 <    which can conflict with char $ac_func (); below.
7432 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7433 <    <limits.h> exists even on freestanding compilers.  */
7434 <
7435 < #ifdef __STDC__
7436 < # include <limits.h>
11438 >
11439 > #ifdef HAVE_IOSTREAM
11440 > #include <iostream>
11441   #else
11442 < # include <assert.h>
11442 > #include <iostream.h>
11443   #endif
11444  
11445 < #undef $ac_func
11446 <
11447 < /* Override any gcc2 internal prototype to avoid an error.  */
11448 < #ifdef __cplusplus
11449 < extern "C"
11450 < {
11445 > #ifdef FC_DUMMY_MAIN
11446 > #ifndef FC_DUMMY_MAIN_EQ_F77
11447 > #  ifdef __cplusplus
11448 >     extern "C"
11449 > #  endif
11450 >   int FC_DUMMY_MAIN() { return 1; }
11451   #endif
7448 – /* We use char because int might match the return type of a gcc2
7449 –   builtin and then its argument prototype would still apply.  */
7450 – char $ac_func ();
7451 – /* The GNU C library defines this for functions which it implements
7452 –    to always fail with ENOSYS.  Some functions are actually named
7453 –    something starting with __ and the normal name is an alias.  */
7454 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7455 – choke me
7456 – #else
7457 – char (*f) () = $ac_func;
11452   #endif
7459 – #ifdef __cplusplus
7460 – }
7461 – #endif
7462 –
11453   int
11454   main ()
11455   {
11456 < return f != $ac_func;
11456 > std::cout<<"Hello World"<<std::endl;return 0;
11457    ;
11458    return 0;
11459   }
11460   _ACEOF
11461 < rm -f conftest.$ac_objext conftest$ac_exeext
11462 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11463 <  (eval $ac_link) 2>conftest.er1
11461 > rm -f conftest.$ac_objext
11462 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11463 >  (eval $ac_compile) 2>conftest.er1
11464    ac_status=$?
11465    grep -v '^ *+' conftest.er1 >conftest.err
11466    rm -f conftest.er1
11467    cat conftest.err >&5
11468    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469    (exit $ac_status); } &&
11470 <         { ac_try='test -z "$ac_c_werror_flag"
11470 >         { ac_try='test -z "$ac_cxx_werror_flag"
11471                           || test ! -s conftest.err'
11472    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473    (eval $ac_try) 2>&5
11474    ac_status=$?
11475    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11476    (exit $ac_status); }; } &&
11477 <         { ac_try='test -s conftest$ac_exeext'
11477 >         { ac_try='test -s conftest.$ac_objext'
11478    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11479    (eval $ac_try) 2>&5
11480    ac_status=$?
11481    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482    (exit $ac_status); }; }; then
11483 <  eval "$as_ac_var=yes"
11483 >  ac_cv_cxx_have_std_iostream=yes
11484   else
11485    echo "$as_me: failed program was:" >&5
11486   sed 's/^/| /' conftest.$ac_ext >&5
11487  
7498 – eval "$as_ac_var=no"
11488   fi
11489 < rm -f conftest.err conftest.$ac_objext \
11490 <      conftest$ac_exeext conftest.$ac_ext
7502 < fi
7503 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7504 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7505 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7506 <  cat >>confdefs.h <<_ACEOF
7507 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7508 < _ACEOF
7509 <
7510 < fi
7511 < done
7512 <
7513 < # special check for _system_configuration because AIX <4.3.2 do not
7514 < # contain the `physmem' member.
7515 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
7516 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
7517 < cat >conftest.$ac_ext <<_ACEOF
11489 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11490 >        cat >conftest.$ac_ext <<_ACEOF
11491   /* confdefs.h.  */
11492   _ACEOF
11493   cat confdefs.h >>conftest.$ac_ext
11494   cat >>conftest.$ac_ext <<_ACEOF
11495   /* end confdefs.h.  */
11496 < #include <sys/systemcfg.h>
11496 >
11497 > #define __USE_STD_IOSTREAM 1
11498 > #ifdef HAVE_IOSTREAM
11499 > #include <iostream>
11500 > #else
11501 > #include <iostream.h>
11502 > #endif
11503 >
11504 > #ifdef FC_DUMMY_MAIN
11505 > #ifndef FC_DUMMY_MAIN_EQ_F77
11506 > #  ifdef __cplusplus
11507 >     extern "C"
11508 > #  endif
11509 >   int FC_DUMMY_MAIN() { return 1; }
11510 > #endif
11511 > #endif
11512   int
11513   main ()
11514   {
11515 < double x = _system_configuration.physmem;
11515 > std::cout<<"Hello World"<<std::endl;return 0;
11516    ;
11517    return 0;
11518   }
# Line 7538 | Line 11526 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11526    cat conftest.err >&5
11527    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528    (exit $ac_status); } &&
11529 <         { ac_try='test -z "$ac_c_werror_flag"
11529 >         { ac_try='test -z "$ac_cxx_werror_flag"
11530                           || test ! -s conftest.err'
11531    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532    (eval $ac_try) 2>&5
# Line 7551 | Line 11539 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11539    ac_status=$?
11540    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541    (exit $ac_status); }; }; then
11542 <  echo "$as_me:$LINENO: result: yes" >&5
7555 < echo "${ECHO_T}yes" >&6
7556 <
7557 < cat >>confdefs.h <<\_ACEOF
7558 < #define HAVE__SYSTEM_CONFIGURATION 1
7559 < _ACEOF
7560 <
11542 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11543   else
11544    echo "$as_me: failed program was:" >&5
11545   sed 's/^/| /' conftest.$ac_ext >&5
11546  
7565 – echo "$as_me:$LINENO: result: no" >&5
7566 – echo "${ECHO_T}no" >&6
11547   fi
11548   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11549 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11550 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
11551 < if test "${ac_cv_header_time+set}" = set; then
11549 >        ac_ext=cc
11550 > ac_cpp='$CXXCPP $CPPFLAGS'
11551 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11552 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11553 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11554 >
11555 >      fi
11556 >
11557 > fi
11558 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11559 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11560 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11561 >
11562 > cat >>confdefs.h <<\_ACEOF
11563 > #define HAVE_STD_IOSTREAM 1
11564 > _ACEOF
11565 >
11566 >  fi
11567 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568 >
11569 > cat >>confdefs.h <<\_ACEOF
11570 > #define __USE_STD_IOSTREAM 1
11571 > _ACEOF
11572 >
11573 >  fi
11574 >
11575 >
11576 >
11577 >
11578 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581    echo $ECHO_N "(cached) $ECHO_C" >&6
11582   else
11583 <  cat >conftest.$ac_ext <<_ACEOF
11583 >
11584 >      ac_cv_cxx_have_std_stl=no
11585 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11586 >
11587 >
11588 >        ac_ext=cc
11589 > ac_cpp='$CXXCPP $CPPFLAGS'
11590 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593 >
11594 >        cat >conftest.$ac_ext <<_ACEOF
11595   /* confdefs.h.  */
11596   _ACEOF
11597   cat confdefs.h >>conftest.$ac_ext
11598   cat >>conftest.$ac_ext <<_ACEOF
11599   /* end confdefs.h.  */
11600 < #include <sys/types.h>
7581 < #include <sys/time.h>
7582 < #include <time.h>
11600 > #include <list>
11601  
11602 + #ifdef FC_DUMMY_MAIN
11603 + #ifndef FC_DUMMY_MAIN_EQ_F77
11604 + #  ifdef __cplusplus
11605 +     extern "C"
11606 + #  endif
11607 +   int FC_DUMMY_MAIN() { return 1; }
11608 + #endif
11609 + #endif
11610   int
11611   main ()
11612   {
11613 < if ((struct tm *) 0)
7588 < return 0;
11613 > std::list<int> foo;return 0;
11614    ;
11615    return 0;
11616   }
# Line 7599 | Line 11624 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11624    cat conftest.err >&5
11625    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11626    (exit $ac_status); } &&
11627 <         { ac_try='test -z "$ac_c_werror_flag"
11627 >         { ac_try='test -z "$ac_cxx_werror_flag"
11628                           || test ! -s conftest.err'
11629    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11630    (eval $ac_try) 2>&5
# Line 7612 | Line 11637 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11637    ac_status=$?
11638    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639    (exit $ac_status); }; }; then
11640 <  ac_cv_header_time=yes
11640 >  ac_cv_cxx_have_std_stl=yes
11641   else
11642    echo "$as_me: failed program was:" >&5
11643   sed 's/^/| /' conftest.$ac_ext >&5
11644  
7620 – ac_cv_header_time=no
11645   fi
11646   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647 +        ac_ext=cc
11648 + ac_cpp='$CXXCPP $CPPFLAGS'
11649 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652 +
11653 +      fi
11654 +
11655   fi
11656 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11657 < echo "${ECHO_T}$ac_cv_header_time" >&6
11658 < if test $ac_cv_header_time = yes; then
11656 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11657 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11658 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11659  
11660   cat >>confdefs.h <<\_ACEOF
11661 < #define TIME_WITH_SYS_TIME 1
11661 > #define HAVE_STD_STL 1
11662   _ACEOF
11663  
11664 < fi
11664 >  fi
11665  
11666  
11667 < echo "$as_me:$LINENO: checking for clock_t" >&5
11668 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11669 < if test "${ac_cv_type_clock_t+set}" = set; then
11667 >
11668 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671    echo $ECHO_N "(cached) $ECHO_C" >&6
11672   else
11673 <  cat >conftest.$ac_ext <<_ACEOF
11673 >
11674 >    ac_cv_cxx_have_fstream_attach=no
11675 >
11676 >
11677 >    ac_ext=cc
11678 > ac_cpp='$CXXCPP $CPPFLAGS'
11679 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11680 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11681 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11682 >
11683 >    cat >conftest.$ac_ext <<_ACEOF
11684   /* confdefs.h.  */
11685   _ACEOF
11686   cat confdefs.h >>conftest.$ac_ext
11687   cat >>conftest.$ac_ext <<_ACEOF
11688   /* end confdefs.h.  */
11689 < $ac_includes_default
11689 >
11690 > #ifdef HAVE_IOSTREAM
11691 > #include <fstream>
11692 > #else
11693 > #include <fstream.h>
11694 > #endif
11695 > #ifdef HAVE_STD_IOSTREAM
11696 > using namespace std;
11697 > #endif
11698 >
11699 > #ifdef FC_DUMMY_MAIN
11700 > #ifndef FC_DUMMY_MAIN_EQ_F77
11701 > #  ifdef __cplusplus
11702 >     extern "C"
11703 > #  endif
11704 >   int FC_DUMMY_MAIN() { return 1; }
11705 > #endif
11706 > #endif
11707   int
11708   main ()
11709   {
11710 < if ((clock_t *) 0)
7651 <  return 0;
7652 < if (sizeof (clock_t))
7653 <  return 0;
11710 > int fd=0;ofstream s;s.attach(fd);
11711    ;
11712    return 0;
11713   }
# Line 7664 | Line 11721 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11721    cat conftest.err >&5
11722    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723    (exit $ac_status); } &&
11724 <         { ac_try='test -z "$ac_c_werror_flag"
11724 >         { ac_try='test -z "$ac_cxx_werror_flag"
11725                           || test ! -s conftest.err'
11726    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727    (eval $ac_try) 2>&5
# Line 7677 | Line 11734 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11734    ac_status=$?
11735    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736    (exit $ac_status); }; }; then
11737 <  ac_cv_type_clock_t=yes
11737 >  ac_cv_cxx_have_fstream_attach=yes
11738   else
11739    echo "$as_me: failed program was:" >&5
11740   sed 's/^/| /' conftest.$ac_ext >&5
11741  
7685 – ac_cv_type_clock_t=no
11742   fi
11743   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744 +    ac_ext=cc
11745 + ac_cpp='$CXXCPP $CPPFLAGS'
11746 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749 +
11750 +
11751   fi
11752 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11753 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11754 < if test $ac_cv_type_clock_t = yes; then
11752 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11753 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11754 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11755  
11756 < cat >>confdefs.h <<_ACEOF
11757 < #define HAVE_CLOCK_T 1
11756 > cat >>confdefs.h <<\_ACEOF
11757 > #define HAVE_FSTREAM_ATTACH 1
11758   _ACEOF
11759  
11760 +  fi
11761  
7698 – fi
11762  
11763 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11764 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11765 < if test "${ac_cv_c_const+set}" = set; then
11763 >
11764 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11765 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11766 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11767    echo $ECHO_N "(cached) $ECHO_C" >&6
11768   else
11769 <  cat >conftest.$ac_ext <<_ACEOF
11769 >
11770 >    ac_cv_cxx_have_fstream_open=no
11771 >    ac_cv_cxx_fstream_open_prot=no
11772 >
11773 >
11774 >    ac_ext=cc
11775 > ac_cpp='$CXXCPP $CPPFLAGS'
11776 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779 >
11780 >    # Try with 2 parameters
11781 >    cat >conftest.$ac_ext <<_ACEOF
11782   /* confdefs.h.  */
11783   _ACEOF
11784   cat confdefs.h >>conftest.$ac_ext
11785   cat >>conftest.$ac_ext <<_ACEOF
11786   /* end confdefs.h.  */
11787  
11788 + #ifdef HAVE_IOSTREAM
11789 + #include <fstream>
11790 + #else
11791 + #include <fstream.h>
11792 + #endif
11793 + #ifdef HAVE_STD_IOSTREAM
11794 + using namespace std;
11795 + #endif
11796 +
11797 + #ifdef FC_DUMMY_MAIN
11798 + #ifndef FC_DUMMY_MAIN_EQ_F77
11799 + #  ifdef __cplusplus
11800 +     extern "C"
11801 + #  endif
11802 +   int FC_DUMMY_MAIN() { return 1; }
11803 + #endif
11804 + #endif
11805   int
11806   main ()
11807   {
11808 < /* FIXME: Include the comments suggested by Paul. */
7716 < #ifndef __cplusplus
7717 <  /* Ultrix mips cc rejects this.  */
7718 <  typedef int charset[2];
7719 <  const charset x;
7720 <  /* SunOS 4.1.1 cc rejects this.  */
7721 <  char const *const *ccp;
7722 <  char **p;
7723 <  /* NEC SVR4.0.2 mips cc rejects this.  */
7724 <  struct point {int x, y;};
7725 <  static struct point const zero = {0,0};
7726 <  /* AIX XL C 1.02.0.0 rejects this.
7727 <     It does not let you subtract one const X* pointer from another in
7728 <     an arm of an if-expression whose if-part is not a constant
7729 <     expression */
7730 <  const char *g = "string";
7731 <  ccp = &g + (g ? g-g : 0);
7732 <  /* HPUX 7.0 cc rejects these. */
7733 <  ++ccp;
7734 <  p = (char**) ccp;
7735 <  ccp = (char const *const *) p;
7736 <  { /* SCO 3.2v4 cc rejects this.  */
7737 <    char *t;
7738 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
7739 <
7740 <    *t++ = 0;
7741 <  }
7742 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7743 <    int x[] = {25, 17};
7744 <    const int *foo = &x[0];
7745 <    ++foo;
7746 <  }
7747 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7748 <    typedef const int *iptr;
7749 <    iptr p = 0;
7750 <    ++p;
7751 <  }
7752 <  { /* AIX XL C 1.02.0.0 rejects this saying
7753 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7754 <    struct s { int j; const int *ap[3]; };
7755 <    struct s *b; b->j = 5;
7756 <  }
7757 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7758 <    const int foo = 10;
7759 <  }
7760 < #endif
7761 <
11808 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809    ;
11810    return 0;
11811   }
# Line 7772 | Line 11819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11819    cat conftest.err >&5
11820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821    (exit $ac_status); } &&
11822 <         { ac_try='test -z "$ac_c_werror_flag"
11822 >         { ac_try='test -z "$ac_cxx_werror_flag"
11823                           || test ! -s conftest.err'
11824    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825    (eval $ac_try) 2>&5
# Line 7785 | Line 11832 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11832    ac_status=$?
11833    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834    (exit $ac_status); }; }; then
11835 <  ac_cv_c_const=yes
11835 >  ac_cv_cxx_have_fstream_open=yes
11836   else
11837    echo "$as_me: failed program was:" >&5
11838   sed 's/^/| /' conftest.$ac_ext >&5
11839  
7793 – ac_cv_c_const=no
11840   fi
11841   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11842 < fi
11843 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7798 < echo "${ECHO_T}$ac_cv_c_const" >&6
7799 < if test $ac_cv_c_const = no; then
7800 <
7801 < cat >>confdefs.h <<\_ACEOF
7802 < #define const
7803 < _ACEOF
7804 <
7805 < fi
7806 <
7807 < echo "$as_me:$LINENO: checking for inline" >&5
7808 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7809 < if test "${ac_cv_c_inline+set}" = set; then
7810 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7811 < else
7812 <  ac_cv_c_inline=no
7813 < for ac_kw in inline __inline__ __inline; do
7814 <  cat >conftest.$ac_ext <<_ACEOF
11842 >    # Try with mode parameter
11843 >    cat >conftest.$ac_ext <<_ACEOF
11844   /* confdefs.h.  */
11845   _ACEOF
11846   cat confdefs.h >>conftest.$ac_ext
11847   cat >>conftest.$ac_ext <<_ACEOF
11848   /* end confdefs.h.  */
11849 < #ifndef __cplusplus
11850 < typedef int foo_t;
11851 < static $ac_kw foo_t static_foo () {return 0; }
11852 < $ac_kw foo_t foo () {return 0; }
11849 >
11850 > #ifdef HAVE_IOSTREAM
11851 > #include <fstream>
11852 > #else
11853 > #include <fstream.h>
11854   #endif
11855 + #ifdef HAVE_STD_IOSTREAM
11856 + using namespace std;
11857 + #endif
11858  
11859 + #ifdef FC_DUMMY_MAIN
11860 + #ifndef FC_DUMMY_MAIN_EQ_F77
11861 + #  ifdef __cplusplus
11862 +     extern "C"
11863 + #  endif
11864 +   int FC_DUMMY_MAIN() { return 1; }
11865 + #endif
11866 + #endif
11867 + int
11868 + main ()
11869 + {
11870 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871 +  ;
11872 +  return 0;
11873 + }
11874   _ACEOF
11875   rm -f conftest.$ac_objext
11876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7833 | Line 11881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11881    cat conftest.err >&5
11882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883    (exit $ac_status); } &&
11884 <         { ac_try='test -z "$ac_c_werror_flag"
11884 >         { ac_try='test -z "$ac_cxx_werror_flag"
11885                           || test ! -s conftest.err'
11886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887    (eval $ac_try) 2>&5
# Line 7846 | Line 11894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11894    ac_status=$?
11895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896    (exit $ac_status); }; }; then
11897 <  ac_cv_c_inline=$ac_kw; break
11897 >  ac_cv_cxx_fstream_open_prot=yes
11898   else
11899    echo "$as_me: failed program was:" >&5
11900   sed 's/^/| /' conftest.$ac_ext >&5
11901  
11902   fi
11903   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904 < done
11904 >    ac_ext=cc
11905 > ac_cpp='$CXXCPP $CPPFLAGS'
11906 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909  
11910 +
11911   fi
11912 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
11913 < echo "${ECHO_T}$ac_cv_c_inline" >&6
11912 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11913 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11914 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11915  
11916 + cat >>confdefs.h <<\_ACEOF
11917 + #define HAVE_FSTREAM_OPEN 1
11918 + _ACEOF
11919  
11920 < case $ac_cv_c_inline in
11921 <  inline | yes) ;;
11922 <  *)
11923 <    case $ac_cv_c_inline in
11924 <      no) ac_val=;;
7868 <      *) ac_val=$ac_cv_c_inline;;
7869 <    esac
7870 <    cat >>confdefs.h <<_ACEOF
7871 < #ifndef __cplusplus
7872 < #define inline $ac_val
7873 < #endif
11920 >  fi
11921 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11922 >
11923 > cat >>confdefs.h <<\_ACEOF
11924 > #define FSTREAM_OPEN_PROT 1
11925   _ACEOF
7875 –    ;;
7876 – esac
11926  
11927 +  fi
11928  
11929  
7880 –  # clean out junk possibly left behind by a previous configuration
7881 –  rm -f src/getopt.h
7882 –  # Check for getopt_long support
11930  
11931 < for ac_header in getopt.h
11931 >
11932 >
11933 >
11934 >
11935 > for ac_header in ctype.h iostream fstream sstream strstream
11936   do
11937   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11938   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7914 | Line 11965 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11965    cat conftest.err >&5
11966    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11967    (exit $ac_status); } &&
11968 <         { ac_try='test -z "$ac_c_werror_flag"
11968 >         { ac_try='test -z "$ac_cxx_werror_flag"
11969                           || test ! -s conftest.err'
11970    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11971    (eval $ac_try) 2>&5
# Line 7958 | Line 12009 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
12009    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010    (exit $ac_status); } >/dev/null; then
12011    if test -s conftest.err; then
12012 <    ac_cpp_err=$ac_c_preproc_warn_flag
12013 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
12012 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
12013 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12014    else
12015      ac_cpp_err=
12016    fi
# Line 7979 | Line 12030 | echo "${ECHO_T}$ac_header_preproc" >&6
12030   echo "${ECHO_T}$ac_header_preproc" >&6
12031  
12032   # So?  What about this header?
12033 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12033 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12034    yes:no: )
12035      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12036   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 8030 | Line 12081 | done
12081  
12082   done
12083  
12084 + # AC_CPP_FUNC
12085 + # ------------------ #
12086 + # Checks to see if ANSI C99 CPP variable __func__ works.
12087 + # If not, perhaps __FUNCTION__ works instead.
12088 + # If not, we'll just define __func__ to "".
12089 + # AC_CPP_FUNC
12090  
12091 < for ac_func in getopt_long
12092 < do
12093 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12094 < echo "$as_me:$LINENO: checking for $ac_func" >&5
8038 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8039 < if eval "test \"\${$as_ac_var+set}\" = set"; then
12091 >
12092 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12093 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12094 > if test "${ac_cv_cpp_func+set}" = set; then
12095    echo $ECHO_N "(cached) $ECHO_C" >&6
12096   else
12097    cat >conftest.$ac_ext <<_ACEOF
# Line 8045 | Line 12100 | cat >>conftest.$ac_ext <<_ACEOF
12100   cat confdefs.h >>conftest.$ac_ext
12101   cat >>conftest.$ac_ext <<_ACEOF
12102   /* end confdefs.h.  */
8048 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8049 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8050 – #define $ac_func innocuous_$ac_func
12103  
12104 < /* System header to define __stub macros and hopefully few prototypes,
12105 <    which can conflict with char $ac_func (); below.
12106 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12107 <    <limits.h> exists even on freestanding compilers.  */
12108 <
12109 < #ifdef __STDC__
8058 < # include <limits.h>
8059 < #else
8060 < # include <assert.h>
8061 < #endif
8062 <
8063 < #undef $ac_func
8064 <
8065 < /* Override any gcc2 internal prototype to avoid an error.  */
8066 < #ifdef __cplusplus
8067 < extern "C"
8068 < {
12104 > #ifdef FC_DUMMY_MAIN
12105 > #ifndef FC_DUMMY_MAIN_EQ_F77
12106 > #  ifdef __cplusplus
12107 >     extern "C"
12108 > #  endif
12109 >   int FC_DUMMY_MAIN() { return 1; }
12110   #endif
8070 – /* We use char because int might match the return type of a gcc2
8071 –   builtin and then its argument prototype would still apply.  */
8072 – char $ac_func ();
8073 – /* The GNU C library defines this for functions which it implements
8074 –    to always fail with ENOSYS.  Some functions are actually named
8075 –    something starting with __ and the normal name is an alias.  */
8076 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8077 – choke me
8078 – #else
8079 – char (*f) () = $ac_func;
12111   #endif
8081 – #ifdef __cplusplus
8082 – }
8083 – #endif
8084 –
12112   int
12113   main ()
12114   {
12115 < return f != $ac_func;
12115 > const char *foo = __func__;
12116    ;
12117    return 0;
12118   }
12119   _ACEOF
12120 < rm -f conftest.$ac_objext conftest$ac_exeext
12121 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12122 <  (eval $ac_link) 2>conftest.er1
12120 > rm -f conftest.$ac_objext
12121 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12122 >  (eval $ac_compile) 2>conftest.er1
12123    ac_status=$?
12124    grep -v '^ *+' conftest.er1 >conftest.err
12125    rm -f conftest.er1
12126    cat conftest.err >&5
12127    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12128    (exit $ac_status); } &&
12129 <         { ac_try='test -z "$ac_c_werror_flag"
12129 >         { ac_try='test -z "$ac_cxx_werror_flag"
12130                           || test ! -s conftest.err'
12131    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12132    (eval $ac_try) 2>&5
12133    ac_status=$?
12134    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12135    (exit $ac_status); }; } &&
12136 <         { ac_try='test -s conftest$ac_exeext'
12136 >         { ac_try='test -s conftest.$ac_objext'
12137    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12138    (eval $ac_try) 2>&5
12139    ac_status=$?
12140    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12141    (exit $ac_status); }; }; then
12142 <  eval "$as_ac_var=yes"
12142 >  ac_cv_cpp_func=yes
12143   else
12144    echo "$as_me: failed program was:" >&5
12145   sed 's/^/| /' conftest.$ac_ext >&5
12146  
8120 – eval "$as_ac_var=no"
8121 – fi
8122 – rm -f conftest.err conftest.$ac_objext \
8123 –      conftest$ac_exeext conftest.$ac_ext
8124 – fi
8125 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8126 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8127 – if test `eval echo '${'$as_ac_var'}'` = yes; then
8128 –  cat >>confdefs.h <<_ACEOF
8129 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8130 – _ACEOF
8131 –
8132 – else
8133 –  # FreeBSD has a gnugetopt library for this
8134 –    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
8135 – echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
8136 – if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
8137 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8138 – else
8139 –  ac_check_lib_save_LIBS=$LIBS
8140 – LIBS="-lgnugetopt  $LIBS"
12147   cat >conftest.$ac_ext <<_ACEOF
12148   /* confdefs.h.  */
12149   _ACEOF
# Line 8145 | Line 12151 | cat >>conftest.$ac_ext <<_ACEOF
12151   cat >>conftest.$ac_ext <<_ACEOF
12152   /* end confdefs.h.  */
12153  
12154 < /* Override any gcc2 internal prototype to avoid an error.  */
12155 < #ifdef __cplusplus
12156 < extern "C"
12154 > #ifdef FC_DUMMY_MAIN
12155 > #ifndef FC_DUMMY_MAIN_EQ_F77
12156 > #  ifdef __cplusplus
12157 >     extern "C"
12158 > #  endif
12159 >   int FC_DUMMY_MAIN() { return 1; }
12160   #endif
12161 < /* We use char because int might match the return type of a gcc2
8153 <   builtin and then its argument prototype would still apply.  */
8154 < char getopt_long ();
12161 > #endif
12162   int
12163   main ()
12164   {
12165 < getopt_long ();
12165 > const char *foo = __FUNCTION__;
12166    ;
12167    return 0;
12168   }
12169   _ACEOF
12170 < rm -f conftest.$ac_objext conftest$ac_exeext
12171 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12172 <  (eval $ac_link) 2>conftest.er1
12170 > rm -f conftest.$ac_objext
12171 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12172 >  (eval $ac_compile) 2>conftest.er1
12173    ac_status=$?
12174    grep -v '^ *+' conftest.er1 >conftest.err
12175    rm -f conftest.er1
12176    cat conftest.err >&5
12177    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12178    (exit $ac_status); } &&
12179 <         { ac_try='test -z "$ac_c_werror_flag"
12179 >         { ac_try='test -z "$ac_cxx_werror_flag"
12180                           || test ! -s conftest.err'
12181    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12182    (eval $ac_try) 2>&5
12183    ac_status=$?
12184    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12185    (exit $ac_status); }; } &&
12186 <         { ac_try='test -s conftest$ac_exeext'
12186 >         { ac_try='test -s conftest.$ac_objext'
12187    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12188    (eval $ac_try) 2>&5
12189    ac_status=$?
12190    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12191    (exit $ac_status); }; }; then
12192 <  ac_cv_lib_gnugetopt_getopt_long=yes
12192 >  ac_cv_cpp_func=__FUNCTION__
12193   else
12194    echo "$as_me: failed program was:" >&5
12195   sed 's/^/| /' conftest.$ac_ext >&5
12196  
12197 < ac_cv_lib_gnugetopt_getopt_long=no
12197 > ac_cv_cpp_func=no
12198   fi
12199 < rm -f conftest.err conftest.$ac_objext \
8193 <      conftest$ac_exeext conftest.$ac_ext
8194 < LIBS=$ac_check_lib_save_LIBS
12199 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12200   fi
12201 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12202 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
12203 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12204 <  cat >>confdefs.h <<\_ACEOF
12205 < #define HAVE_GETOPT_LONG 1
12201 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12202 > fi
12203 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12204 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
12205 > if test $ac_cv_cpp_func = __FUNCTION__; then
12206 >
12207 > cat >>confdefs.h <<\_ACEOF
12208 > #define __func__ __FUNCTION__
12209   _ACEOF
12210  
12211 < else
8204 <  # use the GNU replacement
8205 <      case $LIBOBJS in
8206 <    "getopt.$ac_objext"   | \
8207 <  *" getopt.$ac_objext"   | \
8208 <    "getopt.$ac_objext "* | \
8209 <  *" getopt.$ac_objext "* ) ;;
8210 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
8211 < esac
12211 > elif test $ac_cv_cpp_func = no; then
12212  
12213 <      case $LIBOBJS in
12214 <    "getopt1.$ac_objext"   | \
12215 <  *" getopt1.$ac_objext"   | \
8216 <    "getopt1.$ac_objext "* | \
8217 <  *" getopt1.$ac_objext "* ) ;;
8218 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
8219 < esac
8220 <
8221 <                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
12213 > cat >>confdefs.h <<\_ACEOF
12214 > #define __func__ ""
12215 > _ACEOF
12216  
12217   fi
12218  
8225 – fi
8226 – done
12219  
12220  
12221  
12222 +
12223   case $debug in
12224    1)
12225       ;;
# Line 8235 | Line 12228 | case $debug in
12228  
12229  
12230  
12231 + # Try to determine "good" native compiler flags if none specified on command
12232 + # line
12233  
12234 + if test "$ac_test_FFLAGS" != "set"; then
12235 +  FCFLAGS=""
12236 +  case "${host_cpu}-${host_os}" in
12237  
12238 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12239 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
12240 +                fi;;
12241 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12242 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12243 +                fi;;
12244 +   powerpc*-aix*)
12245 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12246 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12247 +                echo "*******************************************************"
12248 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12249 +                echo "*  recommended that you use                           *"
12250 +                echo "*                                                     *"
12251 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12252 +                echo "*                                 ^^^                 *"
12253 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12254 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12255 +                echo "*******************************************************"
12256 +        fi;;
12257 +   *darwin*)
12258 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12259 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12260 +        fi
12261 +        if test "$FC" = ifort; then
12262 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12263 +        fi;;
12264 +  esac
12265 +
12266 +  if test -n "$CPU_FLAGS"; then
12267 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12268 +  fi
12269 +
12270 +  if test -z "$FCFLAGS"; then
12271 +        echo ""
12272 +        echo "*********************************************************"
12273 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12274 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12275 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12276 +        echo "*********************************************************"
12277 +        echo ""
12278 +        FCFLAGS="-O3"
12279 +  fi
12280 +
12281 +
12282 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12283 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12284 + if test "${ac_guessed_f90flags+set}" = set; then
12285 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12286 + else
12287 +
12288 +
12289 +
12290 + ac_ext=${FC_SRCEXT-f}
12291 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12292 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12293 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12294 +
12295 + echo 'program main' > conftest.$ac_ext
12296 + echo 'end program main' >> conftest.$ac_ext
12297 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12298 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12299 +  (eval $ac_compile) 2>&5
12300 +  ac_status=$?
12301 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12302 +  (exit $ac_status); }; then
12303 +        ac_guessed_f90flags=yes
12304 + else
12305 +        ac_guessed_f90flags=no
12306 + fi
12307 + rm -f conftest*
12308 + ac_ext=cc
12309 + ac_cpp='$CXXCPP $CPPFLAGS'
12310 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12311 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12312 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12313 +
12314 +
12315 + fi
12316 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12317 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12318 + if test "$ac_guessed_f90flags" = yes; then
12319 +        :
12320 +
12321 + else
12322 +        :
12323 +
12324 +        echo ""
12325 +        echo "**********************************************************"
12326 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12327 +        echo "* your compiler.                                        *"
12328 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12329 +        echo "*********************************************************"
12330 +        echo ""
12331 +        FCFLAGS=""
12332 +
12333 + fi
12334 +
12335 +
12336 + fi
12337 +
12338 +
12339 +
12340 +
12341 +
12342 +
12343 +
12344   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12345   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12346   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 8285 | Line 12389 | if test "$ac_test_CFLAGS" != "set"; then
12389                      CFLAGS="-O"
12390                  fi;;
12391    sparc-solaris2*) if test "$CC" = cc; then
12392 <                    CFLAGS="-native -fast -xO5 -dalign"
12392 >                    CFLAGS="-O -dalign"
12393                   fi;;
12394  
12395    alpha*-osf*)  if test "$CC" = cc; then
# Line 8315 | Line 12419 | if test "$ac_test_CFLAGS" != "set"; then
12419     *darwin*)
12420          if test "$CC" = xlc -o "$CC" = cc; then
12421                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12422 +        fi
12423 +        if test "$CC" = icc; then
12424 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12425          fi;;
12426    esac
12427  
# Line 8328 | Line 12435 | if test "$ac_test_CFLAGS" != "set"; then
12435      # -malign-double for x86 systems
12436  
12437  
12438 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12439 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12438 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12439 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12440   if test "${ac_align_double+set}" = set; then
12441    echo $ECHO_N "(cached) $ECHO_C" >&6
12442   else
12443    echo 'void f(){}' > conftest.c
12444 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12444 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12445          ac_align_double=yes
12446   else
12447          ac_align_double=no
# Line 8355 | Line 12462 | fi
12462      # -fstrict-aliasing for gcc-2.95+
12463  
12464  
12465 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12466 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12465 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12466 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12467   if test "${ac_fstrict_aliasing+set}" = set; then
12468    echo $ECHO_N "(cached) $ECHO_C" >&6
12469   else
12470    echo 'void f(){}' > conftest.c
12471 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12471 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12472          ac_fstrict_aliasing=yes
12473   else
12474          ac_fstrict_aliasing=no
# Line 8386 | Line 12493 | fi
12493                    case "${host_cpu}" in
12494            i586*)
12495  
12496 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12497 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12496 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12497 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12498   if test "${ac_cpu_pentium+set}" = set; then
12499    echo $ECHO_N "(cached) $ECHO_C" >&6
12500   else
12501    echo 'void f(){}' > conftest.c
12502 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12502 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12503          ac_cpu_pentium=yes
12504   else
12505          ac_cpu_pentium=no
# Line 8409 | Line 12516 | else
12516          :
12517  
12518  
12519 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12520 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12519 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12520 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12521   if test "${ac_pentium+set}" = set; then
12522    echo $ECHO_N "(cached) $ECHO_C" >&6
12523   else
12524    echo 'void f(){}' > conftest.c
12525 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12525 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12526          ac_pentium=yes
12527   else
12528          ac_pentium=no
# Line 8438 | Line 12545 | fi
12545                    ;;
12546            i686*)
12547  
12548 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12549 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12548 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12549 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12550   if test "${ac_cpu_pentiumpro+set}" = set; then
12551    echo $ECHO_N "(cached) $ECHO_C" >&6
12552   else
12553    echo 'void f(){}' > conftest.c
12554 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12554 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12555          ac_cpu_pentiumpro=yes
12556   else
12557          ac_cpu_pentiumpro=no
# Line 8461 | Line 12568 | else
12568          :
12569  
12570  
12571 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12572 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12571 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12572 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12573   if test "${ac_pentiumpro+set}" = set; then
12574    echo $ECHO_N "(cached) $ECHO_C" >&6
12575   else
12576    echo 'void f(){}' > conftest.c
12577 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12577 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12578          ac_pentiumpro=yes
12579   else
12580          ac_pentiumpro=no
# Line 8494 | Line 12601 | fi
12601                  if test -n "$is60x"; then
12602  
12603  
12604 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12605 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12604 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12605 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12606   if test "${ac_m_cpu_60x+set}" = set; then
12607    echo $ECHO_N "(cached) $ECHO_C" >&6
12608   else
12609    echo 'void f(){}' > conftest.c
12610 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12610 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12611          ac_m_cpu_60x=yes
12612   else
12613          ac_m_cpu_60x=no
# Line 8552 | Line 12659 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12659          :
12660  
12661  
12662 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12663 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12662 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12663 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12664   if test "${ac_m_cpu_750+set}" = set; then
12665    echo $ECHO_N "(cached) $ECHO_C" >&6
12666   else
12667    echo 'void f(){}' > conftest.c
12668 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12668 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12669          ac_m_cpu_750=yes
12670   else
12671          ac_m_cpu_750=no
# Line 8585 | Line 12692 | fi
12692                  if test -z "$CPU_FLAGS"; then
12693  
12694  
12695 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12696 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12695 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12696 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12697   if test "${ac_m_cpu_powerpc+set}" = set; then
12698    echo $ECHO_N "(cached) $ECHO_C" >&6
12699   else
12700    echo 'void f(){}' > conftest.c
12701 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12701 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12702          ac_m_cpu_powerpc=yes
12703   else
12704          ac_m_cpu_powerpc=no
# Line 8613 | Line 12720 | fi
12720                  if test -z "$CPU_FLAGS"; then
12721  
12722  
12723 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12724 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12723 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12724 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12725   if test "${ac_m_powerpc+set}" = set; then
12726    echo $ECHO_N "(cached) $ECHO_C" >&6
12727   else
12728    echo 'void f(){}' > conftest.c
12729 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12729 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12730          ac_m_powerpc=yes
12731   else
12732          ac_m_powerpc=no
# Line 8658 | Line 12765 | fi
12765  
12766  
12767  
12768 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12769 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12768 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12769 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12770   if test "${ac_guessed_cflags+set}" = set; then
12771    echo $ECHO_N "(cached) $ECHO_C" >&6
12772   else
12773    echo 'void f(){}' > conftest.c
12774 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12774 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12775          ac_guessed_cflags=yes
12776   else
12777          ac_guessed_cflags=no
# Line 8748 | Line 12855 | if test "$ac_test_CXXFLAGS" != "set"; then
12855                      CXXFLAGS="-O"
12856                  fi;;
12857    sparc-solaris2*) if test "$CXX" = CC; then
12858 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12858 >                    CXXFLAGS="-features=extensions -O -dalign"
12859                   fi;;
12860     rs6000*-aix*)  if test "$CXX" = xlC; then
12861                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8769 | Line 12876 | if test "$ac_test_CXXFLAGS" != "set"; then
12876     *darwin*)
12877          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12878                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12879 +        fi
12880 +        if test "$CXX" = icpc; then
12881 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12882          fi;;
12883    esac
12884  
# Line 8782 | Line 12892 | if test "$ac_test_CXXFLAGS" != "set"; then
12892      # -malign-double for x86 systems
12893  
12894  
12895 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12896 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12895 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12896 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12897   if test "${ac_align_double+set}" = set; then
12898    echo $ECHO_N "(cached) $ECHO_C" >&6
12899   else
12900    echo 'void f(){}' > conftest.cpp
12901 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12901 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12902          ac_align_double=yes
12903   else
12904          ac_align_double=no
# Line 8809 | Line 12919 | fi
12919      # -fstrict-aliasing for gcc-2.95+
12920  
12921  
12922 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12923 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12922 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12923 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12924   if test "${ac_fstrict_aliasing+set}" = set; then
12925    echo $ECHO_N "(cached) $ECHO_C" >&6
12926   else
12927    echo 'void f(){}' > conftest.cpp
12928 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12928 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12929          ac_fstrict_aliasing=yes
12930   else
12931          ac_fstrict_aliasing=no
# Line 8840 | Line 12950 | fi
12950                    case "${host_cpu}" in
12951            i586*)
12952  
12953 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12954 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12953 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12954 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12955   if test "${ac_cpu_pentium+set}" = set; then
12956    echo $ECHO_N "(cached) $ECHO_C" >&6
12957   else
12958    echo 'void f(){}' > conftest.cpp
12959 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12959 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12960          ac_cpu_pentium=yes
12961   else
12962          ac_cpu_pentium=no
# Line 8863 | Line 12973 | else
12973          :
12974  
12975  
12976 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12977 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12976 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12977 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12978   if test "${ac_pentium+set}" = set; then
12979    echo $ECHO_N "(cached) $ECHO_C" >&6
12980   else
12981    echo 'void f(){}' > conftest.cpp
12982 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12982 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12983          ac_pentium=yes
12984   else
12985          ac_pentium=no
# Line 8892 | Line 13002 | fi
13002                    ;;
13003            i686*)
13004  
13005 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13006 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13005 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13006 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13007   if test "${ac_cpu_pentiumpro+set}" = set; then
13008    echo $ECHO_N "(cached) $ECHO_C" >&6
13009   else
13010    echo 'void f(){}' > conftest.cpp
13011 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13011 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13012          ac_cpu_pentiumpro=yes
13013   else
13014          ac_cpu_pentiumpro=no
# Line 8915 | Line 13025 | else
13025          :
13026  
13027  
13028 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13029 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13028 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13029 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13030   if test "${ac_pentiumpro+set}" = set; then
13031    echo $ECHO_N "(cached) $ECHO_C" >&6
13032   else
13033    echo 'void f(){}' > conftest.cpp
13034 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13034 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13035          ac_pentiumpro=yes
13036   else
13037          ac_pentiumpro=no
# Line 8948 | Line 13058 | fi
13058                  if test -n "$is60x"; then
13059  
13060  
13061 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13062 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13061 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063   if test "${ac_m_cpu_60x+set}" = set; then
13064    echo $ECHO_N "(cached) $ECHO_C" >&6
13065   else
13066    echo 'void f(){}' > conftest.cpp
13067 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13067 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068          ac_m_cpu_60x=yes
8959 – else
8960 –        ac_m_cpu_60x=no
8961 – fi
8962 – rm -f conftest*
8963 –
8964 – fi
8965 – echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
8966 – echo "${ECHO_T}$ac_m_cpu_60x" >&6
8967 – if test "$ac_m_cpu_60x" = yes; then
8968 –        :
8969 –        CPU_FLAGS=-mcpu=$cputype
8970 – else
8971 –        :
8972 –
8973 – fi
8974 –
8975 –                elif test "$cputype" = 750; then
8976 –
8977 –
8978 – echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
8979 – echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
8980 – if test "${ac_cv_prog_gxx_2_95+set}" = set; then
8981 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8982 – else
8983 –
8984 – cat > conftest.cpp <<EOF
8985 – #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8986 – #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8987 –     yes;
8988 – #  endif
8989 – #endif
8990 – EOF
8991 – if { ac_try='${CXX-c++} -E conftest.cpp'
8992 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8993 –  (eval $ac_try) 2>&5
8994 –  ac_status=$?
8995 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8996 –  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8997 –  ac_cv_prog_gxx_2_95=yes
8998 – else
8999 –  ac_cv_prog_gxx_2_95=no
9000 – fi
9001 –
9002 – fi
9003 – echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
9004 – echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
9005 – if test "$ac_cv_prog_gxx_2_95" = yes; then
9006 –        :
9007 –
9008 –
9009 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
9010 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
9011 – if test "${ac_m_cpu_750+set}" = set; then
9012 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9013 – else
9014 –  echo 'void f(){}' > conftest.cpp
9015 – if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
9016 –        ac_m_cpu_750=yes
9017 – else
9018 –        ac_m_cpu_750=no
9019 – fi
9020 – rm -f conftest*
9021 –
9022 – fi
9023 – echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
9024 – echo "${ECHO_T}$ac_m_cpu_750" >&6
9025 – if test "$ac_m_cpu_750" = yes; then
9026 –        :
9027 –        CPU_FLAGS=-mcpu=750
9028 – else
9029 –        :
9030 –
9031 – fi
9032 –
9033 – else
9034 –        :
9035 –
9036 – fi
9037 –
9038 –                fi
9039 –                if test -z "$CPU_FLAGS"; then
9040 –
9041 –
9042 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
9043 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
9044 – if test "${ac_m_cpu_powerpc+set}" = set; then
9045 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9046 – else
9047 –  echo 'void f(){}' > conftest.cpp
9048 – if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
9049 –        ac_m_cpu_powerpc=yes
9050 – else
9051 –        ac_m_cpu_powerpc=no
9052 – fi
9053 – rm -f conftest*
9054 –
9055 – fi
9056 – echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
9057 – echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
9058 – if test "$ac_m_cpu_powerpc" = yes; then
9059 –        :
9060 –        CPU_FLAGS=-mcpu=powerpc
9061 – else
9062 –        :
9063 –
9064 – fi
9065 –
9066 –                fi
9067 –                if test -z "$CPU_FLAGS"; then
9068 –
9069 –
9070 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
9071 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
9072 – if test "${ac_m_powerpc+set}" = set; then
9073 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9074 – else
9075 –  echo 'void f(){}' > conftest.cpp
9076 – if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
9077 –        ac_m_powerpc=yes
9078 – else
9079 –        ac_m_powerpc=no
9080 – fi
9081 – rm -f conftest*
9082 –
9083 – fi
9084 – echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
9085 – echo "${ECHO_T}$ac_m_powerpc" >&6
9086 – if test "$ac_m_powerpc" = yes; then
9087 –        :
9088 –        CPU_FLAGS=-mpowerpc
9089 – else
9090 –        :
9091 –
9092 – fi
9093 –
9094 –                fi
9095 –          esac
9096 –  fi
9097 –
9098 –  if test -n "$CPU_FLAGS"; then
9099 –        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
9100 –  fi
9101 –
9102 –  if test -z "$CXXFLAGS"; then
9103 –        echo ""
9104 –        echo "**********************************************************"
9105 –        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
9106 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9107 –        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
9108 –        echo "**********************************************************"
9109 –        echo ""
9110 –        CXXFLAGS="-O3"
9111 –  fi
9112 –
9113 –
9114 –
9115 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
9116 – echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
9117 – if test "${ac_guessed_cxxflags+set}" = set; then
9118 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9119 – else
9120 –  echo 'void f(){}' > conftest.cpp
9121 – if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
9122 –        ac_guessed_cxxflags=yes
9123 – else
9124 –        ac_guessed_cxxflags=no
9125 – fi
9126 – rm -f conftest*
9127 –
9128 – fi
9129 – echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
9130 – echo "${ECHO_T}$ac_guessed_cxxflags" >&6
9131 – if test "$ac_guessed_cxxflags" = yes; then
9132 –        :
9133 –
9134 – else
9135 –        :
9136 –
9137 –        echo ""
9138 –        echo "**********************************************************"
9139 –        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
9140 –        echo "* your compiler.                                         *"
9141 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9142 –        echo "**********************************************************"
9143 –        echo ""
9144 –        CXXFLAGS=""
9145 –
9146 – fi
9147 –
9148 –
9149 – fi
9150 –
9151 –
9152 –
9153 –
9154 –
9155 – # Try to determine "good" native compiler flags if none specified on command
9156 – # line
9157 –
9158 – if test x"$F90FLAGS" = x ; then
9159 –  F90FLAGS=""
9160 –  case "${host_cpu}-${host_os}" in
9161 –
9162 –  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
9163 –                    F90FLAGS="-O"
9164 –                fi;;
9165 –   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
9166 –                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
9167 –                fi;;
9168 –   powerpc*-aix*)
9169 –        if test "$F90" = f90 -o "$F90" = xlf90; then
9170 –                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
9171 –                echo "*******************************************************"
9172 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
9173 –                echo "*  recommended that you use                           *"
9174 –                echo "*                                                     *"
9175 –                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
9176 –                echo "*                                 ^^^                 *"
9177 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
9178 –                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
9179 –                echo "*******************************************************"
9180 –        fi;;
9181 –   *darwin*)
9182 –        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
9183 –                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
9184 –        fi;;
9185 –  esac
9186 –
9187 –  if test -n "$CPU_FLAGS"; then
9188 –        F90FLAGS="$F90FLAGS $CPU_FLAGS"
9189 –  fi
9190 –
9191 –  if test -z "$F90FLAGS"; then
9192 –        echo ""
9193 –        echo "**********************************************************"
9194 –        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
9195 –        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9196 –        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
9197 –        echo "**********************************************************"
9198 –        echo ""
9199 –        F90FLAGS="-O3"
9200 –  fi
9201 –
9202 –
9203 – echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
9204 – echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
9205 – if test "${ac_guessed_f90flags+set}" = set; then
9206 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9207 – else
9208 –
9209 –
9210 –
9211 – ac_ext=f90
9212 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
9213 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9214 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
9215 –
9216 – echo 'program main' > conftest.$ac_ext
9217 – echo 'end program main' >> conftest.$ac_ext
9218 – ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
9219 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9220 –  (eval $ac_compile) 2>&5
9221 –  ac_status=$?
9222 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9223 –  (exit $ac_status); }; then
9224 –        ac_guessed_f90flags=yes
9225 – else
9226 –        ac_guessed_f90flags=no
9227 – fi
9228 – rm -f conftest*
9229 – ac_ext=c
9230 – ac_cpp='$CPP $CPPFLAGS'
9231 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9232 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9233 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
9234 –
9235 –
9236 – fi
9237 – echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
9238 – echo "${ECHO_T}$ac_guessed_f90flags" >&6
9239 – if test "$ac_guessed_f90flags" = yes; then
9240 –        :
9241 –
9242 – else
9243 –        :
9244 –
9245 –        echo ""
9246 –        echo "**********************************************************"
9247 –        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
9248 –        echo "* your compiler.                                         *"
9249 –        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9250 –        echo "**********************************************************"
9251 –        echo ""
9252 –        F90FLAGS=""
9253 –
9254 – fi
9255 –
9256 –
9257 – fi
9258 –
9259 –     ;;
9260 – esac
9261 –
9262 – # Find a good install program.  We prefer a C program (faster),
9263 – # so one script is as good as another.  But avoid the broken or
9264 – # incompatible versions:
9265 – # SysV /etc/install, /usr/sbin/install
9266 – # SunOS /usr/etc/install
9267 – # IRIX /sbin/install
9268 – # AIX /bin/install
9269 – # AmigaOS /C/install, which installs bootblocks on floppy discs
9270 – # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
9271 – # AFS /usr/afsws/bin/install, which mishandles nonexistent args
9272 – # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
9273 – # OS/2's system install, which has a completely different semantic
9274 – # ./install, which can be erroneously created by make from ./install.sh.
9275 – echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
9276 – echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
9277 – if test -z "$INSTALL"; then
9278 – if test "${ac_cv_path_install+set}" = set; then
9279 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9280 – else
9281 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9282 – for as_dir in $PATH
9283 – do
9284 –  IFS=$as_save_IFS
9285 –  test -z "$as_dir" && as_dir=.
9286 –  # Account for people who put trailing slashes in PATH elements.
9287 – case $as_dir/ in
9288 –  ./ | .// | /cC/* | \
9289 –  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
9290 –  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
9291 –  /usr/ucb/* ) ;;
9292 –  *)
9293 –    # OSF1 and SCO ODT 3.0 have their own names for install.
9294 –    # Don't use installbsd from OSF since it installs stuff as root
9295 –    # by default.
9296 –    for ac_prog in ginstall scoinst install; do
9297 –      for ac_exec_ext in '' $ac_executable_extensions; do
9298 –        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
9299 –          if test $ac_prog = install &&
9300 –            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9301 –            # AIX install.  It has an incompatible calling convention.
9302 –            :
9303 –          elif test $ac_prog = install &&
9304 –            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9305 –            # program-specific install script used by HP pwplus--don't use.
9306 –            :
9307 –          else
9308 –            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
9309 –            break 3
9310 –          fi
9311 –        fi
9312 –      done
9313 –    done
9314 –    ;;
9315 – esac
9316 – done
9317 –
9318 –
9319 – fi
9320 –  if test "${ac_cv_path_install+set}" = set; then
9321 –    INSTALL=$ac_cv_path_install
9322 –  else
9323 –    # As a last resort, use the slow shell script.  We don't cache a
9324 –    # path for INSTALL within a source directory, because that will
9325 –    # break other packages using the cache if that directory is
9326 –    # removed, or if the path is relative.
9327 –    INSTALL=$ac_install_sh
9328 –  fi
9329 – fi
9330 – echo "$as_me:$LINENO: result: $INSTALL" >&5
9331 – echo "${ECHO_T}$INSTALL" >&6
9332 –
9333 – # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
9334 – # It thinks the first close brace ends the variable substitution.
9335 – test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
9336 –
9337 – test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
9338 –
9339 – test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
9340 –
9341 – echo "$as_me:$LINENO: checking whether ln -s works" >&5
9342 – echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
9343 – LN_S=$as_ln_s
9344 – if test "$LN_S" = "ln -s"; then
9345 –  echo "$as_me:$LINENO: result: yes" >&5
9346 – echo "${ECHO_T}yes" >&6
13069   else
13070 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
9349 < echo "${ECHO_T}no, using $LN_S" >&6
13070 >        ac_m_cpu_60x=no
13071   fi
13072 + rm -f conftest*
13073  
9352 – echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
9353 – echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
9354 – set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
9355 – if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
9356 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9357 – else
9358 –  cat >conftest.make <<\_ACEOF
9359 – all:
9360 –        @echo 'ac_maketemp="$(MAKE)"'
9361 – _ACEOF
9362 – # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
9363 – eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
9364 – if test -n "$ac_maketemp"; then
9365 –  eval ac_cv_prog_make_${ac_make}_set=yes
9366 – else
9367 –  eval ac_cv_prog_make_${ac_make}_set=no
13074   fi
13075 < rm -f conftest.make
13076 < fi
13077 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
13078 <  echo "$as_me:$LINENO: result: yes" >&5
13079 < echo "${ECHO_T}yes" >&6
9374 <  SET_MAKE=
13075 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
13076 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
13077 > if test "$ac_m_cpu_60x" = yes; then
13078 >        :
13079 >        CPU_FLAGS=-mcpu=$cputype
13080   else
13081 <  echo "$as_me:$LINENO: result: no" >&5
13082 < echo "${ECHO_T}no" >&6
9378 <  SET_MAKE="MAKE=${MAKE-make}"
13081 >        :
13082 >
13083   fi
13084  
13085 < if test -n "$ac_tool_prefix"; then
13086 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
13087 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
13088 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13089 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13090 < if test "${ac_cv_prog_RANLIB+set}" = set; then
13085 >                elif test "$cputype" = 750; then
13086 >
13087 >
13088 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
13089 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
13090 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
13091    echo $ECHO_N "(cached) $ECHO_C" >&6
13092   else
9389 –  if test -n "$RANLIB"; then
9390 –  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
9391 – else
9392 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9393 – for as_dir in $PATH
9394 – do
9395 –  IFS=$as_save_IFS
9396 –  test -z "$as_dir" && as_dir=.
9397 –  for ac_exec_ext in '' $ac_executable_extensions; do
9398 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9399 –    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
9400 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9401 –    break 2
9402 –  fi
9403 – done
9404 – done
13093  
13094 < fi
13095 < fi
13096 < RANLIB=$ac_cv_prog_RANLIB
13097 < if test -n "$RANLIB"; then
13098 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
13099 < echo "${ECHO_T}$RANLIB" >&6
13094 > cat > conftest.cpp <<EOF
13095 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
13096 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
13097 >     yes;
13098 > #  endif
13099 > #endif
13100 > EOF
13101 > if { ac_try='${CXX-c++} -E conftest.cpp'
13102 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13103 >  (eval $ac_try) 2>&5
13104 >  ac_status=$?
13105 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13106 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13107 >  ac_cv_prog_gxx_2_95=yes
13108   else
13109 <  echo "$as_me:$LINENO: result: no" >&5
9414 < echo "${ECHO_T}no" >&6
13109 >  ac_cv_prog_gxx_2_95=no
13110   fi
13111  
13112   fi
13113 < if test -z "$ac_cv_prog_RANLIB"; then
13114 <  ac_ct_RANLIB=$RANLIB
13115 <  # Extract the first word of "ranlib", so it can be a program name with args.
13116 < set dummy ranlib; ac_word=$2
13117 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13118 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13119 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
13113 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
13114 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
13115 > if test "$ac_cv_prog_gxx_2_95" = yes; then
13116 >        :
13117 >
13118 >
13119 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121 > if test "${ac_m_cpu_750+set}" = set; then
13122    echo $ECHO_N "(cached) $ECHO_C" >&6
13123   else
13124 <  if test -n "$ac_ct_RANLIB"; then
13125 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
13124 >  echo 'void f(){}' > conftest.cpp
13125 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126 >        ac_m_cpu_750=yes
13127   else
13128 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13129 < for as_dir in $PATH
13130 < do
9433 <  IFS=$as_save_IFS
9434 <  test -z "$as_dir" && as_dir=.
9435 <  for ac_exec_ext in '' $ac_executable_extensions; do
9436 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9437 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
9438 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9439 <    break 2
9440 <  fi
9441 < done
9442 < done
13128 >        ac_m_cpu_750=no
13129 > fi
13130 > rm -f conftest*
13131  
9444 –  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
13132   fi
13133 < fi
13134 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
13135 < if test -n "$ac_ct_RANLIB"; then
13136 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
13137 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
13133 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13134 > echo "${ECHO_T}$ac_m_cpu_750" >&6
13135 > if test "$ac_m_cpu_750" = yes; then
13136 >        :
13137 >        CPU_FLAGS=-mcpu=750
13138   else
13139 <  echo "$as_me:$LINENO: result: no" >&5
13140 < echo "${ECHO_T}no" >&6
13139 >        :
13140 >
13141   fi
13142  
9456 –  RANLIB=$ac_ct_RANLIB
13143   else
13144 <  RANLIB="$ac_cv_prog_RANLIB"
13144 >        :
13145 >
13146   fi
13147  
13148 < for ac_prog in 'bison -y' byacc
13149 < do
13150 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13151 < set dummy $ac_prog; ac_word=$2
13152 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13153 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13154 < if test "${ac_cv_prog_YACC+set}" = set; then
13148 >                fi
13149 >                if test -z "$CPU_FLAGS"; then
13150 >
13151 >
13152 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13153 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13154 > if test "${ac_m_cpu_powerpc+set}" = set; then
13155    echo $ECHO_N "(cached) $ECHO_C" >&6
13156   else
13157 <  if test -n "$YACC"; then
13158 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
13157 >  echo 'void f(){}' > conftest.cpp
13158 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13159 >        ac_m_cpu_powerpc=yes
13160   else
13161 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13162 < for as_dir in $PATH
13163 < do
9476 <  IFS=$as_save_IFS
9477 <  test -z "$as_dir" && as_dir=.
9478 <  for ac_exec_ext in '' $ac_executable_extensions; do
9479 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9480 <    ac_cv_prog_YACC="$ac_prog"
9481 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9482 <    break 2
9483 <  fi
9484 < done
9485 < done
13161 >        ac_m_cpu_powerpc=no
13162 > fi
13163 > rm -f conftest*
13164  
13165   fi
13166 < fi
13167 < YACC=$ac_cv_prog_YACC
13168 < if test -n "$YACC"; then
13169 <  echo "$as_me:$LINENO: result: $YACC" >&5
13170 < echo "${ECHO_T}$YACC" >&6
13166 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13167 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
13168 > if test "$ac_m_cpu_powerpc" = yes; then
13169 >        :
13170 >        CPU_FLAGS=-mcpu=powerpc
13171   else
13172 <  echo "$as_me:$LINENO: result: no" >&5
13173 < echo "${ECHO_T}no" >&6
13172 >        :
13173 >
13174   fi
13175  
13176 <  test -n "$YACC" && break
13177 < done
9500 < test -n "$YACC" || YACC="yacc"
13176 >                fi
13177 >                if test -z "$CPU_FLAGS"; then
13178  
13179 < for ac_prog in flex lex
13180 < do
13181 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13182 < set dummy $ac_prog; ac_word=$2
9506 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9507 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9508 < if test "${ac_cv_prog_LEX+set}" = set; then
13179 >
13180 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13181 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13182 > if test "${ac_m_powerpc+set}" = set; then
13183    echo $ECHO_N "(cached) $ECHO_C" >&6
13184   else
13185 <  if test -n "$LEX"; then
13186 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
13185 >  echo 'void f(){}' > conftest.cpp
13186 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13187 >        ac_m_powerpc=yes
13188   else
13189 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13190 < for as_dir in $PATH
13191 < do
9517 <  IFS=$as_save_IFS
9518 <  test -z "$as_dir" && as_dir=.
9519 <  for ac_exec_ext in '' $ac_executable_extensions; do
9520 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9521 <    ac_cv_prog_LEX="$ac_prog"
9522 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9523 <    break 2
9524 <  fi
9525 < done
9526 < done
13189 >        ac_m_powerpc=no
13190 > fi
13191 > rm -f conftest*
13192  
13193   fi
13194 < fi
13195 < LEX=$ac_cv_prog_LEX
13196 < if test -n "$LEX"; then
13197 <  echo "$as_me:$LINENO: result: $LEX" >&5
13198 < echo "${ECHO_T}$LEX" >&6
13194 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
13195 > echo "${ECHO_T}$ac_m_powerpc" >&6
13196 > if test "$ac_m_powerpc" = yes; then
13197 >        :
13198 >        CPU_FLAGS=-mpowerpc
13199   else
13200 <  echo "$as_me:$LINENO: result: no" >&5
13201 < echo "${ECHO_T}no" >&6
13200 >        :
13201 >
13202   fi
13203  
13204 <  test -n "$LEX" && break
13205 < done
13206 < test -n "$LEX" || LEX=":"
9542 <
9543 < if test -z "$LEXLIB"
9544 < then
9545 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
9546 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
9547 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
9548 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9549 < else
9550 <  ac_check_lib_save_LIBS=$LIBS
9551 < LIBS="-lfl  $LIBS"
9552 < cat >conftest.$ac_ext <<_ACEOF
9553 < /* confdefs.h.  */
9554 < _ACEOF
9555 < cat confdefs.h >>conftest.$ac_ext
9556 < cat >>conftest.$ac_ext <<_ACEOF
9557 < /* end confdefs.h.  */
13204 >                fi
13205 >          esac
13206 >  fi
13207  
13208 < /* Override any gcc2 internal prototype to avoid an error.  */
13209 < #ifdef __cplusplus
13210 < extern "C"
9562 < #endif
9563 < /* We use char because int might match the return type of a gcc2
9564 <   builtin and then its argument prototype would still apply.  */
9565 < char yywrap ();
9566 < int
9567 < main ()
9568 < {
9569 < yywrap ();
9570 <  ;
9571 <  return 0;
9572 < }
9573 < _ACEOF
9574 < rm -f conftest.$ac_objext conftest$ac_exeext
9575 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9576 <  (eval $ac_link) 2>conftest.er1
9577 <  ac_status=$?
9578 <  grep -v '^ *+' conftest.er1 >conftest.err
9579 <  rm -f conftest.er1
9580 <  cat conftest.err >&5
9581 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9582 <  (exit $ac_status); } &&
9583 <         { ac_try='test -z "$ac_c_werror_flag"
9584 <                         || test ! -s conftest.err'
9585 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9586 <  (eval $ac_try) 2>&5
9587 <  ac_status=$?
9588 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9589 <  (exit $ac_status); }; } &&
9590 <         { ac_try='test -s conftest$ac_exeext'
9591 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9592 <  (eval $ac_try) 2>&5
9593 <  ac_status=$?
9594 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9595 <  (exit $ac_status); }; }; then
9596 <  ac_cv_lib_fl_yywrap=yes
9597 < else
9598 <  echo "$as_me: failed program was:" >&5
9599 < sed 's/^/| /' conftest.$ac_ext >&5
13208 >  if test -n "$CPU_FLAGS"; then
13209 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13210 >  fi
13211  
13212 < ac_cv_lib_fl_yywrap=no
13213 < fi
13214 < rm -f conftest.err conftest.$ac_objext \
13215 <      conftest$ac_exeext conftest.$ac_ext
13216 < LIBS=$ac_check_lib_save_LIBS
13217 < fi
13218 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
13219 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
13220 < if test $ac_cv_lib_fl_yywrap = yes; then
13221 <  LEXLIB="-lfl"
9611 < else
9612 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
9613 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
9614 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
9615 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9616 < else
9617 <  ac_check_lib_save_LIBS=$LIBS
9618 < LIBS="-ll  $LIBS"
9619 < cat >conftest.$ac_ext <<_ACEOF
9620 < /* confdefs.h.  */
9621 < _ACEOF
9622 < cat confdefs.h >>conftest.$ac_ext
9623 < cat >>conftest.$ac_ext <<_ACEOF
9624 < /* end confdefs.h.  */
13212 >  if test -z "$CXXFLAGS"; then
13213 >        echo ""
13214 >        echo "**********************************************************"
13215 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
13216 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13217 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
13218 >        echo "**********************************************************"
13219 >        echo ""
13220 >        CXXFLAGS="-O3"
13221 >  fi
13222  
9626 – /* Override any gcc2 internal prototype to avoid an error.  */
9627 – #ifdef __cplusplus
9628 – extern "C"
9629 – #endif
9630 – /* We use char because int might match the return type of a gcc2
9631 –   builtin and then its argument prototype would still apply.  */
9632 – char yywrap ();
9633 – int
9634 – main ()
9635 – {
9636 – yywrap ();
9637 –  ;
9638 –  return 0;
9639 – }
9640 – _ACEOF
9641 – rm -f conftest.$ac_objext conftest$ac_exeext
9642 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9643 –  (eval $ac_link) 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); } &&
9650 –         { ac_try='test -z "$ac_c_werror_flag"
9651 –                         || test ! -s conftest.err'
9652 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9653 –  (eval $ac_try) 2>&5
9654 –  ac_status=$?
9655 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9656 –  (exit $ac_status); }; } &&
9657 –         { ac_try='test -s conftest$ac_exeext'
9658 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9659 –  (eval $ac_try) 2>&5
9660 –  ac_status=$?
9661 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9662 –  (exit $ac_status); }; }; then
9663 –  ac_cv_lib_l_yywrap=yes
9664 – else
9665 –  echo "$as_me: failed program was:" >&5
9666 – sed 's/^/| /' conftest.$ac_ext >&5
13223  
9668 – ac_cv_lib_l_yywrap=no
9669 – fi
9670 – rm -f conftest.err conftest.$ac_objext \
9671 –      conftest$ac_exeext conftest.$ac_ext
9672 – LIBS=$ac_check_lib_save_LIBS
9673 – fi
9674 – echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9675 – echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9676 – if test $ac_cv_lib_l_yywrap = yes; then
9677 –  LEXLIB="-ll"
9678 – fi
13224  
13225 < fi
13226 <
13227 < fi
9683 <
9684 < if test "x$LEX" != "x:"; then
9685 <  echo "$as_me:$LINENO: checking lex output file root" >&5
9686 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9687 < if test "${ac_cv_prog_lex_root+set}" = set; then
13225 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13226 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13227 > if test "${ac_guessed_cxxflags+set}" = set; then
13228    echo $ECHO_N "(cached) $ECHO_C" >&6
13229   else
13230 <  # The minimal lex program is just a single line: %%.  But some broken lexes
13231 < # (Solaris, I think it was) want two %% lines, so accommodate them.
13232 < cat >conftest.l <<_ACEOF
9693 < %%
9694 < %%
9695 < _ACEOF
9696 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9697 <  (eval $LEX conftest.l) 2>&5
9698 <  ac_status=$?
9699 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9700 <  (exit $ac_status); }
9701 < if test -f lex.yy.c; then
9702 <  ac_cv_prog_lex_root=lex.yy
9703 < elif test -f lexyy.c; then
9704 <  ac_cv_prog_lex_root=lexyy
13230 >  echo 'void f(){}' > conftest.cpp
13231 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13232 >        ac_guessed_cxxflags=yes
13233   else
13234 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9707 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9708 <   { (exit 1); exit 1; }; }
13234 >        ac_guessed_cxxflags=no
13235   fi
13236 < fi
9711 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9712 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9713 < rm -f conftest.l
9714 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13236 > rm -f conftest*
13237  
9716 – echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9717 – echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9718 – if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9719 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9720 – else
9721 –  # POSIX says lex can declare yytext either as a pointer or an array; the
9722 – # default is implementation-dependent. Figure out which it is, since
9723 – # not all implementations provide the %pointer and %array declarations.
9724 – ac_cv_prog_lex_yytext_pointer=no
9725 – echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9726 – ac_save_LIBS=$LIBS
9727 – LIBS="$LIBS $LEXLIB"
9728 – cat >conftest.$ac_ext <<_ACEOF
9729 – `cat $LEX_OUTPUT_ROOT.c`
9730 – _ACEOF
9731 – rm -f conftest.$ac_objext conftest$ac_exeext
9732 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9733 –  (eval $ac_link) 2>conftest.er1
9734 –  ac_status=$?
9735 –  grep -v '^ *+' conftest.er1 >conftest.err
9736 –  rm -f conftest.er1
9737 –  cat conftest.err >&5
9738 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9739 –  (exit $ac_status); } &&
9740 –         { ac_try='test -z "$ac_c_werror_flag"
9741 –                         || test ! -s conftest.err'
9742 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9743 –  (eval $ac_try) 2>&5
9744 –  ac_status=$?
9745 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9746 –  (exit $ac_status); }; } &&
9747 –         { ac_try='test -s conftest$ac_exeext'
9748 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9749 –  (eval $ac_try) 2>&5
9750 –  ac_status=$?
9751 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9752 –  (exit $ac_status); }; }; then
9753 –  ac_cv_prog_lex_yytext_pointer=yes
9754 – else
9755 –  echo "$as_me: failed program was:" >&5
9756 – sed 's/^/| /' conftest.$ac_ext >&5
9757 –
13238   fi
13239 < rm -f conftest.err conftest.$ac_objext \
13240 <      conftest$ac_exeext conftest.$ac_ext
13241 < LIBS=$ac_save_LIBS
13242 < rm -f "${LEX_OUTPUT_ROOT}.c"
13239 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
13240 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
13241 > if test "$ac_guessed_cxxflags" = yes; then
13242 >        :
13243  
13244 < fi
13245 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9766 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9767 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
9768 <
9769 < cat >>confdefs.h <<\_ACEOF
9770 < #define YYTEXT_POINTER 1
9771 < _ACEOF
13244 > else
13245 >        :
13246  
13247 < fi
13247 >        echo ""
13248 >        echo "**********************************************************"
13249 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
13250 >        echo "* your compiler.                                         *"
13251 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13252 >        echo "**********************************************************"
13253 >        echo ""
13254 >        CXXFLAGS=""
13255  
13256   fi
13257  
9777 –   # Extract the first word of "perl", so it can be a program name with args.
9778 – set dummy perl; ac_word=$2
9779 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9780 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9781 – if test "${ac_cv_path_PERLINTERP+set}" = set; then
9782 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9783 – else
9784 –  case $PERLINTERP in
9785 –  [\\/]* | ?:[\\/]*)
9786 –  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9787 –  ;;
9788 –  *)
9789 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9790 – for as_dir in $PATH
9791 – do
9792 –  IFS=$as_save_IFS
9793 –  test -z "$as_dir" && as_dir=.
9794 –  for ac_exec_ext in '' $ac_executable_extensions; do
9795 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9796 –    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9797 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9798 –    break 2
9799 –  fi
9800 – done
9801 – done
13258  
9803 –  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9804 –  ;;
9805 – esac
13259   fi
9807 – PERLINTERP=$ac_cv_path_PERLINTERP
13260  
13261 < if test -n "$PERLINTERP"; then
9810 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9811 < echo "${ECHO_T}$PERLINTERP" >&6
9812 < else
9813 <  echo "$as_me:$LINENO: result: no" >&5
9814 < echo "${ECHO_T}no" >&6
9815 < fi
9816 <
9817 <   ac_cv_path_perlinterp="$PERLINTERP"
9818 <   _sHpB='#!'
9819 <
9820 <
9821 < # Check whether --with-perl-shebang or --without-perl-shebang was given.
9822 < if test "${with_perl_shebang+set}" = set; then
9823 <  withval="$with_perl_shebang"
9824 <  opt_perl_shebang="$withval"
9825 < else
9826 <                opt_perl_shebang="not_set"
9827 < fi;
9828 <   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9829 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9830 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
9831 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9832 < else
9833 <   case "$opt_perl_shebang" in
9834 <                      not_set  ) ax_cv_opt_perl_shebang=''
9835 <                               ;;
9836 <                         *     )
9837 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9838 <                    esac
9839 <
9840 < fi
9841 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9842 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9843 <   if test "A$ax_cv_opt_perl_shebang" != "A"
9844 <     then
9845 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9846 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9847 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9848 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
9849 <
9850 < # Automatic detection of sharpbang formula starts here
9851 <     else
9852 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
9853 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9854 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9855 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9856 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9857 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9858 < else
9859 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9860 <        if test "x$_somian_kspb_perl" == x
9861 <          then _somian_ksbp_warn_empty='durnit'
9862 <          else
9863 <          case "A$_somian_kspb_perl" in
9864 <                 A#!*perl* )
9865 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9866 <                        ;;
9867 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9868 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9869 <          esac
9870 <        fi
9871 <
9872 < fi
9873 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
9874 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
9875 < # The above prints Checking ... result message to user.
9876 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9877 <
9878 <    if test A${_somian_ksbp_warn_empty+set} == Aset
9879 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9880 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9881 <    fi
9882 < # Inform user after printing result value
9883 <    if test A${_somian_ksbp_warn_defau+set} == Aset
9884 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9885 < echo "$as_me: Maybe Not good -" >&6;}
9886 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9887 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9888 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
9889 < echo "$as_me: OK Good result - " >&6;}
9890 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9891 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9892 <    fi
9893 <  fi
9894 <
9895 < # Extract the first word of "ar", so it can be a program name with args.
9896 < set dummy ar; ac_word=$2
9897 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9898 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9899 < if test "${ac_cv_prog_AR+set}" = set; then
9900 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9901 < else
9902 <  if test -n "$AR"; then
9903 <  ac_cv_prog_AR="$AR" # Let the user override the test.
9904 < else
9905 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9906 < for as_dir in $PATH
9907 < do
9908 <  IFS=$as_save_IFS
9909 <  test -z "$as_dir" && as_dir=.
9910 <  for ac_exec_ext in '' $ac_executable_extensions; do
9911 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9912 <    ac_cv_prog_AR="ar"
9913 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9914 <    break 2
9915 <  fi
9916 < done
9917 < done
9918 <
9919 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
9920 < fi
9921 < fi
9922 < AR=$ac_cv_prog_AR
9923 < if test -n "$AR"; then
9924 <  echo "$as_me:$LINENO: result: $AR" >&5
9925 < echo "${ECHO_T}$AR" >&6
9926 < else
9927 <  echo "$as_me:$LINENO: result: no" >&5
9928 < echo "${ECHO_T}no" >&6
9929 < fi
9930 <
9931 < if test "$AR" = "NONE"; then
9932 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9933 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9934 <   { (exit 1); exit 1; }; }
9935 <  cat >confcache <<\_ACEOF
9936 < # This file is a shell script that caches the results of configure
9937 < # tests run on this system so they can be shared between configure
9938 < # scripts and configure runs, see configure's option --config-cache.
9939 < # It is not useful on other systems.  If it contains results you don't
9940 < # want to keep, you may remove or edit it.
9941 < #
9942 < # config.status only pays attention to the cache file if you give it
9943 < # the --recheck option to rerun configure.
9944 < #
9945 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
9946 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
9947 < # following values.
9948 <
9949 < _ACEOF
9950 <
9951 < # The following way of writing the cache mishandles newlines in values,
9952 < # but we know of no workaround that is simple, portable, and efficient.
9953 < # So, don't put newlines in cache variables' values.
9954 < # Ultrix sh set writes to stderr and can't be redirected directly,
9955 < # and sets the high bit in the cache file unless we assign to the vars.
9956 < {
9957 <  (set) 2>&1 |
9958 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9959 <    *ac_space=\ *)
9960 <      # `set' does not quote correctly, so add quotes (double-quote
9961 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
9962 <      sed -n \
9963 <        "s/'/'\\\\''/g;
9964 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9965 <      ;;
9966 <    *)
9967 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
9968 <      sed -n \
9969 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9970 <      ;;
9971 <    esac;
9972 < } |
9973 <  sed '
9974 <     t clear
9975 <     : clear
9976 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9977 <     t end
9978 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9979 <     : end' >>confcache
9980 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
9981 <  if test -w $cache_file; then
9982 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9983 <    cat confcache >$cache_file
9984 <  else
9985 <    echo "not updating unwritable cache $cache_file"
9986 <  fi
9987 < fi
9988 < rm -f confcache
9989 <  exit 1
9990 < fi
9991 <
9992 < # Extract the first word of "ps", so it can be a program name with args.
9993 < set dummy ps; ac_word=$2
9994 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9995 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9996 < if test "${ac_cv_path_PS+set}" = set; then
9997 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9998 < else
9999 <  case $PS in
10000 <  [\\/]* | ?:[\\/]*)
10001 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
10002 <  ;;
10003 <  *)
10004 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10005 < for as_dir in $PATH
10006 < do
10007 <  IFS=$as_save_IFS
10008 <  test -z "$as_dir" && as_dir=.
10009 <  for ac_exec_ext in '' $ac_executable_extensions; do
10010 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10011 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
10012 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10013 <    break 2
10014 <  fi
10015 < done
10016 < done
10017 <
10018 <  ;;
13261 >     ;;
13262   esac
10020 – fi
10021 – PS=$ac_cv_path_PS
13263  
10023 – if test -n "$PS"; then
10024 –  echo "$as_me:$LINENO: result: $PS" >&5
10025 – echo "${ECHO_T}$PS" >&6
10026 – else
10027 –  echo "$as_me:$LINENO: result: no" >&5
10028 – echo "${ECHO_T}no" >&6
10029 – fi
13264  
10031 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
10032 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
10033 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
10034 –  echo $ECHO_N "(cached) $ECHO_C" >&6
10035 – else
10036 –
10037 –        if $PS ax -o rss > /dev/null 2>&1; then
10038 –                ac_cv_prog_ps_ax=yes
10039 –        else
10040 –                ac_cv_prog_ps_ax=no
10041 –        fi
10042 –        if $PS -ef -o rss > /dev/null 2>&1; then
10043 –                ac_cv_prog_ps_ef=yes
10044 –        else
10045 –                ac_cv_prog_ps_ef=no
10046 –        fi
10047 –        if test "$ac_cv_prog_ps_ax" = yes; then
10048 –                ac_cv_prog_ps_syntax=BSD
10049 –        else
10050 –                if test "$ac_cv_prog_ps_ef" = yes; then
10051 –                        ac_cv_prog_ps_syntax=POSIX
10052 –                else
10053 –                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
10054 – echo "$as_me: error: Could not determine ps syntax" >&2;}
10055 –   { (exit 1); exit 1; }; }
10056 –                fi
10057 –        fi
10058 –
10059 – fi
10060 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
10061 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
10062 –
10063 –
10064 – cat >>confdefs.h <<_ACEOF
10065 – #define PSCOMMAND $PS
10066 – _ACEOF
10067 –
10068 –
13265   cat >>confdefs.h <<\_ACEOF
13266   #define OBAPI
13267   _ACEOF
13268  
13269  
13270  
10075 – if test "$ac_cv_prog_ps_syntax" = BSD; then
13271  
10077 – cat >>confdefs.h <<\_ACEOF
10078 – #define PSTYPE_IS_BSD 1
10079 – _ACEOF
10080 –
10081 – else
10082 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
10083 –
10084 – cat >>confdefs.h <<\_ACEOF
10085 – #define PSTYPE_IS_POSIX 1
10086 – _ACEOF
10087 –
10088 –   else
10089 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
10090 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
10091 –   { (exit 1); exit 1; }; }
10092 –   fi
10093 – fi
10094 –
10095 –
13272   # Check whether --with-mpi or --without-mpi was given.
13273   if test "${with_mpi+set}" = set; then
13274    withval="$with_mpi"
# Line 10148 | Line 13324 | rm -f conftest*
13324   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13325   have_mpif_h=0
13326   rm -f conftest*
13327 < cat >conftest.f90 <<EOF
13327 > cat >conftest.$ac_ext <<EOF
13328   program main
13329     include 'mpif.h'
13330   end
13331   EOF
13332 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13332 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13333          echo "$as_me:$LINENO: result: yes" >&5
13334   echo "${ECHO_T}yes" >&6
13335          MPI_F90_INC="$MPI_INC_DIR"
# Line 10207 | Line 13383 | char MPI_Init ();
13383   /* We use char because int might match the return type of a gcc2
13384     builtin and then its argument prototype would still apply.  */
13385   char MPI_Init ();
13386 + #ifdef FC_DUMMY_MAIN
13387 + #ifndef FC_DUMMY_MAIN_EQ_F77
13388 + #  ifdef __cplusplus
13389 +     extern "C"
13390 + #  endif
13391 +   int FC_DUMMY_MAIN() { return 1; }
13392 + #endif
13393 + #endif
13394   int
13395   main ()
13396   {
# Line 10277 | Line 13461 | char MPI_Init ();
13461   /* We use char because int might match the return type of a gcc2
13462     builtin and then its argument prototype would still apply.  */
13463   char MPI_Init ();
13464 + #ifdef FC_DUMMY_MAIN
13465 + #ifndef FC_DUMMY_MAIN_EQ_F77
13466 + #  ifdef __cplusplus
13467 +     extern "C"
13468 + #  endif
13469 +   int FC_DUMMY_MAIN() { return 1; }
13470 + #endif
13471 + #endif
13472   int
13473   main ()
13474   {
# Line 10348 | Line 13540 | char MPI_Init ();
13540   /* We use char because int might match the return type of a gcc2
13541     builtin and then its argument prototype would still apply.  */
13542   char MPI_Init ();
13543 + #ifdef FC_DUMMY_MAIN
13544 + #ifndef FC_DUMMY_MAIN_EQ_F77
13545 + #  ifdef __cplusplus
13546 +     extern "C"
13547 + #  endif
13548 +   int FC_DUMMY_MAIN() { return 1; }
13549 + #endif
13550 + #endif
13551   int
13552   main ()
13553   {
# Line 10419 | Line 13619 | char MPI_Init ();
13619   /* We use char because int might match the return type of a gcc2
13620     builtin and then its argument prototype would still apply.  */
13621   char MPI_Init ();
13622 + #ifdef FC_DUMMY_MAIN
13623 + #ifndef FC_DUMMY_MAIN_EQ_F77
13624 + #  ifdef __cplusplus
13625 +     extern "C"
13626 + #  endif
13627 +   int FC_DUMMY_MAIN() { return 1; }
13628 + #endif
13629 + #endif
13630   int
13631   main ()
13632   {
# Line 10463 | Line 13671 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
13671   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13672   echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13673   if test $ac_cv_lib_mpich_MPI_Init = yes; then
13674 <  MPI_LIB="-lmpich -lpmpich"
13674 >  MPI_LIB="-lpmpich -lmpich"
13675   fi
13676  
13677   fi
# Line 10491 | Line 13699 | char MPI_Init ();
13699   /* We use char because int might match the return type of a gcc2
13700     builtin and then its argument prototype would still apply.  */
13701   char MPI_Init ();
13702 + #ifdef FC_DUMMY_MAIN
13703 + #ifndef FC_DUMMY_MAIN_EQ_F77
13704 + #  ifdef __cplusplus
13705 +     extern "C"
13706 + #  endif
13707 +   int FC_DUMMY_MAIN() { return 1; }
13708 + #endif
13709 + #endif
13710   int
13711   main ()
13712   {
# Line 10909 | Line 14125 | cat >>conftest.$ac_ext <<_ACEOF
14125   cat >>conftest.$ac_ext <<_ACEOF
14126   /* end confdefs.h.  */
14127   #include <CGAL/Cartesian.h>
14128 + #ifdef FC_DUMMY_MAIN
14129 + #ifndef FC_DUMMY_MAIN_EQ_F77
14130 + #  ifdef __cplusplus
14131 +     extern "C"
14132 + #  endif
14133 +   int FC_DUMMY_MAIN() { return 1; }
14134 + #endif
14135 + #endif
14136   int
14137   main ()
14138   {
# Line 11149 | Line 14373 | fi
14373   else
14374          enable_dot=yes
14375   fi
11152 –
11153 –
11154 –
11155 –
11156 –
11157 –
11158 –
11159 – OBJEXT=".$OBJEXT"
11160 –
11161 – OOPSE=oopse
11162 –
11163 – if test "x${prefix}" = "xNONE"
11164 – then
11165 –  OOPSE_HOME=${ac_default_prefix}/oopse
11166 – else
11167 –  OOPSE_HOME=${prefix}/oopse
11168 – fi
11169 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
11170 – if test "${enable_oopse_home+set}" = set; then
11171 –  enableval="$enable_oopse_home"
11172 –  OOPSE_HOME="${enableval}"
11173 – fi;
11174 –
11175 – case "x$INSTALL" in
11176 –   x/*) ;;
11177 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
11178 – esac
14376  
11180 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14377  
11182 – CFLAGS=${CFLAGS-""}
11183 – CXXFLAGS=${CXXFLAGS-""}
11184 – CPPFLAGS=${CPPFLAGS-""}
11185 – FFLAGS=${FFLAGS-""}
11186 – F90FLAGS=${F90FLAGS-""}
11187 – LDFLAGS=${LDFLAGS-""}
11188 – DEBUG=${DEBUG-"-g"}
14378  
11190 – case $debug in
11191 –  1)
11192 –     FFLAGS="$DEBUG $FFLAGS"
11193 –     F90FLAGS="$DEBUG $F90FLAGS"
11194 –     ;;
11195 –  *)
11196 –     ;;
11197 – esac
14379  
14380  
14381  
# Line 11211 | Line 14392 | esac
14392  
14393  
14394  
11214 –
11215 –
11216 –          ac_config_headers="$ac_config_headers src/config.h"
11217 –
14395                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396  
14397  
# Line 11580 | Line 14757 | cat >&5 <<_CSEOF
14757   } >&5
14758   cat >&5 <<_CSEOF
14759  
14760 < This file was extended by OOPSE $as_me 2.0, which was
14760 > This file was extended by OOPSE $as_me 3.0, which was
14761   generated by GNU Autoconf 2.59.  Invocation command line was
14762  
14763    CONFIG_FILES    = $CONFIG_FILES
# Line 11643 | Line 14820 | ac_cs_version="\\
14820  
14821   cat >>$CONFIG_STATUS <<_ACEOF
14822   ac_cs_version="\\
14823 < OOPSE config.status 2.0
14823 > OOPSE config.status 3.0
14824   configured by $0, generated by GNU Autoconf 2.59,
14825    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14826  
# Line 11837 | Line 15014 | s,@LIBS@,$LIBS,;t t
15014   s,@ECHO_N@,$ECHO_N,;t t
15015   s,@ECHO_T@,$ECHO_T,;t t
15016   s,@LIBS@,$LIBS,;t t
11840 – s,@PROGNAME@,$PROGNAME,;t t
11841 – s,@debug@,$debug,;t t
15017   s,@build@,$build,;t t
15018   s,@build_cpu@,$build_cpu,;t t
15019   s,@build_vendor@,$build_vendor,;t t
# Line 11847 | Line 15022 | s,@host_os@,$host_os,;t t
15022   s,@host_cpu@,$host_cpu,;t t
15023   s,@host_vendor@,$host_vendor,;t t
15024   s,@host_os@,$host_os,;t t
15025 < s,@CC@,$CC,;t t
15026 < s,@CFLAGS@,$CFLAGS,;t t
15025 > s,@PROGNAME@,$PROGNAME,;t t
15026 > s,@debug@,$debug,;t t
15027 > s,@CXX@,$CXX,;t t
15028 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15029   s,@LDFLAGS@,$LDFLAGS,;t t
15030   s,@CPPFLAGS@,$CPPFLAGS,;t t
15031 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15031 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032   s,@EXEEXT@,$EXEEXT,;t t
15033   s,@OBJEXT@,$OBJEXT,;t t
15034 < s,@CXX@,$CXX,;t t
15035 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15036 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15034 > s,@CC@,$CC,;t t
15035 > s,@CFLAGS@,$CFLAGS,;t t
15036 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15037 > s,@FC@,$FC,;t t
15038 > s,@FCFLAGS@,$FCFLAGS,;t t
15039 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15040   s,@CPP@,$CPP,;t t
15041   s,@EGREP@,$EGREP,;t t
11862 – s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11863 – s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11864 – s,@F90@,$F90,;t t
11865 – s,@F90FLAGS@,$F90FLAGS,;t t
11866 – s,@ac_ct_F90@,$ac_ct_F90,;t t
11867 – s,@PREPFLAG@,$PREPFLAG,;t t
11868 – s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11869 – s,@F90LIBS@,$F90LIBS,;t t
11870 – s,@F90_FUNC@,$F90_FUNC,;t t
11871 – s,@F90_FUNC_@,$F90_FUNC_,;t t
11872 – s,@MOD@,$MOD,;t t
11873 – s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11874 – s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11875 – s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11876 – s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
11877 – s,@CXXCPP@,$CXXCPP,;t t
11878 – s,@LIBOBJS@,$LIBOBJS,;t t
11879 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11880 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11881 – s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15042   s,@LN_S@,$LN_S,;t t
15043   s,@SET_MAKE@,$SET_MAKE,;t t
15044   s,@RANLIB@,$RANLIB,;t t
15045   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11886 – s,@YACC@,$YACC,;t t
11887 – s,@LEX@,$LEX,;t t
11888 – s,@LEXLIB@,$LEXLIB,;t t
11889 – s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046   s,@PERLINTERP@,$PERLINTERP,;t t
15047   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051   s,@AR@,$AR,;t t
15052   s,@PS@,$PS,;t t
15053 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056 + s,@FCLIBS@,$FCLIBS,;t t
15057 + s,@FC_FUNC@,$FC_FUNC,;t t
15058 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15059 + s,@MOD@,$MOD,;t t
15060 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064 + s,@LIBOBJS@,$LIBOBJS,;t t
15065 + s,@POW_LIB@,$POW_LIB,;t t
15066 + s,@CXXCPP@,$CXXCPP,;t t
15067 + s,@__func__@,$__func__,;t t
15068   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11915 | Line 15089 | s,@SUBDIRS@,$SUBDIRS,;t t
15089   s,@OOPSE@,$OOPSE,;t t
15090   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15091   s,@SUBDIRS@,$SUBDIRS,;t t
11918 – s,@FFLAGS@,$FFLAGS,;t t
15092   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093   CEOF
15094  

Diff Legend

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