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 958 by gezelter, Wed May 17 03:03:03 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_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 ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_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-zlib=DIR root directory path of zlib installation defaults to
883                    /usr/local or /usr if not found in /usr/local
884  --without-zlib to disable zlib usage completely
882    --with-perl-shebang     override what perl thinks is the way for the kernel
883                            to start it (seldom needed)
884 +  --with-zlib=DIR         root directory path of zlib installation (defaults
885 +                          to /usr/local or /usr if not found in /usr/local)
886 +  --with-fftw=DIR         root directory path of fftw installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889    --with-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 1374 | Line 1375 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1375   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1376   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1377
1378
1379 # This file is part of Autoconf.                       -*- Autoconf -*-
1380 # Programming languages support.
1381 # Copyright 2000, 2001
1382 # Free Software Foundation, Inc.
1383 #
1384 # This program is free software; you can redistribute it and/or modify
1385 # it under the terms of the GNU General Public License as published by
1386 # the Free Software Foundation; either version 2, or (at your option)
1387 # any later version.
1388 #
1389 # This program is distributed in the hope that it will be useful,
1390 # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 # GNU General Public License for more details.
1393 #
1394 # You should have received a copy of the GNU General Public License
1395 # along with this program; if not, write to the Free Software
1396 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 # 02111-1307, USA.
1398 #
1399 # As a special exception, the Free Software Foundation gives unlimited
1400 # permission to copy, distribute and modify the configure scripts that
1401 # are the output of Autoconf.  You need not follow the terms of the GNU
1402 # General Public License when using or distributing such scripts, even
1403 # though portions of the text of Autoconf appear in them.  The GNU
1404 # General Public License (GPL) does govern all other use of the material
1405 # that constitutes the Autoconf program.
1406 #
1407 # Certain portions of the Autoconf source text are designed to be copied
1408 # (in certain cases, depending on the input) into the output of
1409 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 # source text consists of comments plus executable code that decides which
1411 # of the data portions to output in any given case.  We call these
1412 # comments and executable code the "non-data" portions.  Autoconf never
1413 # copies any of the non-data portions into its output.
1414 #
1415 # This special exception to the GPL applies to versions of Autoconf
1416 # released by the Free Software Foundation.  When you make and
1417 # distribute a modified version of Autoconf, you may extend this special
1418 # exception to the GPL to apply to your modified version as well, *unless*
1419 # your modified version has the potential to copy into its output some
1420 # of the text that was the non-data portion of the version that you started
1421 # with.  (In other words, unless your change moves or copies text from
1422 # the non-data portions to the data portions.)  If your modification has
1423 # such potential, you must delete any notice of this special exception
1424 # to the GPL from your modified version.
1425 #
1426 # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 # many others).
1428
1429
1430 # Table of Contents:
1431 #
1432 # 1. Language selection
1433 #    and routines to produce programs in a given language.
1434 #  a. Fortran 77 (to be moved from aclang.m4)
1435 #  b. Fortran 90
1436 #  c. Fortran 95
1437 #
1438 # 2. Producing programs in a given language.
1439 #  a. Fortran 77 (to be moved from aclang.m4)
1440 #  b. Fortran 90
1441 #  c. Fortran 95
1442 #
1443 # 3. Looking for a compiler
1444 #    And possibly the associated preprocessor.
1445 #  a. Fortran 77 (to be moved from aclang.m4)
1446 #  b. Fortran 90
1447 #  c. Fortran 95
1448 #
1449 # 4. Compilers' characteristics.
1450 #  a. Fortran 77 (to be moved from aclang.m4)
1451 #  b. Fortran 90
1452 #  c. Fortran 95
1453
1454 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 # ---------------------------------------------------------------------------
1456 #
1457 # Processing the elements of a list is tedious in shell programming,
1458 # as lists tend to be implemented as space delimited strings.
1459 #
1460 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 # if ELEMENT is a member of LIST, otherwise it executes
1462 # ACTION-IF-NOT-FOUND.
1463 # _AC_LIST_MEMBER_IF
1464
1465
1466
1467 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 # -------------------------------------------------
1469 #
1470 # Specifying options to the compiler (whether it be the C, C++ or
1471 # Fortran 77 compiler) that are meant for the linker is compiler
1472 # dependent.  This macro lets you give options to the compiler that
1473 # are meant for the linker in a portable, compiler-independent way.
1474 #
1475 # This macro take two arguments, a list of linker options that the
1476 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 # appended to the shell variable in a compiler-dependent way.
1479 #
1480 # For example, if the selected language is C, then this:
1481 #
1482 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 #
1484 # will expand into this if the selected C compiler is gcc:
1485 #
1486 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 #
1488 # otherwise, it will expand into this:
1489 #
1490 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 #
1492 # You are encouraged to add support for compilers that this macro
1493 # doesn't currently support.
1494 # FIXME: Get rid of this macro.
1495 # _AC_LINKER_OPTION
1496
1497
1498
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1502
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1506
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1509
1510
1511
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1514
1515
1516
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1520
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1523
1524
1525
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1528
1529
1530
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1534
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1538
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1541
1542
1543
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1546
1547
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1550
1378  
1379  
1380 < # ------------------------ #
1554 < # 2c. Fortran 95 sources.  #
1555 < # ------------------------ #
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1382  
1383  
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1384  
1385  
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1386  
1387  
1388  
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1389  
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1390  
1391  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1392  
1393  
1394  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1395  
1396  
1397  
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
1398  
1399  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1400  
1401  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1402  
1403  
1404  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1405  
1406  
1407  
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
1408  
1409  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1410  
1411  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1412  
1413  
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
1414  
1415  
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
1416  
1417  
1672 # AC_F90_LIBRARY_LDFLAGS
1673 # ----------------------
1674 #
1675 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 # intrinsic and run-time libraries that are required to successfully
1677 # link a Fortran 90 program or shared library.  The output variable
1678 # F90LIBS is set to these flags.
1679 #
1680 # This macro is intended to be used in those situations when it is
1681 # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 # program or shared library.
1683 #
1684 # For example, if object files from a C++ and Fortran 90 compiler must
1685 # be linked together, then the C++ compiler/linker must be used for
1686 # linking (since special C++-ish things need to happen at link time
1687 # like calling global constructors, instantiating templates, enabling
1688 # exception support, etc.).
1689 #
1690 # However, the Fortran 90 intrinsic and run-time libraries must be
1691 # linked in as well, but the C++ compiler/linker doesn't know how to
1692 # add these Fortran 90 libraries.  Hence, the macro
1693 # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 # libraries.
1695 #
1696 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 # AC_F90_LIBRARY_LDFLAGS
1418  
1419  
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
1420  
1717 # The replacement is empty.
1421  
1422  
1423  
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
1424  
1729
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
1736
1737
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1741
1742
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 # --------------
1425   #
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 # ----------------------
1426   #
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.
1427   #
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
1428  
1429  
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
1430  
1809 # The replacement is empty.
1431  
1432  
1433  
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
1434   # AC_F90_MODULE_NAMES
1435   # -------------------
1436   #
# Line 1885 | Line 1490 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1490  
1491  
1492  
1888 #
1889 #
1890 #
1493  
1494  
1495  
# Line 1923 | Line 1525 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1525  
1526  
1527  
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
1528   # who am i
1529   # Make sure we can run config.sub.
1530   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 2011 | Line 1583 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1583  
1584  
1585  
1586 < ac_ext=c
1587 < ac_cpp='$CPP $CPPFLAGS'
1588 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1589 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1590 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1586 > # set program name
1587 > PROGNAME="oopse"
1588 >
1589 >
1590 >
1591 >
1592 > OBJEXT=".$OBJEXT"
1593 >
1594 > OOPSE=oopse
1595 >
1596 > if test "x${prefix}" = "xNONE"
1597 > then
1598 >  OOPSE_HOME=${ac_default_prefix}/oopse
1599 > else
1600 >  OOPSE_HOME=${prefix}/oopse
1601 > fi
1602 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1603 > if test "${enable_oopse_home+set}" = set; then
1604 >  enableval="$enable_oopse_home"
1605 >  OOPSE_HOME="${enableval}"
1606 > fi;
1607 >
1608 > # there are two ways to do debugging.  One with the --enable-debug flag
1609 > # and one using the DEBUG environment variable
1610 >
1611 > debug=0
1612 > # Check whether --enable-debug or --disable-debug was given.
1613 > if test "${enable_debug+set}" = set; then
1614 >  enableval="$enable_debug"
1615 >  debug=1
1616 > fi;
1617 > if test "${DEBUG}"; then
1618 >
1619 > cat >>confdefs.h <<\_ACEOF
1620 > #define debug 1
1621 > _ACEOF
1622 >
1623 >  msg="$msg, debug mode"
1624 > fi
1625 >
1626 >
1627 > # Checks for programs.
1628 > ac_ext=cc
1629 > ac_cpp='$CXXCPP $CPPFLAGS'
1630 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1631 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1632 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1633   if test -n "$ac_tool_prefix"; then
1634 <  for ac_prog in pathcc icc xlc gcc cc
1634 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1635    do
1636      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1637   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1638   echo "$as_me:$LINENO: checking for $ac_word" >&5
1639   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1640 < if test "${ac_cv_prog_CC+set}" = set; then
1640 > if test "${ac_cv_prog_CXX+set}" = set; then
1641    echo $ECHO_N "(cached) $ECHO_C" >&6
1642   else
1643 <  if test -n "$CC"; then
1644 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1643 >  if test -n "$CXX"; then
1644 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1645   else
1646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1647   for as_dir in $PATH
# Line 2036 | Line 1650 | do
1650    test -z "$as_dir" && as_dir=.
1651    for ac_exec_ext in '' $ac_executable_extensions; do
1652    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1653 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1653 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1654      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1655      break 2
1656    fi
# Line 2045 | Line 1659 | fi
1659  
1660   fi
1661   fi
1662 < CC=$ac_cv_prog_CC
1663 < if test -n "$CC"; then
1664 <  echo "$as_me:$LINENO: result: $CC" >&5
1665 < echo "${ECHO_T}$CC" >&6
1662 > CXX=$ac_cv_prog_CXX
1663 > if test -n "$CXX"; then
1664 >  echo "$as_me:$LINENO: result: $CXX" >&5
1665 > echo "${ECHO_T}$CXX" >&6
1666   else
1667    echo "$as_me:$LINENO: result: no" >&5
1668   echo "${ECHO_T}no" >&6
1669   fi
1670  
1671 <    test -n "$CC" && break
1671 >    test -n "$CXX" && break
1672    done
1673   fi
1674 < if test -z "$CC"; then
1675 <  ac_ct_CC=$CC
1676 <  for ac_prog in pathcc icc xlc gcc cc
1674 > if test -z "$CXX"; then
1675 >  ac_ct_CXX=$CXX
1676 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1677   do
1678    # Extract the first word of "$ac_prog", so it can be a program name with args.
1679   set dummy $ac_prog; ac_word=$2
1680   echo "$as_me:$LINENO: checking for $ac_word" >&5
1681   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1682 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1682 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1683    echo $ECHO_N "(cached) $ECHO_C" >&6
1684   else
1685 <  if test -n "$ac_ct_CC"; then
1686 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1685 >  if test -n "$ac_ct_CXX"; then
1686 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1687   else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689   for as_dir in $PATH
# Line 2078 | Line 1692 | do
1692    test -z "$as_dir" && as_dir=.
1693    for ac_exec_ext in '' $ac_executable_extensions; do
1694    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1695 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1695 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1696      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1697      break 2
1698    fi
# Line 2087 | Line 1701 | fi
1701  
1702   fi
1703   fi
1704 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1705 < if test -n "$ac_ct_CC"; then
1706 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1707 < echo "${ECHO_T}$ac_ct_CC" >&6
1704 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1705 > if test -n "$ac_ct_CXX"; then
1706 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1707 > echo "${ECHO_T}$ac_ct_CXX" >&6
1708   else
1709    echo "$as_me:$LINENO: result: no" >&5
1710   echo "${ECHO_T}no" >&6
1711   fi
1712  
1713 <  test -n "$ac_ct_CC" && break
1713 >  test -n "$ac_ct_CXX" && break
1714   done
1715 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1716  
1717 <  CC=$ac_ct_CC
1717 >  CXX=$ac_ct_CXX
1718   fi
1719  
1720  
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
1721   # Provide some information about the compiler.
1722   echo "$as_me:$LINENO:" \
1723 <     "checking for C compiler version" >&5
1723 >     "checking for C++ compiler version" >&5
1724   ac_compiler=`set X $ac_compile; echo $2`
1725   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1726    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2149 | Line 1758 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1758   # Try to create an executable without -o first, disregard a.out.
1759   # It will help us diagnose broken compilers, and finding out an intuition
1760   # of exeext.
1761 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1762 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1761 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1762 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1763   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1764   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1765    (eval $ac_link_default) 2>&5
# Line 2193 | Line 1802 | sed 's/^/| /' conftest.$ac_ext >&5
1802    echo "$as_me: failed program was:" >&5
1803   sed 's/^/| /' conftest.$ac_ext >&5
1804  
1805 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1805 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1806   See \`config.log' for more details." >&5
1807 < echo "$as_me: error: C compiler cannot create executables
1807 > echo "$as_me: error: C++ compiler cannot create executables
1808   See \`config.log' for more details." >&2;}
1809     { (exit 77); exit 77; }; }
1810   fi
# Line 2206 | Line 1815 | echo "${ECHO_T}$ac_file" >&6
1815  
1816   # Check the compiler produces executables we can run.  If not, either
1817   # the compiler is broken, or we cross compile.
1818 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1819 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1818 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1819 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1820   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1821   # If not cross compiling, check that we can run a simple program.
1822   if test "$cross_compiling" != yes; then
# Line 2222 | Line 1831 | if test "$cross_compiling" != yes; then
1831      if test "$cross_compiling" = maybe; then
1832          cross_compiling=yes
1833      else
1834 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1834 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1835   If you meant to cross compile, use \`--host'.
1836   See \`config.log' for more details." >&5
1837 < echo "$as_me: error: cannot run C compiled programs.
1837 > echo "$as_me: error: cannot run C++ compiled programs.
1838   If you meant to cross compile, use \`--host'.
1839   See \`config.log' for more details." >&2;}
1840     { (exit 1); exit 1; }; }
# Line 2330 | Line 1939 | ac_objext=$OBJEXT
1939   echo "${ECHO_T}$ac_cv_objext" >&6
1940   OBJEXT=$ac_cv_objext
1941   ac_objext=$OBJEXT
1942 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1943 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1944 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1945 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1946 + else
1947 +  cat >conftest.$ac_ext <<_ACEOF
1948 + /* confdefs.h.  */
1949 + _ACEOF
1950 + cat confdefs.h >>conftest.$ac_ext
1951 + cat >>conftest.$ac_ext <<_ACEOF
1952 + /* end confdefs.h.  */
1953 +
1954 + int
1955 + main ()
1956 + {
1957 + #ifndef __GNUC__
1958 +       choke me
1959 + #endif
1960 +
1961 +  ;
1962 +  return 0;
1963 + }
1964 + _ACEOF
1965 + rm -f conftest.$ac_objext
1966 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1967 +  (eval $ac_compile) 2>conftest.er1
1968 +  ac_status=$?
1969 +  grep -v '^ *+' conftest.er1 >conftest.err
1970 +  rm -f conftest.er1
1971 +  cat conftest.err >&5
1972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973 +  (exit $ac_status); } &&
1974 +         { ac_try='test -z "$ac_cxx_werror_flag"
1975 +                         || test ! -s conftest.err'
1976 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1977 +  (eval $ac_try) 2>&5
1978 +  ac_status=$?
1979 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1980 +  (exit $ac_status); }; } &&
1981 +         { ac_try='test -s conftest.$ac_objext'
1982 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1983 +  (eval $ac_try) 2>&5
1984 +  ac_status=$?
1985 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986 +  (exit $ac_status); }; }; then
1987 +  ac_compiler_gnu=yes
1988 + else
1989 +  echo "$as_me: failed program was:" >&5
1990 + sed 's/^/| /' conftest.$ac_ext >&5
1991 +
1992 + ac_compiler_gnu=no
1993 + fi
1994 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1996 +
1997 + fi
1998 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1999 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2000 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2001 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2002 + ac_save_CXXFLAGS=$CXXFLAGS
2003 + CXXFLAGS="-g"
2004 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2005 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2006 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2007 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2008 + else
2009 +  cat >conftest.$ac_ext <<_ACEOF
2010 + /* confdefs.h.  */
2011 + _ACEOF
2012 + cat confdefs.h >>conftest.$ac_ext
2013 + cat >>conftest.$ac_ext <<_ACEOF
2014 + /* end confdefs.h.  */
2015 +
2016 + int
2017 + main ()
2018 + {
2019 +
2020 +  ;
2021 +  return 0;
2022 + }
2023 + _ACEOF
2024 + rm -f conftest.$ac_objext
2025 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2026 +  (eval $ac_compile) 2>conftest.er1
2027 +  ac_status=$?
2028 +  grep -v '^ *+' conftest.er1 >conftest.err
2029 +  rm -f conftest.er1
2030 +  cat conftest.err >&5
2031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2032 +  (exit $ac_status); } &&
2033 +         { ac_try='test -z "$ac_cxx_werror_flag"
2034 +                         || test ! -s conftest.err'
2035 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2036 +  (eval $ac_try) 2>&5
2037 +  ac_status=$?
2038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2039 +  (exit $ac_status); }; } &&
2040 +         { ac_try='test -s conftest.$ac_objext'
2041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2042 +  (eval $ac_try) 2>&5
2043 +  ac_status=$?
2044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045 +  (exit $ac_status); }; }; then
2046 +  ac_cv_prog_cxx_g=yes
2047 + else
2048 +  echo "$as_me: failed program was:" >&5
2049 + sed 's/^/| /' conftest.$ac_ext >&5
2050 +
2051 + ac_cv_prog_cxx_g=no
2052 + fi
2053 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2054 + fi
2055 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2056 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2057 + if test "$ac_test_CXXFLAGS" = set; then
2058 +  CXXFLAGS=$ac_save_CXXFLAGS
2059 + elif test $ac_cv_prog_cxx_g = yes; then
2060 +  if test "$GXX" = yes; then
2061 +    CXXFLAGS="-g -O2"
2062 +  else
2063 +    CXXFLAGS="-g"
2064 +  fi
2065 + else
2066 +  if test "$GXX" = yes; then
2067 +    CXXFLAGS="-O2"
2068 +  else
2069 +    CXXFLAGS=
2070 +  fi
2071 + fi
2072 + for ac_declaration in \
2073 +   '' \
2074 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2075 +   'extern "C" void std::exit (int); using std::exit;' \
2076 +   'extern "C" void exit (int) throw ();' \
2077 +   'extern "C" void exit (int);' \
2078 +   'void exit (int);'
2079 + do
2080 +  cat >conftest.$ac_ext <<_ACEOF
2081 + /* confdefs.h.  */
2082 + _ACEOF
2083 + cat confdefs.h >>conftest.$ac_ext
2084 + cat >>conftest.$ac_ext <<_ACEOF
2085 + /* end confdefs.h.  */
2086 + $ac_declaration
2087 + #include <stdlib.h>
2088 + int
2089 + main ()
2090 + {
2091 + exit (42);
2092 +  ;
2093 +  return 0;
2094 + }
2095 + _ACEOF
2096 + rm -f conftest.$ac_objext
2097 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2098 +  (eval $ac_compile) 2>conftest.er1
2099 +  ac_status=$?
2100 +  grep -v '^ *+' conftest.er1 >conftest.err
2101 +  rm -f conftest.er1
2102 +  cat conftest.err >&5
2103 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104 +  (exit $ac_status); } &&
2105 +         { ac_try='test -z "$ac_cxx_werror_flag"
2106 +                         || test ! -s conftest.err'
2107 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108 +  (eval $ac_try) 2>&5
2109 +  ac_status=$?
2110 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2111 +  (exit $ac_status); }; } &&
2112 +         { ac_try='test -s conftest.$ac_objext'
2113 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2114 +  (eval $ac_try) 2>&5
2115 +  ac_status=$?
2116 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2117 +  (exit $ac_status); }; }; then
2118 +  :
2119 + else
2120 +  echo "$as_me: failed program was:" >&5
2121 + sed 's/^/| /' conftest.$ac_ext >&5
2122 +
2123 + continue
2124 + fi
2125 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2126 +  cat >conftest.$ac_ext <<_ACEOF
2127 + /* confdefs.h.  */
2128 + _ACEOF
2129 + cat confdefs.h >>conftest.$ac_ext
2130 + cat >>conftest.$ac_ext <<_ACEOF
2131 + /* end confdefs.h.  */
2132 + $ac_declaration
2133 + int
2134 + main ()
2135 + {
2136 + exit (42);
2137 +  ;
2138 +  return 0;
2139 + }
2140 + _ACEOF
2141 + rm -f conftest.$ac_objext
2142 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2143 +  (eval $ac_compile) 2>conftest.er1
2144 +  ac_status=$?
2145 +  grep -v '^ *+' conftest.er1 >conftest.err
2146 +  rm -f conftest.er1
2147 +  cat conftest.err >&5
2148 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2149 +  (exit $ac_status); } &&
2150 +         { ac_try='test -z "$ac_cxx_werror_flag"
2151 +                         || test ! -s conftest.err'
2152 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2153 +  (eval $ac_try) 2>&5
2154 +  ac_status=$?
2155 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2156 +  (exit $ac_status); }; } &&
2157 +         { ac_try='test -s conftest.$ac_objext'
2158 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2159 +  (eval $ac_try) 2>&5
2160 +  ac_status=$?
2161 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2162 +  (exit $ac_status); }; }; then
2163 +  break
2164 + else
2165 +  echo "$as_me: failed program was:" >&5
2166 + sed 's/^/| /' conftest.$ac_ext >&5
2167 +
2168 + fi
2169 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2170 + done
2171 + rm -f conftest*
2172 + if test -n "$ac_declaration"; then
2173 +  echo '#ifdef __cplusplus' >>confdefs.h
2174 +  echo $ac_declaration      >>confdefs.h
2175 +  echo '#endif'             >>confdefs.h
2176 + fi
2177 +
2178 + ac_ext=c
2179 + ac_cpp='$CPP $CPPFLAGS'
2180 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2181 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2182 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2183 +
2184 + ac_ext=c
2185 + ac_cpp='$CPP $CPPFLAGS'
2186 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2187 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2188 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2189 + if test -n "$ac_tool_prefix"; then
2190 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2191 +  do
2192 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2193 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2194 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2195 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2196 + if test "${ac_cv_prog_CC+set}" = set; then
2197 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2198 + else
2199 +  if test -n "$CC"; then
2200 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2201 + else
2202 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2203 + for as_dir in $PATH
2204 + do
2205 +  IFS=$as_save_IFS
2206 +  test -z "$as_dir" && as_dir=.
2207 +  for ac_exec_ext in '' $ac_executable_extensions; do
2208 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2209 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2210 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2211 +    break 2
2212 +  fi
2213 + done
2214 + done
2215 +
2216 + fi
2217 + fi
2218 + CC=$ac_cv_prog_CC
2219 + if test -n "$CC"; then
2220 +  echo "$as_me:$LINENO: result: $CC" >&5
2221 + echo "${ECHO_T}$CC" >&6
2222 + else
2223 +  echo "$as_me:$LINENO: result: no" >&5
2224 + echo "${ECHO_T}no" >&6
2225 + fi
2226 +
2227 +    test -n "$CC" && break
2228 +  done
2229 + fi
2230 + if test -z "$CC"; then
2231 +  ac_ct_CC=$CC
2232 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2233 + do
2234 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2235 + set dummy $ac_prog; ac_word=$2
2236 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2237 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2238 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2239 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2240 + else
2241 +  if test -n "$ac_ct_CC"; then
2242 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2243 + else
2244 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2245 + for as_dir in $PATH
2246 + do
2247 +  IFS=$as_save_IFS
2248 +  test -z "$as_dir" && as_dir=.
2249 +  for ac_exec_ext in '' $ac_executable_extensions; do
2250 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2251 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2252 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2253 +    break 2
2254 +  fi
2255 + done
2256 + done
2257 +
2258 + fi
2259 + fi
2260 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2261 + if test -n "$ac_ct_CC"; then
2262 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2263 + echo "${ECHO_T}$ac_ct_CC" >&6
2264 + else
2265 +  echo "$as_me:$LINENO: result: no" >&5
2266 + echo "${ECHO_T}no" >&6
2267 + fi
2268 +
2269 +  test -n "$ac_ct_CC" && break
2270 + done
2271 +
2272 +  CC=$ac_ct_CC
2273 + fi
2274 +
2275 +
2276 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2277 + See \`config.log' for more details." >&5
2278 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2279 + See \`config.log' for more details." >&2;}
2280 +   { (exit 1); exit 1; }; }
2281 +
2282 + # Provide some information about the compiler.
2283 + echo "$as_me:$LINENO:" \
2284 +     "checking for C compiler version" >&5
2285 + ac_compiler=`set X $ac_compile; echo $2`
2286 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2287 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2288 +  ac_status=$?
2289 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2290 +  (exit $ac_status); }
2291 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2292 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2293 +  ac_status=$?
2294 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2295 +  (exit $ac_status); }
2296 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2297 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2298 +  ac_status=$?
2299 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2300 +  (exit $ac_status); }
2301 +
2302   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2303   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2304   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2723 | Line 2692 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2692   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2693   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2694   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2726
2695  
2696 < ac_ext=cc
2697 < ac_cpp='$CXXCPP $CPPFLAGS'
2698 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2699 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2732 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2696 > ac_ext=${FC_SRCEXT-f}
2697 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2698 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2699 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2700   if test -n "$ac_tool_prefix"; then
2701 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2701 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2702    do
2703      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2704   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2705   echo "$as_me:$LINENO: checking for $ac_word" >&5
2706   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2707 < if test "${ac_cv_prog_CXX+set}" = set; then
2707 > if test "${ac_cv_prog_FC+set}" = set; then
2708    echo $ECHO_N "(cached) $ECHO_C" >&6
2709   else
2710 <  if test -n "$CXX"; then
2711 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2710 >  if test -n "$FC"; then
2711 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2712   else
2713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2714   for as_dir in $PATH
# Line 2750 | Line 2717 | do
2717    test -z "$as_dir" && as_dir=.
2718    for ac_exec_ext in '' $ac_executable_extensions; do
2719    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2720 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2720 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2721      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2722      break 2
2723    fi
# Line 2759 | Line 2726 | fi
2726  
2727   fi
2728   fi
2729 < CXX=$ac_cv_prog_CXX
2730 < if test -n "$CXX"; then
2731 <  echo "$as_me:$LINENO: result: $CXX" >&5
2732 < echo "${ECHO_T}$CXX" >&6
2733 < else
2734 <  echo "$as_me:$LINENO: result: no" >&5
2729 > FC=$ac_cv_prog_FC
2730 > if test -n "$FC"; then
2731 >  echo "$as_me:$LINENO: result: $FC" >&5
2732 > echo "${ECHO_T}$FC" >&6
2733 > else
2734 >  echo "$as_me:$LINENO: result: no" >&5
2735   echo "${ECHO_T}no" >&6
2736   fi
2737  
2738 <    test -n "$CXX" && break
2738 >    test -n "$FC" && break
2739    done
2740   fi
2741 < if test -z "$CXX"; then
2742 <  ac_ct_CXX=$CXX
2743 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2741 > if test -z "$FC"; then
2742 >  ac_ct_FC=$FC
2743 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2744   do
2745    # Extract the first word of "$ac_prog", so it can be a program name with args.
2746   set dummy $ac_prog; ac_word=$2
2747   echo "$as_me:$LINENO: checking for $ac_word" >&5
2748   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2749 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2749 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2750    echo $ECHO_N "(cached) $ECHO_C" >&6
2751   else
2752 <  if test -n "$ac_ct_CXX"; then
2753 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2752 >  if test -n "$ac_ct_FC"; then
2753 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2754   else
2755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2756   for as_dir in $PATH
# Line 2792 | Line 2759 | do
2759    test -z "$as_dir" && as_dir=.
2760    for ac_exec_ext in '' $ac_executable_extensions; do
2761    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2762 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2762 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2763      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2764      break 2
2765    fi
# Line 2801 | Line 2768 | fi
2768  
2769   fi
2770   fi
2771 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2772 < if test -n "$ac_ct_CXX"; then
2773 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2774 < echo "${ECHO_T}$ac_ct_CXX" >&6
2771 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2772 > if test -n "$ac_ct_FC"; then
2773 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2774 > echo "${ECHO_T}$ac_ct_FC" >&6
2775   else
2776    echo "$as_me:$LINENO: result: no" >&5
2777   echo "${ECHO_T}no" >&6
2778   fi
2779  
2780 <  test -n "$ac_ct_CXX" && break
2780 >  test -n "$ac_ct_FC" && break
2781   done
2815 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2782  
2783 <  CXX=$ac_ct_CXX
2783 >  FC=$ac_ct_FC
2784   fi
2785  
2786  
2787   # Provide some information about the compiler.
2788 < echo "$as_me:$LINENO:" \
2789 <     "checking for C++ compiler version" >&5
2788 > echo "$as_me:2788:" \
2789 >     "checking for Fortran compiler version" >&5
2790   ac_compiler=`set X $ac_compile; echo $2`
2791   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2792    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2837 | Line 2803 | ac_compiler=`set X $ac_compile; echo $2`
2803    ac_status=$?
2804    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2805    (exit $ac_status); }
2806 + rm -f a.out
2807  
2808 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2809 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2810 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2808 > # If we don't use `.F' as extension, the preprocessor is not run on the
2809 > # input file.  (Note that this only needs to work for GNU compilers.)
2810 > ac_save_ext=$ac_ext
2811 > ac_ext=F
2812 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2813 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2814 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2815    echo $ECHO_N "(cached) $ECHO_C" >&6
2816   else
2817    cat >conftest.$ac_ext <<_ACEOF
2818 < /* confdefs.h.  */
2848 < _ACEOF
2849 < cat confdefs.h >>conftest.$ac_ext
2850 < cat >>conftest.$ac_ext <<_ACEOF
2851 < /* end confdefs.h.  */
2852 <
2853 < int
2854 < main ()
2855 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2861 <  return 0;
2862 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2870 | Line 2831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2831    cat conftest.err >&5
2832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833    (exit $ac_status); } &&
2834 <         { ac_try='test -z "$ac_cxx_werror_flag"
2834 >         { ac_try='test -z "$ac_fc_werror_flag"
2835                           || test ! -s conftest.err'
2836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837    (eval $ac_try) 2>&5
# Line 2891 | Line 2852 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2852   ac_compiler_gnu=no
2853   fi
2854   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2855 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2855 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2856  
2857   fi
2858 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2859 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2860 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2861 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2862 < ac_save_CXXFLAGS=$CXXFLAGS
2863 < CXXFLAGS="-g"
2864 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2865 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2866 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2858 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2859 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2860 > ac_ext=$ac_save_ext
2861 > ac_test_FFLAGS=${FCFLAGS+set}
2862 > ac_save_FFLAGS=$FCFLAGS
2863 > FCFLAGS=
2864 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2865 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2866 > if test "${ac_cv_prog_fc_g+set}" = set; then
2867    echo $ECHO_N "(cached) $ECHO_C" >&6
2868   else
2869 <  cat >conftest.$ac_ext <<_ACEOF
2870 < /* confdefs.h.  */
2871 < _ACEOF
2911 < cat confdefs.h >>conftest.$ac_ext
2912 < cat >>conftest.$ac_ext <<_ACEOF
2913 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2916 < main ()
2917 < {
2918 <
2919 <  ;
2920 <  return 0;
2921 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2929 | Line 2881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2881    cat conftest.err >&5
2882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883    (exit $ac_status); } &&
2884 <         { ac_try='test -z "$ac_cxx_werror_flag"
2884 >         { ac_try='test -z "$ac_fc_werror_flag"
2885                           || test ! -s conftest.err'
2886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2887    (eval $ac_try) 2>&5
# Line 2942 | Line 2894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2894    ac_status=$?
2895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2896    (exit $ac_status); }; }; then
2897 <  ac_cv_prog_cxx_g=yes
2897 >  ac_cv_prog_fc_g=yes
2898   else
2899    echo "$as_me: failed program was:" >&5
2900   sed 's/^/| /' conftest.$ac_ext >&5
2901  
2902 < ac_cv_prog_cxx_g=no
2902 > ac_cv_prog_fc_g=no
2903   fi
2904   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2905 +
2906   fi
2907 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2908 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2909 < if test "$ac_test_CXXFLAGS" = set; then
2910 <  CXXFLAGS=$ac_save_CXXFLAGS
2911 < elif test $ac_cv_prog_cxx_g = yes; then
2912 <  if test "$GXX" = yes; then
2913 <    CXXFLAGS="-g -O2"
2907 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2908 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2909 > if test "$ac_test_FFLAGS" = set; then
2910 >  FCFLAGS=$ac_save_FFLAGS
2911 > elif test $ac_cv_prog_fc_g = yes; then
2912 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2913 >    FCFLAGS="-g -O2"
2914    else
2915 <    CXXFLAGS="-g"
2915 >    FCFLAGS="-g"
2916    fi
2917   else
2918 <  if test "$GXX" = yes; then
2919 <    CXXFLAGS="-O2"
2918 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2919 >    FCFLAGS="-O2"
2920    else
2921 <    CXXFLAGS=
2921 >    FCFLAGS=
2922    fi
2970 fi
2971 for ac_declaration in \
2972   '' \
2973   'extern "C" void std::exit (int) throw (); using std::exit;' \
2974   'extern "C" void std::exit (int); using std::exit;' \
2975   'extern "C" void exit (int) throw ();' \
2976   'extern "C" void exit (int);' \
2977   'void exit (int);'
2978 do
2979  cat >conftest.$ac_ext <<_ACEOF
2980 /* confdefs.h.  */
2981 _ACEOF
2982 cat confdefs.h >>conftest.$ac_ext
2983 cat >>conftest.$ac_ext <<_ACEOF
2984 /* end confdefs.h.  */
2985 $ac_declaration
2986 #include <stdlib.h>
2987 int
2988 main ()
2989 {
2990 exit (42);
2991  ;
2992  return 0;
2993 }
2994 _ACEOF
2995 rm -f conftest.$ac_objext
2996 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2997  (eval $ac_compile) 2>conftest.er1
2998  ac_status=$?
2999  grep -v '^ *+' conftest.er1 >conftest.err
3000  rm -f conftest.er1
3001  cat conftest.err >&5
3002  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3003  (exit $ac_status); } &&
3004         { ac_try='test -z "$ac_cxx_werror_flag"
3005                         || test ! -s conftest.err'
3006  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3007  (eval $ac_try) 2>&5
3008  ac_status=$?
3009  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3010  (exit $ac_status); }; } &&
3011         { ac_try='test -s conftest.$ac_objext'
3012  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3013  (eval $ac_try) 2>&5
3014  ac_status=$?
3015  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3016  (exit $ac_status); }; }; then
3017  :
3018 else
3019  echo "$as_me: failed program was:" >&5
3020 sed 's/^/| /' conftest.$ac_ext >&5
3021
3022 continue
2923   fi
3024 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3025  cat >conftest.$ac_ext <<_ACEOF
3026 /* confdefs.h.  */
3027 _ACEOF
3028 cat confdefs.h >>conftest.$ac_ext
3029 cat >>conftest.$ac_ext <<_ACEOF
3030 /* end confdefs.h.  */
3031 $ac_declaration
3032 int
3033 main ()
3034 {
3035 exit (42);
3036  ;
3037  return 0;
3038 }
3039 _ACEOF
3040 rm -f conftest.$ac_objext
3041 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3042  (eval $ac_compile) 2>conftest.er1
3043  ac_status=$?
3044  grep -v '^ *+' conftest.er1 >conftest.err
3045  rm -f conftest.er1
3046  cat conftest.err >&5
3047  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3048  (exit $ac_status); } &&
3049         { ac_try='test -z "$ac_cxx_werror_flag"
3050                         || test ! -s conftest.err'
3051  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3052  (eval $ac_try) 2>&5
3053  ac_status=$?
3054  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3055  (exit $ac_status); }; } &&
3056         { ac_try='test -s conftest.$ac_objext'
3057  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3058  (eval $ac_try) 2>&5
3059  ac_status=$?
3060  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3061  (exit $ac_status); }; }; then
3062  break
3063 else
3064  echo "$as_me: failed program was:" >&5
3065 sed 's/^/| /' conftest.$ac_ext >&5
3066
3067 fi
3068 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3069 done
3070 rm -f conftest*
3071 if test -n "$ac_declaration"; then
3072  echo '#ifdef __cplusplus' >>confdefs.h
3073  echo $ac_declaration      >>confdefs.h
3074  echo '#endif'             >>confdefs.h
3075 fi
2924  
2925   ac_ext=c
2926   ac_cpp='$CPP $CPPFLAGS'
2927   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2928   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2929   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3082
2930  
2931   ac_ext=c
2932   ac_cpp='$CPP $CPPFLAGS'
# Line 3315 | Line 3162 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3162   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3163   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3164  
3318
3165   echo "$as_me:$LINENO: checking for egrep" >&5
3166   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3167   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3331 | Line 3177 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3177   EGREP=$ac_cv_prog_egrep
3178  
3179  
3180 + echo "$as_me:$LINENO: checking whether ln -s works" >&5
3181 + echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3182 + LN_S=$as_ln_s
3183 + if test "$LN_S" = "ln -s"; then
3184 +  echo "$as_me:$LINENO: result: yes" >&5
3185 + echo "${ECHO_T}yes" >&6
3186 + else
3187 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3188 + echo "${ECHO_T}no, using $LN_S" >&6
3189 + fi
3190  
3191 < OOPSE_TEMPLATE_FLAGS=""
3192 < if test $ac_cv_cxx_compiler_gnu = no; then
3193 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3194 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3195 <  echo 'void f(){}' > conftest.cc
3196 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3197 <    echo "$as_me:$LINENO: result: yes" >&5
3191 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3192 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3193 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3194 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3196 > else
3197 >  cat >conftest.make <<\_ACEOF
3198 > all:
3199 >        @echo 'ac_maketemp="$(MAKE)"'
3200 > _ACEOF
3201 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3202 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3203 > if test -n "$ac_maketemp"; then
3204 >  eval ac_cv_prog_make_${ac_make}_set=yes
3205 > else
3206 >  eval ac_cv_prog_make_${ac_make}_set=no
3207 > fi
3208 > rm -f conftest.make
3209 > fi
3210 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3211 >  echo "$as_me:$LINENO: result: yes" >&5
3212   echo "${ECHO_T}yes" >&6
3213 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3213 >  SET_MAKE=
3214 > else
3215 >  echo "$as_me:$LINENO: result: no" >&5
3216   echo "${ECHO_T}no" >&6
3217 +  SET_MAKE="MAKE=${MAKE-make}"
3218 + fi
3219 +
3220 + if test -n "$ac_tool_prefix"; then
3221 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3222 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3223 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3226 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3227 + else
3228 +  if test -n "$RANLIB"; then
3229 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3230 + else
3231 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 + for as_dir in $PATH
3233 + do
3234 +  IFS=$as_save_IFS
3235 +  test -z "$as_dir" && as_dir=.
3236 +  for ac_exec_ext in '' $ac_executable_extensions; do
3237 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3239 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240 +    break 2
3241    fi
3242 <  rm -f conftest*
3243 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3244 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3245 <  echo 'void f(){}' > conftest.cc
3246 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3247 <    echo "$as_me:$LINENO: result: yes" >&5
3248 < echo "${ECHO_T}yes" >&6
3249 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3250 <  else
3251 <    echo "$as_me:$LINENO: result: no" >&5
3242 > done
3243 > done
3244 >
3245 > fi
3246 > fi
3247 > RANLIB=$ac_cv_prog_RANLIB
3248 > if test -n "$RANLIB"; then
3249 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3250 > echo "${ECHO_T}$RANLIB" >&6
3251 > else
3252 >  echo "$as_me:$LINENO: result: no" >&5
3253   echo "${ECHO_T}no" >&6
3254 + fi
3255 +
3256 + fi
3257 + if test -z "$ac_cv_prog_RANLIB"; then
3258 +  ac_ct_RANLIB=$RANLIB
3259 +  # Extract the first word of "ranlib", so it can be a program name with args.
3260 + set dummy ranlib; ac_word=$2
3261 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3262 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3263 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3264 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3265 + else
3266 +  if test -n "$ac_ct_RANLIB"; then
3267 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3268 + else
3269 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3270 + for as_dir in $PATH
3271 + do
3272 +  IFS=$as_save_IFS
3273 +  test -z "$as_dir" && as_dir=.
3274 +  for ac_exec_ext in '' $ac_executable_extensions; do
3275 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3276 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3277 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3278 +    break 2
3279    fi
3280 <  rm -f conftest*
3281 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3282 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3283 <  echo 'void f(){}' > conftest.cc
3284 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3285 <    echo "$as_me:$LINENO: result: yes" >&5
3286 < echo "${ECHO_T}yes" >&6
3287 <    OOPSE_TEMPLATE_FLAGS="-pto"
3288 <  else
3289 <    echo "$as_me:$LINENO: result: no" >&5
3280 > done
3281 > done
3282 >
3283 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284 > fi
3285 > fi
3286 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3287 > if test -n "$ac_ct_RANLIB"; then
3288 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3289 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3290 > else
3291 >  echo "$as_me:$LINENO: result: no" >&5
3292   echo "${ECHO_T}no" >&6
3293 + fi
3294 +
3295 +  RANLIB=$ac_ct_RANLIB
3296 + else
3297 +  RANLIB="$ac_cv_prog_RANLIB"
3298 + fi
3299 +
3300 +
3301 +   # Extract the first word of "perl", so it can be a program name with args.
3302 + set dummy perl; ac_word=$2
3303 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3304 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3305 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3306 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3307 + else
3308 +  case $PERLINTERP in
3309 +  [\\/]* | ?:[\\/]*)
3310 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3311 +  ;;
3312 +  *)
3313 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3314 + for as_dir in $PATH
3315 + do
3316 +  IFS=$as_save_IFS
3317 +  test -z "$as_dir" && as_dir=.
3318 +  for ac_exec_ext in '' $ac_executable_extensions; do
3319 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3320 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3321 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3322 +    break 2
3323    fi
3324 <  rm -f conftest*
3325 <  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
3324 > done
3325 > done
3326  
3327 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3328 +  ;;
3329 + esac
3330 + fi
3331 + PERLINTERP=$ac_cv_path_PERLINTERP
3332  
3333 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3334 <  else
3335 <    echo "$as_me:$LINENO: result: no" >&5
3333 > if test -n "$PERLINTERP"; then
3334 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3335 > echo "${ECHO_T}$PERLINTERP" >&6
3336 > else
3337 >  echo "$as_me:$LINENO: result: no" >&5
3338   echo "${ECHO_T}no" >&6
3339 + fi
3340 +
3341 +   ac_cv_path_perlinterp="$PERLINTERP"
3342 +   _sHpB='#!'
3343 +
3344 +
3345 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3346 + if test "${with_perl_shebang+set}" = set; then
3347 +  withval="$with_perl_shebang"
3348 +  opt_perl_shebang="$withval"
3349 + else
3350 +                opt_perl_shebang="not_set"
3351 + fi;
3352 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3353 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3354 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3356 + else
3357 +   case "$opt_perl_shebang" in
3358 +                      not_set  ) ax_cv_opt_perl_shebang=''
3359 +                               ;;
3360 +                         *     )
3361 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3362 +                    esac
3363 +
3364 + fi
3365 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3366 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3367 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3368 +     then
3369 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3370 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3371 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3372 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3373 +
3374 + # Automatic detection of sharpbang formula starts here
3375 +     else
3376 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3377 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3378 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3379 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3380 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3381 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3382 + else
3383 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3384 +        if test "x$_somian_kspb_perl" == x
3385 +          then _somian_ksbp_warn_empty='durnit'
3386 +          else
3387 +          case "A$_somian_kspb_perl" in
3388 +                 A#!*perl* )
3389 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3390 +                        ;;
3391 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3392 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3393 +          esac
3394 +        fi
3395 +
3396 + fi
3397 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3398 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3399 + # The above prints Checking ... result message to user.
3400 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3401 +
3402 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3403 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3404 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3405 +    fi
3406 + # Inform user after printing result value
3407 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3408 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3409 + echo "$as_me: Maybe Not good -" >&6;}
3410 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3411 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3412 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3413 + echo "$as_me: OK Good result - " >&6;}
3414 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3415 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3416 +    fi
3417    fi
3418 +
3419 + # Find a good install program.  We prefer a C program (faster),
3420 + # so one script is as good as another.  But avoid the broken or
3421 + # incompatible versions:
3422 + # SysV /etc/install, /usr/sbin/install
3423 + # SunOS /usr/etc/install
3424 + # IRIX /sbin/install
3425 + # AIX /bin/install
3426 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3427 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3428 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3429 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3430 + # OS/2's system install, which has a completely different semantic
3431 + # ./install, which can be erroneously created by make from ./install.sh.
3432 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3433 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3434 + if test -z "$INSTALL"; then
3435 + if test "${ac_cv_path_install+set}" = set; then
3436 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3437 + else
3438 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3439 + for as_dir in $PATH
3440 + do
3441 +  IFS=$as_save_IFS
3442 +  test -z "$as_dir" && as_dir=.
3443 +  # Account for people who put trailing slashes in PATH elements.
3444 + case $as_dir/ in
3445 +  ./ | .// | /cC/* | \
3446 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3447 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3448 +  /usr/ucb/* ) ;;
3449 +  *)
3450 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3451 +    # Don't use installbsd from OSF since it installs stuff as root
3452 +    # by default.
3453 +    for ac_prog in ginstall scoinst install; do
3454 +      for ac_exec_ext in '' $ac_executable_extensions; do
3455 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3456 +          if test $ac_prog = install &&
3457 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3458 +            # AIX install.  It has an incompatible calling convention.
3459 +            :
3460 +          elif test $ac_prog = install &&
3461 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3462 +            # program-specific install script used by HP pwplus--don't use.
3463 +            :
3464 +          else
3465 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3466 +            break 3
3467 +          fi
3468 +        fi
3469 +      done
3470 +    done
3471 +    ;;
3472 + esac
3473 + done
3474 +
3475 +
3476   fi
3477 +  if test "${ac_cv_path_install+set}" = set; then
3478 +    INSTALL=$ac_cv_path_install
3479 +  else
3480 +    # As a last resort, use the slow shell script.  We don't cache a
3481 +    # path for INSTALL within a source directory, because that will
3482 +    # break other packages using the cache if that directory is
3483 +    # removed, or if the path is relative.
3484 +    INSTALL=$ac_install_sh
3485 +  fi
3486 + fi
3487 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3488 + echo "${ECHO_T}$INSTALL" >&6
3489  
3490 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3491 + # It thinks the first close brace ends the variable substitution.
3492 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3493  
3494 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3495  
3496 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3497  
3498 < ac_ext=f90
3499 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3500 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3501 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3502 < if test -n "$ac_tool_prefix"; then
3503 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3504 <  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
3498 > case "x$INSTALL" in
3499 >   x/*) ;;
3500 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3501 > esac
3502 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3503 > # Extract the first word of "ar", so it can be a program name with args.
3504 > set dummy ar; ac_word=$2
3505   echo "$as_me:$LINENO: checking for $ac_word" >&5
3506   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3507 < if test "${ac_cv_prog_F90+set}" = set; then
3507 > if test "${ac_cv_prog_AR+set}" = set; then
3508    echo $ECHO_N "(cached) $ECHO_C" >&6
3509   else
3510 <  if test -n "$F90"; then
3511 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3510 >  if test -n "$AR"; then
3511 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3512   else
3513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3514   for as_dir in $PATH
# Line 3412 | Line 3517 | do
3517    test -z "$as_dir" && as_dir=.
3518    for ac_exec_ext in '' $ac_executable_extensions; do
3519    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3520 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3520 >    ac_cv_prog_AR="ar"
3521      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3522      break 2
3523    fi
3524   done
3525   done
3526  
3527 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3528   fi
3529   fi
3530 < F90=$ac_cv_prog_F90
3531 < if test -n "$F90"; then
3532 <  echo "$as_me:$LINENO: result: $F90" >&5
3533 < echo "${ECHO_T}$F90" >&6
3530 > AR=$ac_cv_prog_AR
3531 > if test -n "$AR"; then
3532 >  echo "$as_me:$LINENO: result: $AR" >&5
3533 > echo "${ECHO_T}$AR" >&6
3534   else
3535    echo "$as_me:$LINENO: result: no" >&5
3536   echo "${ECHO_T}no" >&6
3537   fi
3538  
3539 <    test -n "$F90" && break
3540 <  done
3539 > if test "$AR" = "NONE"; then
3540 >  cat >confcache <<\_ACEOF
3541 > # This file is a shell script that caches the results of configure
3542 > # tests run on this system so they can be shared between configure
3543 > # scripts and configure runs, see configure's option --config-cache.
3544 > # It is not useful on other systems.  If it contains results you don't
3545 > # want to keep, you may remove or edit it.
3546 > #
3547 > # config.status only pays attention to the cache file if you give it
3548 > # the --recheck option to rerun configure.
3549 > #
3550 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3551 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3552 > # following values.
3553 >
3554 > _ACEOF
3555 >
3556 > # The following way of writing the cache mishandles newlines in values,
3557 > # but we know of no workaround that is simple, portable, and efficient.
3558 > # So, don't put newlines in cache variables' values.
3559 > # Ultrix sh set writes to stderr and can't be redirected directly,
3560 > # and sets the high bit in the cache file unless we assign to the vars.
3561 > {
3562 >  (set) 2>&1 |
3563 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3564 >    *ac_space=\ *)
3565 >      # `set' does not quote correctly, so add quotes (double-quote
3566 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3567 >      sed -n \
3568 >        "s/'/'\\\\''/g;
3569 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3570 >      ;;
3571 >    *)
3572 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3573 >      sed -n \
3574 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3575 >      ;;
3576 >    esac;
3577 > } |
3578 >  sed '
3579 >     t clear
3580 >     : clear
3581 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3582 >     t end
3583 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3584 >     : end' >>confcache
3585 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3586 >  if test -w $cache_file; then
3587 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3588 >    cat confcache >$cache_file
3589 >  else
3590 >    echo "not updating unwritable cache $cache_file"
3591 >  fi
3592   fi
3593 < if test -z "$F90"; then
3594 <  ac_ct_F90=$F90
3595 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3596 < do
3597 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3441 < set dummy $ac_prog; ac_word=$2
3593 > rm -f confcache
3594 >  exit 1
3595 > fi
3596 > # Extract the first word of "ps", so it can be a program name with args.
3597 > set dummy ps; ac_word=$2
3598   echo "$as_me:$LINENO: checking for $ac_word" >&5
3599   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3600 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3600 > if test "${ac_cv_path_PS+set}" = set; then
3601    echo $ECHO_N "(cached) $ECHO_C" >&6
3602   else
3603 <  if test -n "$ac_ct_F90"; then
3604 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3605 < else
3606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3603 >  case $PS in
3604 >  [\\/]* | ?:[\\/]*)
3605 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3606 >  ;;
3607 >  *)
3608 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3609   for as_dir in $PATH
3610   do
3611    IFS=$as_save_IFS
3612    test -z "$as_dir" && as_dir=.
3613    for ac_exec_ext in '' $ac_executable_extensions; do
3614    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3615 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3615 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3616      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3617      break 2
3618    fi
3619   done
3620   done
3621  
3622 +  ;;
3623 + esac
3624   fi
3625 < fi
3626 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3627 < if test -n "$ac_ct_F90"; then
3628 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3629 < echo "${ECHO_T}$ac_ct_F90" >&6
3625 > PS=$ac_cv_path_PS
3626 >
3627 > if test -n "$PS"; then
3628 >  echo "$as_me:$LINENO: result: $PS" >&5
3629 > echo "${ECHO_T}$PS" >&6
3630   else
3631    echo "$as_me:$LINENO: result: no" >&5
3632   echo "${ECHO_T}no" >&6
3633   fi
3634  
3635 <  test -n "$ac_ct_F90" && break
3636 < done
3635 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3636 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3637 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3639 > else
3640  
3641 <  F90=$ac_ct_F90
3641 >        if $PS ax -o rss > /dev/null 2>&1; then
3642 >                ac_cv_prog_ps_ax=yes
3643 >        else
3644 >                ac_cv_prog_ps_ax=no
3645 >        fi
3646 >        if $PS -ef -o rss > /dev/null 2>&1; then
3647 >                ac_cv_prog_ps_ef=yes
3648 >        else
3649 >                ac_cv_prog_ps_ef=no
3650 >        fi
3651 >        if test "$ac_cv_prog_ps_ax" = yes; then
3652 >                ac_cv_prog_ps_syntax=BSD
3653 >        else
3654 >                if test "$ac_cv_prog_ps_ef" = yes; then
3655 >                        ac_cv_prog_ps_syntax=POSIX
3656 >                else
3657 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3658 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3659 >   { (exit 1); exit 1; }; }
3660 >                fi
3661 >        fi
3662 >
3663   fi
3664 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3665 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3666  
3667 + cat >>confdefs.h <<_ACEOF
3668 + #define PSCOMMAND $PS
3669 + _ACEOF
3670  
3671 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3672 < # input file.
3673 < ac_save_ext=$ac_ext
3674 < ac_ext=F90
3675 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3676 < 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
3671 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3672 >
3673 > cat >>confdefs.h <<\_ACEOF
3674 > #define PSTYPE_IS_BSD 1
3675 > _ACEOF
3676 >
3677   else
3678 <  cat >conftest.$ac_ext <<_ACEOF
3678 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679  
3680 < program main
3680 > cat >>confdefs.h <<\_ACEOF
3681 > #define PSTYPE_IS_POSIX 1
3682 > _ACEOF
3683  
3684 < #ifndef __GNUC__
3685 <       choke me
3686 < #endif
3684 >   else
3685 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3686 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3687 >   { (exit 1); exit 1; }; }
3688 >   fi
3689 > fi
3690  
3691 < end program main
3691 > ac_ext=${FC_SRCEXT-f}
3692 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3693 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3694 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3695 >
3696 >
3697 > echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3698 > echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3699 > if test "${ac_cv_fc_srcext_F90+set}" = set; then
3700 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3701 > else
3702 >  ac_ext=F90
3703 > ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3704 > FCFLAGS_SRCEXT=""
3705 > ac_cv_fc_srcext_F90=unknown
3706 > for ac_flag in none -qsuffix=f=F90 -Tf; do
3707 >  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3708 >  cat >conftest.$ac_ext <<_ACEOF
3709 >      program main
3710  
3711 +      end
3712   _ACEOF
3713   rm -f conftest.$ac_objext
3714   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3508 | Line 3719 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3719    cat conftest.err >&5
3720    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3721    (exit $ac_status); } &&
3722 <         { ac_try='test -z "$ac_f90_werror_flag"
3722 >         { ac_try='test -z "$ac_fc_werror_flag"
3723                           || test ! -s conftest.err'
3724    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3725    (eval $ac_try) 2>&5
# Line 3521 | Line 3732 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3732    ac_status=$?
3733    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3734    (exit $ac_status); }; }; then
3735 <  ac_compiler_gnu=yes
3735 >  ac_cv_fc_srcext_F90=$ac_flag; break
3736   else
3737    echo "$as_me: failed program was:" >&5
3738   sed 's/^/| /' conftest.$ac_ext >&5
3739  
3529 ac_compiler_gnu=no
3740   fi
3741   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3742 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3742 > done
3743 > rm -f conftest.$ac_objext conftest.F90
3744 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3745  
3746   fi
3747 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3748 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3749 < ac_ext=$ac_save_ext
3750 < G95=`test $ac_compiler_gnu = yes && echo yes`
3751 < ac_ext=c
3752 < ac_cpp='$CPP $CPPFLAGS'
3753 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3754 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3747 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3748 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3749 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3750 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3751 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3752 >   { (exit 1); exit 1; }; }
3753 > else
3754 >  FC_SRCEXT=F90
3755 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3756 >    FCFLAGS_SRCEXT=""
3757 >    FCFLAGS_F90=""
3758 >  else
3759 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3760 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3761 >  fi
3762  
3763  
3764 + fi
3765  
3766  
3767  
3768 +
3769 +
3770   # Try to determine native compiler flags that allow us to use F90 suffix
3771   # for preprocessed f90 source.
3772  
# Line 3553 | Line 3774 | if test "$ac_test_PREPFLAG" != "set"; then
3774    PREPFLAG=""
3775    case "${host_cpu}-${host_os}" in
3776  
3777 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3777 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3778                      PREPFLAG="-fpp1 "
3779                  fi;;
3780 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3780 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3781                      PREPFLAG="-qsuffix=cpp=F90 "
3782                  fi;;
3783    *darwin*)
3784 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3784 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3785                  PREPFLAG="-qsuffix=cpp=F90 "
3786          fi;;
3787    esac
# Line 3575 | Line 3796 | echo $ECHO_N "checking to make sure F90 preprocessor f
3796   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3797  
3798  
3799 <  ac_ext=f90
3800 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3801 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3802 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3799 >  ac_ext=${FC_SRCEXT-f}
3800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3803  
3804    ac_save_ext=$ac_ext
3805    ac_ext=F90
3806 <  ac_save_F90FLAGS=$F90FLAGS
3806 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3807  
3808    if test "$PREPFLAG"; then
3809 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3809 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3810   fi
3811  
3812      cat >conftest.$ac_ext <<_ACEOF
3813  
3814  
3815 < program main
3595 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3599
3600 end program main
3601
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3609 | Line 3827 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827    cat conftest.err >&5
3828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3829    (exit $ac_status); } &&
3830 <         { ac_try='test -z "$ac_f90_werror_flag"
3830 >         { ac_try='test -z "$ac_fc_werror_flag"
3831                           || test ! -s conftest.err'
3832    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3833    (eval $ac_try) 2>&5
# Line 3631 | Line 3849 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3849   fi
3850   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3851  
3852 <  F90FLAGS=$ac_save_F90FLAGS
3852 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3853    ac_ext=$ac_save_ext
3854 <  ac_ext=c
3855 < ac_cpp='$CPP $CPPFLAGS'
3856 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3857 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3640 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3854 >  ac_ext=${FC_SRCEXT-f}
3855 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3856 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3857 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3858  
3859  
3860    if test "$prepflagworks" = 1; then
3861      echo "$as_me:$LINENO: result: yes" >&5
3862   echo "${ECHO_T}yes" >&6
3863 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3864  
3865    else
3866      echo "$as_me:$LINENO: result: no" >&5
# Line 3664 | Line 3882 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3882    PREPDEFFLAG=""
3883    case "${host_cpu}-${host_os}" in
3884  
3885 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3885 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3886                      PREPDEFFLAG=" "
3887                  fi;;
3888 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3888 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3889                      PREPDEFFLAG="-WF,"
3890                  fi;;
3891    *darwin*)
3892 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3892 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3893                  PREPDEFFLAG="-WF,"
3894          fi;;
3895    esac
# Line 3686 | Line 3904 | echo $ECHO_N "checking to make sure F90 preprocessor d
3904   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3905  
3906  
3907 <  ac_ext=f90
3908 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3909 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3907 >  ac_ext=${FC_SRCEXT-f}
3908 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3909 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3910 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3911  
3912    ac_save_ext=$ac_ext
3913    ac_ext=F90
3914 <  ac_save_F90FLAGS=$F90FLAGS
3914 >  ac_save_FCFLAGS=$FCFLAGS
3915  
3916    if test "$PREPDEFFLAG"; then
3917 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3917 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3918   fi
3919  
3920      cat >conftest.$ac_ext <<_ACEOF
3921  
3922  
3923 < program main
3706 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3714
3715 end program main
3716
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3724 | Line 3939 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3939    cat conftest.err >&5
3940    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3941    (exit $ac_status); } &&
3942 <         { ac_try='test -z "$ac_f90_werror_flag"
3942 >         { ac_try='test -z "$ac_fc_werror_flag"
3943                           || test ! -s conftest.err'
3944    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3945    (eval $ac_try) 2>&5
# Line 3746 | Line 3961 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3961   fi
3962   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3963  
3964 <  F90FLAGS=$ac_save_F90FLAGS
3964 >  FCFLAGS=$ac_save_FCFLAGS
3965    ac_ext=$ac_save_ext
3966 <  ac_ext=c
3967 < ac_cpp='$CPP $CPPFLAGS'
3968 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3969 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3966 >  ac_ext=${FC_SRCEXT-f}
3967 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3968 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3969 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3970  
3971  
3758
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3769 | Line 3982 | fi
3982    fi
3983   fi
3984  
3985 < ac_ext=f90
3986 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3987 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3988 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3989 <
3990 <
3991 <
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
3985 > ac_ext=${FC_SRCEXT-f}
3986 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3987 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3988 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3989 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3990 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3991 > if test "${ac_cv_prog_fc_v+set}" = set; then
3992    echo $ECHO_N "(cached) $ECHO_C" >&6
3993   else
3994 +  cat >conftest.$ac_ext <<_ACEOF
3995 +      program main
3996  
3997 < cat >conftest.$ac_ext <<_ACEOF
3790 <
3791 < program main
3792 <
3793 <
3794 < end program main
3795 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3803 | Line 4005 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4005    cat conftest.err >&5
4006    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007    (exit $ac_status); } &&
4008 <         { ac_try='test -z "$ac_f90_werror_flag"
4008 >         { ac_try='test -z "$ac_fc_werror_flag"
4009                           || test ! -s conftest.err'
4010    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4011    (eval $ac_try) 2>&5
# Line 3816 | Line 4018 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018    ac_status=$?
4019    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020    (exit $ac_status); }; }; then
4021 <  ac_cv_prog_f90_v=
4021 >  ac_cv_prog_fc_v=
4022   # Try some options frequently used verbose output
4023   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4024 <  ac_ext=f90
4025 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
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
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3828 <
3829 < program main
3830 <
3831 <
3832 < end program main
3833 <
4027 >      end
4028   _ACEOF
4029  
4030   # Compile and link our simple test program by passing a flag (argument
4031 < # 1 to this macro) to the Fortran 90 compiler in order to get
4032 < # "verbose" output that we can then parse for the Fortran 90 linker
4031 > # 1 to this macro) to the Fortran compiler in order to get
4032 > # "verbose" output that we can then parse for the Fortran linker
4033   # flags.
4034 < ac_save_F90FLAGS=$F90FLAGS
4035 < F90FLAGS="$F90FLAGS $ac_verb"
4034 > ac_save_FFLAGS=$FCFLAGS
4035 > FCFLAGS="$FCFLAGS $ac_verb"
4036 > (eval echo $as_me:4036: \"$ac_link\") >&5
4037 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4038 > echo "$ac_fc_v_output" >&5
4039 > FCFLAGS=$ac_save_FFLAGS
4040  
4041 < (eval echo $as_me: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
4041 > rm -f conftest*
4042  
4043 < rm -f conftest.*
4044 < ac_ext=f90
4045 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4046 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4047 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4043 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4044 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4045 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4046 > ac_fc_v_output="`echo $ac_fc_v_output |
4047 >        grep 'LPATH is:' |
4048 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4049  
4050 < # If we are using xlf then replace all the commas with spaces.
4051 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4052 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4053 < fi
4050 > case $ac_fc_v_output in
4051 >  # If we are using xlf then replace all the commas with spaces.
4052 >  *xlfentry*)
4053 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4054  
4055 < # If we are using Cray Fortran then delete quotes.
4056 < # Use "\"" instead of '"' for font-lock-mode.
4057 < # FIXME: a more general fix for quoted arguments with spaces?
4058 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4059 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4060 < fi
4055 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4056 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4057 >  *mGLOB_options_string*)
4058 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4059 >
4060 >  # If we are using Cray Fortran then delete quotes.
4061 >  # Use "\"" instead of '"' for font-lock-mode.
4062 >  # FIXME: a more general fix for quoted arguments with spaces?
4063 >  *cft90*)
4064 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4065 > esac
4066 >
4067 >
4068    # look for -l* and *.a constructs in the output
4069 <  for ac_arg in $ac_f90_v_output; do
4069 >  for ac_arg in $ac_fc_v_output; do
4070       case $ac_arg in
4071          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4072 <          ac_cv_prog_f90_v=$ac_verb
4072 >          ac_cv_prog_fc_v=$ac_verb
4073            break 2 ;;
4074       esac
4075    done
4076   done
4077 < if test -z "$ac_cv_prog_f90_v"; then
4078 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4079 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4077 > if test -z "$ac_cv_prog_fc_v"; then
4078 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4079 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4080   fi
4081   else
4082    echo "$as_me: failed program was:" >&5
# Line 3885 | Line 4088 | fi
4088   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089  
4090   fi
4091 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4092 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4093 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4094 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4095 < if test "${ac_cv_flibs+set}" = set; then
4096 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3894 < else
3895 <  if test "x$F90LIBS" != "x"; then
3896 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4091 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4092 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4093 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4094 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4095 > if test "${ac_cv_fc_libs+set}" = set; then
4096 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4097   else
4098 +  if test "x$FCLIBS" != "x"; then
4099 +  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4100 + else
4101  
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
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3907 <
3908 <
3909 < end program main
3910 <
4105 >      end
4106   _ACEOF
4107  
4108   # Compile and link our simple test program by passing a flag (argument
4109 < # 1 to this macro) to the Fortran 90 compiler in order to get
4110 < # "verbose" output that we can then parse for the Fortran 90 linker
4109 > # 1 to this macro) to the Fortran compiler in order to get
4110 > # "verbose" output that we can then parse for the Fortran linker
4111   # flags.
4112 < ac_save_F90FLAGS=$F90FLAGS
4113 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4112 > ac_save_FFLAGS=$FCFLAGS
4113 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4114 > (eval echo $as_me:4114: \"$ac_link\") >&5
4115 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4116 > echo "$ac_fc_v_output" >&5
4117 > FCFLAGS=$ac_save_FFLAGS
4118  
4119 < (eval echo $as_me: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
4119 > rm -f conftest*
4120  
4121 < rm -f conftest.*
4122 < ac_ext=f90
4123 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4124 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4125 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4121 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4122 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4123 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4124 > ac_fc_v_output="`echo $ac_fc_v_output |
4125 >        grep 'LPATH is:' |
4126 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4127  
4128 < # If we are using xlf then replace all the commas with spaces.
4129 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4130 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4131 < fi
4128 > case $ac_fc_v_output in
4129 >  # If we are using xlf then replace all the commas with spaces.
4130 >  *xlfentry*)
4131 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4132  
4133 < # If we are using Cray Fortran then delete quotes.
4134 < # Use "\"" instead of '"' for font-lock-mode.
4135 < # FIXME: a more general fix for quoted arguments with spaces?
4136 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3940 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3941 < fi
4133 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4134 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4135 >  *mGLOB_options_string*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4137  
4138 < ac_cv_f90libs=
4138 >  # If we are using Cray Fortran then delete quotes.
4139 >  # Use "\"" instead of '"' for font-lock-mode.
4140 >  # FIXME: a more general fix for quoted arguments with spaces?
4141 >  *cft90*)
4142 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4143 > esac
4144  
4145 +
4146 +
4147 + ac_cv_fc_libs=
4148 +
4149   # Save positional arguments (if any)
4150   ac_save_positional="$@"
4151  
4152 < set X $ac_f90_v_output
4152 > set X $ac_fc_v_output
4153   while test $# != 1; do
4154    shift
4155    ac_arg=$1
4156    case $ac_arg in
4157          [\\/]*.a | ?:[\\/]*.a)
4158              ac_exists=false
4159 <  for ac_i in $ac_cv_f90libs; do
4159 >  for ac_i in $ac_cv_fc_libs; do
4160      if test x"$ac_arg" = x"$ac_i"; then
4161        ac_exists=true
4162        break
# Line 3962 | Line 4166 | else
4166    if test x"$ac_exists" = xtrue; then
4167    :
4168   else
4169 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4169 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4170   fi
4171  
4172            ;;
4173          -bI:*)
4174              ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_arg" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 3980 | Line 4184 | else
4184   else
4185    if test "$ac_compiler_gnu" = yes; then
4186    for ac_link_opt in $ac_arg; do
4187 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4187 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4188    done
4189   else
4190 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4190 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4191   fi
4192   fi
4193  
4194            ;;
4195            # Ignore these flags.
4196 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4196 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4197            ;;
4198          -lkernel32)
4199 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4199 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4200            ;;
4201          -[LRuY])
4202            # These flags, when seen by themselves, take an argument.
4203            # We remove the space between option and argument and re-iterate
4204            # unless we find an empty arg or a new option (starting with -)
4205            case $2 in
4206 <             "" | -*);;
4207 <             *)
4206 >             "" | -*);;
4207 >             *)
4208                  ac_arg="$ac_arg$2"
4005
4209                  shift; shift
4210                  set X $ac_arg "$@"
4211                  ;;
# Line 4011 | Line 4214 | fi
4214          -YP,*)
4215            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4216                ac_exists=false
4217 <  for ac_i in $ac_cv_f90libs; do
4217 >  for ac_i in $ac_cv_fc_libs; do
4218      if test x"$ac_j" = x"$ac_i"; then
4219        ac_exists=true
4220        break
# Line 4022 | Line 4225 | else
4225    :
4226   else
4227    ac_arg="$ac_arg $ac_j"
4228 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4228 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4229   fi
4230  
4231            done
4232            ;;
4233          -[lLR]*)
4234              ac_exists=false
4235 <  for ac_i in $ac_cv_f90libs; do
4235 >  for ac_i in $ac_cv_fc_libs; do
4236      if test x"$ac_arg" = x"$ac_i"; then
4237        ac_exists=true
4238        break
# Line 4039 | Line 4242 | else
4242    if test x"$ac_exists" = xtrue; then
4243    :
4244   else
4245 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4245 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4246   fi
4247  
4248            ;;
# Line 4054 | Line 4257 | case `(uname -sr) 2>/dev/null` in
4257   # must begin with a "/").
4258   case `(uname -sr) 2>/dev/null` in
4259     "SunOS 5"*)
4260 <      ac_ld_run_path=`echo $ac_f90_v_output |
4260 >      ac_ld_run_path=`echo $ac_fc_v_output |
4261                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4262        test "x$ac_ld_run_path" != x &&
4060
4263          if test "$ac_compiler_gnu" = yes; then
4264    for ac_link_opt in $ac_ld_run_path; do
4265 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4265 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4266    done
4267   else
4268 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4268 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4269   fi
4270        ;;
4271   esac
4272 < fi # test "x$F90LIBS" = "x"
4272 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4273  
4274   fi
4275 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4276 < echo "${ECHO_T}$ac_cv_flibs" >&6
4277 < F90LIBS="$ac_cv_f90libs"
4275 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4276 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4277 > FCLIBS="$ac_cv_fc_libs"
4278  
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
4279  
4280 + ac_ext=${FC_SRCEXT-f}
4281 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4282 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4283 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4284  
4285 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4286 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4287 < if test "${ac_cv_f90_mangling+set}" = set; then
4285 >
4286 > ac_ext=${FC_SRCEXT-f}
4287 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4288 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4289 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4290 >
4291 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4292 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4293 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4294    echo $ECHO_N "(cached) $ECHO_C" >&6
4295   else
4296 <  ac_ext=f90
4297 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4298 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4299 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4300 < cat >conftest.$ac_ext <<_ACEOF
4301 < subroutine foobar()
4302 < return
4303 < end
4304 < subroutine foo_bar()
4305 < return
4306 < end
4296 >  ac_fc_dm_save_LIBS=$LIBS
4297 > LIBS="$LIBS $FCLIBS"
4298 > ac_fortran_dm_var=FC_DUMMY_MAIN
4299 > ac_ext=c
4300 > ac_cpp='$CPP $CPPFLAGS'
4301 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4302 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4303 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4304 >
4305 > # First, try linking without a dummy main:
4306 > cat >conftest.$ac_ext <<_ACEOF
4307 > /* confdefs.h.  */
4308   _ACEOF
4309 + cat confdefs.h >>conftest.$ac_ext
4310 + cat >>conftest.$ac_ext <<_ACEOF
4311 + /* end confdefs.h.  */
4312 +
4313 + #ifdef FC_DUMMY_MAIN
4314 + #ifndef FC_DUMMY_MAIN_EQ_F77
4315 + #  ifdef __cplusplus
4316 +     extern "C"
4317 + #  endif
4318 +   int FC_DUMMY_MAIN() { return 1; }
4319 + #endif
4320 + #endif
4321 + int
4322 + main ()
4323 + {
4324 +
4325 +  ;
4326 +  return 0;
4327 + }
4328 + _ACEOF
4329 + rm -f conftest.$ac_objext conftest$ac_exeext
4330 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4331 +  (eval $ac_link) 2>conftest.er1
4332 +  ac_status=$?
4333 +  grep -v '^ *+' conftest.er1 >conftest.err
4334 +  rm -f conftest.er1
4335 +  cat conftest.err >&5
4336 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4337 +  (exit $ac_status); } &&
4338 +         { ac_try='test -z "$ac_c_werror_flag"
4339 +                         || test ! -s conftest.err'
4340 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4341 +  (eval $ac_try) 2>&5
4342 +  ac_status=$?
4343 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4344 +  (exit $ac_status); }; } &&
4345 +         { ac_try='test -s conftest$ac_exeext'
4346 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4347 +  (eval $ac_try) 2>&5
4348 +  ac_status=$?
4349 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4350 +  (exit $ac_status); }; }; then
4351 +  ac_cv_fortran_dummy_main=none
4352 + else
4353 +  echo "$as_me: failed program was:" >&5
4354 + sed 's/^/| /' conftest.$ac_ext >&5
4355 +
4356 + ac_cv_fortran_dummy_main=unknown
4357 + fi
4358 + rm -f conftest.err conftest.$ac_objext \
4359 +      conftest$ac_exeext conftest.$ac_ext
4360 +
4361 + if test $ac_cv_fortran_dummy_main = unknown; then
4362 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4363 +     cat >conftest.$ac_ext <<_ACEOF
4364 + /* confdefs.h.  */
4365 + _ACEOF
4366 + cat confdefs.h >>conftest.$ac_ext
4367 + cat >>conftest.$ac_ext <<_ACEOF
4368 + /* end confdefs.h.  */
4369 + #define $ac_fortran_dm_var $ac_func
4370 + #ifdef FC_DUMMY_MAIN
4371 + #ifndef FC_DUMMY_MAIN_EQ_F77
4372 + #  ifdef __cplusplus
4373 +     extern "C"
4374 + #  endif
4375 +   int FC_DUMMY_MAIN() { return 1; }
4376 + #endif
4377 + #endif
4378 + int
4379 + main ()
4380 + {
4381 +
4382 +  ;
4383 +  return 0;
4384 + }
4385 + _ACEOF
4386 + rm -f conftest.$ac_objext conftest$ac_exeext
4387 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4388 +  (eval $ac_link) 2>conftest.er1
4389 +  ac_status=$?
4390 +  grep -v '^ *+' conftest.er1 >conftest.err
4391 +  rm -f conftest.er1
4392 +  cat conftest.err >&5
4393 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4394 +  (exit $ac_status); } &&
4395 +         { ac_try='test -z "$ac_c_werror_flag"
4396 +                         || test ! -s conftest.err'
4397 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4398 +  (eval $ac_try) 2>&5
4399 +  ac_status=$?
4400 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4401 +  (exit $ac_status); }; } &&
4402 +         { ac_try='test -s conftest$ac_exeext'
4403 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4404 +  (eval $ac_try) 2>&5
4405 +  ac_status=$?
4406 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4407 +  (exit $ac_status); }; }; then
4408 +  ac_cv_fortran_dummy_main=$ac_func; break
4409 + else
4410 +  echo "$as_me: failed program was:" >&5
4411 + sed 's/^/| /' conftest.$ac_ext >&5
4412 +
4413 + fi
4414 + rm -f conftest.err conftest.$ac_objext \
4415 +      conftest$ac_exeext conftest.$ac_ext
4416 +   done
4417 + fi
4418 + ac_ext=${FC_SRCEXT-f}
4419 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4420 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4421 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4422 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4423 + rm -f conftest*
4424 + LIBS=$ac_fc_dm_save_LIBS
4425 +
4426 + fi
4427 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4428 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4429 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4430 + if test "$FC_DUMMY_MAIN" != unknown; then
4431 +  if test $FC_DUMMY_MAIN != none; then
4432 +
4433 + cat >>confdefs.h <<_ACEOF
4434 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4435 + _ACEOF
4436 +
4437 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4438 +
4439 + cat >>confdefs.h <<\_ACEOF
4440 + #define FC_DUMMY_MAIN_EQ_F77 1
4441 + _ACEOF
4442 +
4443 +  fi
4444 + fi
4445 + else
4446 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4447 + See \`config.log' for more details." >&5
4448 + echo "$as_me: error: linking to Fortran libraries from C fails
4449 + See \`config.log' for more details." >&2;}
4450 +   { (exit 1); exit 1; }; }
4451 + fi
4452 +
4453 +
4454 + ac_ext=${FC_SRCEXT-f}
4455 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4456 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4457 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4458 +
4459 + ac_ext=${FC_SRCEXT-f}
4460 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4461 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4462 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4463 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4464 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4465 + if test "${ac_cv_fc_mangling+set}" = set; then
4466 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4467 + else
4468 +  cat >conftest.$ac_ext <<_ACEOF
4469 +      subroutine foobar()
4470 +      return
4471 +      end
4472 +      subroutine foo_bar()
4473 +      return
4474 +      end
4475 + _ACEOF
4476   rm -f conftest.$ac_objext
4477   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4478    (eval $ac_compile) 2>conftest.er1
# Line 4106 | Line 4482 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4482    cat conftest.err >&5
4483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4484    (exit $ac_status); } &&
4485 <         { ac_try='test -z "$ac_f90_werror_flag"
4485 >         { ac_try='test -z "$ac_fc_werror_flag"
4486                           || test ! -s conftest.err'
4487    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4488    (eval $ac_try) 2>&5
# Line 4119 | Line 4495 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4495    ac_status=$?
4496    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4497    (exit $ac_status); }; }; then
4498 <  mv conftest.$ac_objext cf90_test.$ac_objext
4498 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4499  
4500 +  ac_save_LIBS=$LIBS
4501 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4502 +
4503    ac_ext=c
4504   ac_cpp='$CPP $CPPFLAGS'
4505   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4506   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4507   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4129
4130  ac_save_LIBS=$LIBS
4131  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4132
4508    ac_success=no
4509    for ac_foobar in foobar FOOBAR; do
4510      for ac_underscore in "" "_"; do
# Line 4148 | Line 4523 | char $ac_func ();
4523   /* We use char because int might match the return type of a gcc2
4524     builtin and then its argument prototype would still apply.  */
4525   char $ac_func ();
4526 + #ifdef FC_DUMMY_MAIN
4527 + #ifndef FC_DUMMY_MAIN_EQ_F77
4528 + #  ifdef __cplusplus
4529 +     extern "C"
4530 + #  endif
4531 +   int FC_DUMMY_MAIN() { return 1; }
4532 + #endif
4533 + #endif
4534   int
4535   main ()
4536   {
# Line 4188 | Line 4571 | rm -f conftest.err conftest.$ac_objext \
4571        conftest$ac_exeext conftest.$ac_ext
4572      done
4573    done
4574 +  ac_ext=${FC_SRCEXT-f}
4575 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4576 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4577 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4578  
4579    if test "$ac_success" = "yes"; then
4580       case $ac_foobar in
4581 <        foobar)
4582 <           ac_case=lower
4583 <           ac_foo_bar=foo_bar
4584 <           ;;
4585 <        FOOBAR)
4586 <           ac_case=upper
4587 <           ac_foo_bar=FOO_BAR
4588 <           ;;
4581 >        foobar)
4582 >           ac_case=lower
4583 >           ac_foo_bar=foo_bar
4584 >           ;;
4585 >        FOOBAR)
4586 >           ac_case=upper
4587 >           ac_foo_bar=FOO_BAR
4588 >           ;;
4589       esac
4590  
4591 +     ac_ext=c
4592 + ac_cpp='$CPP $CPPFLAGS'
4593 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4594 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4595 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4596       ac_success_extra=no
4597       for ac_extra in "" "_"; do
4598 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 <
4208 <        cat >conftest.$ac_ext <<_ACEOF
4598 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 >        cat >conftest.$ac_ext <<_ACEOF
4600   /* confdefs.h.  */
4601   _ACEOF
4602   cat confdefs.h >>conftest.$ac_ext
# Line 4219 | Line 4610 | char $ac_func ();
4610   /* We use char because int might match the return type of a gcc2
4611     builtin and then its argument prototype would still apply.  */
4612   char $ac_func ();
4613 + #ifdef FC_DUMMY_MAIN
4614 + #ifndef FC_DUMMY_MAIN_EQ_F77
4615 + #  ifdef __cplusplus
4616 +     extern "C"
4617 + #  endif
4618 +   int FC_DUMMY_MAIN() { return 1; }
4619 + #endif
4620 + #endif
4621   int
4622   main ()
4623   {
# Line 4258 | Line 4657 | rm -f conftest.err conftest.$ac_objext \
4657   rm -f conftest.err conftest.$ac_objext \
4658        conftest$ac_exeext conftest.$ac_ext
4659       done
4660 +     ac_ext=${FC_SRCEXT-f}
4661 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664  
4665       if test "$ac_success_extra" = "yes"; then
4666 <        ac_cv_f90_mangling="$ac_case case"
4666 >        ac_cv_fc_mangling="$ac_case case"
4667          if test -z "$ac_underscore"; then
4668 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4668 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4669          else
4670 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4268 <
4670 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4671          fi
4672          if test -z "$ac_extra"; then
4673 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4673 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4674          else
4675 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4675 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4676          fi
4677        else
4678 <        ac_cv_f90_mangling="unknown"
4678 >        ac_cv_fc_mangling="unknown"
4679        fi
4680    else
4681 <     ac_cv_f90_mangling="unknown"
4280 <
4681 >     ac_cv_fc_mangling="unknown"
4682    fi
4683  
4684    LIBS=$ac_save_LIBS
4685 <  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*
4685 >  rm -f cfortran_test* conftest*
4686   else
4687    echo "$as_me: failed program was:" >&5
4688   sed 's/^/| /' conftest.$ac_ext >&5
4689  
4690 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4691 + See \`config.log' for more details." >&5
4692 + echo "$as_me: error: cannot compile a simple Fortran program
4693 + See \`config.log' for more details." >&2;}
4694 +   { (exit 1); exit 1; }; }
4695   fi
4696   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
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
4697  
4698   fi
4699 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4700 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4699 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4700 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4701  
4702 + ac_ext=${FC_SRCEXT-f}
4703 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4704 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4705 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4706  
4707 + ac_ext=${FC_SRCEXT-f}
4708 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4709 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4710 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4711  
4712 < case $ac_cv_f90_mangling in
4712 >
4713 > case $ac_cv_fc_mangling in
4714    "lower case, no underscore, no extra underscore")
4715            cat >>confdefs.h <<\_ACEOF
4716 < #define F90_FUNC(name,NAME) name
4716 > #define FC_FUNC(name,NAME) name
4717   _ACEOF
4718  
4719            cat >>confdefs.h <<\_ACEOF
4720 < #define F90_FUNC_(name,NAME) name
4720 > #define FC_FUNC_(name,NAME) name
4721   _ACEOF
4722   ;;
4723    "lower case, no underscore, extra underscore")
4724            cat >>confdefs.h <<\_ACEOF
4725 < #define F90_FUNC(name,NAME) name
4725 > #define FC_FUNC(name,NAME) name
4726   _ACEOF
4727  
4728            cat >>confdefs.h <<\_ACEOF
4729 < #define F90_FUNC_(name,NAME) name ## _
4729 > #define FC_FUNC_(name,NAME) name ## _
4730   _ACEOF
4731   ;;
4732    "lower case, underscore, no extra underscore")
4733            cat >>confdefs.h <<\_ACEOF
4734 < #define F90_FUNC(name,NAME) name ## _
4734 > #define FC_FUNC(name,NAME) name ## _
4735   _ACEOF
4736  
4737            cat >>confdefs.h <<\_ACEOF
4738 < #define F90_FUNC_(name,NAME) name ## _
4738 > #define FC_FUNC_(name,NAME) name ## _
4739   _ACEOF
4740   ;;
4741    "lower case, underscore, extra underscore")
4742            cat >>confdefs.h <<\_ACEOF
4743 < #define F90_FUNC(name,NAME) name ## _
4743 > #define FC_FUNC(name,NAME) name ## _
4744   _ACEOF
4745  
4746            cat >>confdefs.h <<\_ACEOF
4747 < #define F90_FUNC_(name,NAME) name ## __
4747 > #define FC_FUNC_(name,NAME) name ## __
4748   _ACEOF
4749   ;;
4750    "upper case, no underscore, no extra underscore")
4751            cat >>confdefs.h <<\_ACEOF
4752 < #define F90_FUNC(name,NAME) NAME
4752 > #define FC_FUNC(name,NAME) NAME
4753   _ACEOF
4754  
4755            cat >>confdefs.h <<\_ACEOF
4756 < #define F90_FUNC_(name,NAME) NAME
4756 > #define FC_FUNC_(name,NAME) NAME
4757   _ACEOF
4758   ;;
4759    "upper case, no underscore, extra underscore")
4760            cat >>confdefs.h <<\_ACEOF
4761 < #define F90_FUNC(name,NAME) NAME
4761 > #define FC_FUNC(name,NAME) NAME
4762   _ACEOF
4763  
4764            cat >>confdefs.h <<\_ACEOF
4765 < #define F90_FUNC_(name,NAME) NAME ## _
4765 > #define FC_FUNC_(name,NAME) NAME ## _
4766   _ACEOF
4767   ;;
4768    "upper case, underscore, no extra underscore")
4769            cat >>confdefs.h <<\_ACEOF
4770 < #define F90_FUNC(name,NAME) NAME ## _
4770 > #define FC_FUNC(name,NAME) NAME ## _
4771   _ACEOF
4772  
4773            cat >>confdefs.h <<\_ACEOF
4774 < #define F90_FUNC_(name,NAME) NAME ## _
4774 > #define FC_FUNC_(name,NAME) NAME ## _
4775   _ACEOF
4776   ;;
4777    "upper case, underscore, extra underscore")
4778            cat >>confdefs.h <<\_ACEOF
4779 < #define F90_FUNC(name,NAME) NAME ## _
4779 > #define FC_FUNC(name,NAME) NAME ## _
4780   _ACEOF
4781  
4782            cat >>confdefs.h <<\_ACEOF
4783 < #define F90_FUNC_(name,NAME) NAME ## __
4783 > #define FC_FUNC_(name,NAME) NAME ## __
4784   _ACEOF
4785   ;;
4786    *)
4787 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4788 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4787 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4788 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4789            ;;
4790   esac
4791  
4792 + ac_ext=${FC_SRCEXT-f}
4793 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4794 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4795 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4796  
4797  
4798  
4799 + ac_ext=${FC_SRCEXT-f}
4800 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4801 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4802 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4803 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4804 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4805 + if test "${ac_cv_prog_fc_v+set}" = set; then
4806 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4807 + else
4808 +  cat >conftest.$ac_ext <<_ACEOF
4809 +      program main
4810  
4811 +      end
4812 + _ACEOF
4813 + rm -f conftest.$ac_objext
4814 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4815 +  (eval $ac_compile) 2>conftest.er1
4816 +  ac_status=$?
4817 +  grep -v '^ *+' conftest.er1 >conftest.err
4818 +  rm -f conftest.er1
4819 +  cat conftest.err >&5
4820 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4821 +  (exit $ac_status); } &&
4822 +         { ac_try='test -z "$ac_fc_werror_flag"
4823 +                         || test ! -s conftest.err'
4824 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4825 +  (eval $ac_try) 2>&5
4826 +  ac_status=$?
4827 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828 +  (exit $ac_status); }; } &&
4829 +         { ac_try='test -s conftest.$ac_objext'
4830 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4831 +  (eval $ac_try) 2>&5
4832 +  ac_status=$?
4833 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4834 +  (exit $ac_status); }; }; then
4835 +  ac_cv_prog_fc_v=
4836 + # Try some options frequently used verbose output
4837 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4838 +  cat >conftest.$ac_ext <<_ACEOF
4839 +      program main
4840 +
4841 +      end
4842 + _ACEOF
4843 +
4844 + # Compile and link our simple test program by passing a flag (argument
4845 + # 1 to this macro) to the Fortran compiler in order to get
4846 + # "verbose" output that we can then parse for the Fortran linker
4847 + # flags.
4848 + ac_save_FFLAGS=$FCFLAGS
4849 + FCFLAGS="$FCFLAGS $ac_verb"
4850 + (eval echo $as_me:4850: \"$ac_link\") >&5
4851 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4852 + echo "$ac_fc_v_output" >&5
4853 + FCFLAGS=$ac_save_FFLAGS
4854 +
4855 + rm -f conftest*
4856 +
4857 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4858 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4859 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4860 + ac_fc_v_output="`echo $ac_fc_v_output |
4861 +        grep 'LPATH is:' |
4862 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4863 +
4864 + case $ac_fc_v_output in
4865 +  # If we are using xlf then replace all the commas with spaces.
4866 +  *xlfentry*)
4867 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4868 +
4869 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4870 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4871 +  *mGLOB_options_string*)
4872 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4873 +
4874 +  # If we are using Cray Fortran then delete quotes.
4875 +  # Use "\"" instead of '"' for font-lock-mode.
4876 +  # FIXME: a more general fix for quoted arguments with spaces?
4877 +  *cft90*)
4878 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4879 + esac
4880 +
4881 +
4882 +  # look for -l* and *.a constructs in the output
4883 +  for ac_arg in $ac_fc_v_output; do
4884 +     case $ac_arg in
4885 +        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4886 +          ac_cv_prog_fc_v=$ac_verb
4887 +          break 2 ;;
4888 +     esac
4889 +  done
4890 + done
4891 + if test -z "$ac_cv_prog_fc_v"; then
4892 +   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4893 + echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4894 + fi
4895 + else
4896 +  echo "$as_me: failed program was:" >&5
4897 + sed 's/^/| /' conftest.$ac_ext >&5
4898 +
4899 + { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4900 + echo "$as_me: WARNING: compilation failed" >&2;}
4901 + fi
4902 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4903 +
4904 + fi
4905 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4906 + echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4907 + echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4908 + echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4909 + if test "${ac_cv_fc_libs+set}" = set; then
4910 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4911 + else
4912 +  if test "x$FCLIBS" != "x"; then
4913 +  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4914 + else
4915 +
4916 + cat >conftest.$ac_ext <<_ACEOF
4917 +      program main
4918 +
4919 +      end
4920 + _ACEOF
4921 +
4922 + # Compile and link our simple test program by passing a flag (argument
4923 + # 1 to this macro) to the Fortran compiler in order to get
4924 + # "verbose" output that we can then parse for the Fortran linker
4925 + # flags.
4926 + ac_save_FFLAGS=$FCFLAGS
4927 + FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4928 + (eval echo $as_me:4928: \"$ac_link\") >&5
4929 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4930 + echo "$ac_fc_v_output" >&5
4931 + FCFLAGS=$ac_save_FFLAGS
4932 +
4933 + rm -f conftest*
4934 +
4935 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4936 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4937 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4938 + ac_fc_v_output="`echo $ac_fc_v_output |
4939 +        grep 'LPATH is:' |
4940 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4941 +
4942 + case $ac_fc_v_output in
4943 +  # If we are using xlf then replace all the commas with spaces.
4944 +  *xlfentry*)
4945 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4946 +
4947 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4948 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4949 +  *mGLOB_options_string*)
4950 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4951 +
4952 +  # If we are using Cray Fortran then delete quotes.
4953 +  # Use "\"" instead of '"' for font-lock-mode.
4954 +  # FIXME: a more general fix for quoted arguments with spaces?
4955 +  *cft90*)
4956 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4957 + esac
4958 +
4959 +
4960 +
4961 + ac_cv_fc_libs=
4962 +
4963 + # Save positional arguments (if any)
4964 + ac_save_positional="$@"
4965 +
4966 + set X $ac_fc_v_output
4967 + while test $# != 1; do
4968 +  shift
4969 +  ac_arg=$1
4970 +  case $ac_arg in
4971 +        [\\/]*.a | ?:[\\/]*.a)
4972 +            ac_exists=false
4973 +  for ac_i in $ac_cv_fc_libs; do
4974 +    if test x"$ac_arg" = x"$ac_i"; then
4975 +      ac_exists=true
4976 +      break
4977 +    fi
4978 +  done
4979 +
4980 +  if test x"$ac_exists" = xtrue; then
4981 +  :
4982 + else
4983 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4984 + fi
4985 +
4986 +          ;;
4987 +        -bI:*)
4988 +            ac_exists=false
4989 +  for ac_i in $ac_cv_fc_libs; do
4990 +    if test x"$ac_arg" = x"$ac_i"; then
4991 +      ac_exists=true
4992 +      break
4993 +    fi
4994 +  done
4995 +
4996 +  if test x"$ac_exists" = xtrue; then
4997 +  :
4998 + else
4999 +  if test "$ac_compiler_gnu" = yes; then
5000 +  for ac_link_opt in $ac_arg; do
5001 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5002 +  done
5003 + else
5004 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5005 + fi
5006 + fi
5007 +
5008 +          ;;
5009 +          # Ignore these flags.
5010 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5011 +          ;;
5012 +        -lkernel32)
5013 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5014 +          ;;
5015 +        -[LRuY])
5016 +          # These flags, when seen by themselves, take an argument.
5017 +          # We remove the space between option and argument and re-iterate
5018 +          # unless we find an empty arg or a new option (starting with -)
5019 +          case $2 in
5020 +             "" | -*);;
5021 +             *)
5022 +                ac_arg="$ac_arg$2"
5023 +                shift; shift
5024 +                set X $ac_arg "$@"
5025 +                ;;
5026 +          esac
5027 +          ;;
5028 +        -YP,*)
5029 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5030 +              ac_exists=false
5031 +  for ac_i in $ac_cv_fc_libs; do
5032 +    if test x"$ac_j" = x"$ac_i"; then
5033 +      ac_exists=true
5034 +      break
5035 +    fi
5036 +  done
5037 +
5038 +  if test x"$ac_exists" = xtrue; then
5039 +  :
5040 + else
5041 +  ac_arg="$ac_arg $ac_j"
5042 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5043 + fi
5044 +
5045 +          done
5046 +          ;;
5047 +        -[lLR]*)
5048 +            ac_exists=false
5049 +  for ac_i in $ac_cv_fc_libs; do
5050 +    if test x"$ac_arg" = x"$ac_i"; then
5051 +      ac_exists=true
5052 +      break
5053 +    fi
5054 +  done
5055 +
5056 +  if test x"$ac_exists" = xtrue; then
5057 +  :
5058 + else
5059 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5060 + fi
5061 +
5062 +          ;;
5063 +          # Ignore everything else.
5064 +  esac
5065 + done
5066 + # restore positional arguments
5067 + set X $ac_save_positional; shift
5068 +
5069 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5070 + # then we insist that the "run path" must be an absolute path (i.e. it
5071 + # must begin with a "/").
5072 + case `(uname -sr) 2>/dev/null` in
5073 +   "SunOS 5"*)
5074 +      ac_ld_run_path=`echo $ac_fc_v_output |
5075 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5076 +      test "x$ac_ld_run_path" != x &&
5077 +        if test "$ac_compiler_gnu" = yes; then
5078 +  for ac_link_opt in $ac_ld_run_path; do
5079 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5080 +  done
5081 + else
5082 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5083 + fi
5084 +      ;;
5085 + esac
5086 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5087 +
5088 + fi
5089 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5090 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5091 + FCLIBS="$ac_cv_fc_libs"
5092 +
5093 +
5094 + ac_ext=${FC_SRCEXT-f}
5095 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5096 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5097 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5098 +
5099 +
5100 +
5101   echo "$as_me:$LINENO: checking for module suffix" >&5
5102   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5103   rm -f conftest*
5104   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5105   rm -f work*
5106 < cat >conftest.f90 <<EOF
5106 > cat >conftest.$ac_ext <<EOF
5107          module conftest
5108          integer n
5109          parameter (n=1)
# Line 4400 | Line 5112 | modcase="lower"
5112   # SGI and absoft compilers generates module name in upper case!
5113   testname="conftest"
5114   modcase="lower"
5115 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5116 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5115 > if (eval $ac_compile) 2>/dev/null ; then
5116 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5117      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5118      if test -z "$MOD" ; then
5119          MOD=`ls CONFTEST* 2>/dev/null \
5120 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5120 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5121          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5122          if test -n "$MOD" ; then
5123              testname="CONFTEST"
# Line 4445 | Line 5157 | rm -f work*
5157   rm -f conftest*
5158   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5159   rm -f work*
5160 < cat >conftest.f90 <<EOF
5160 > cat >conftest.$ac_ext <<EOF
5161          module conftest
5162          integer n
5163          parameter (n=1)
# Line 4453 | Line 5165 | testname="conftest"
5165   EOF
5166   # SGI and absoft compilers generates module name in upper case!
5167   testname="conftest"
5168 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5169 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5168 > if (eval $ac_compile) 2>/dev/null ; then
5169 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5170     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5171     if test -n "$mod" ; then
5172        testname="CONFTEST"
# Line 4463 | Line 5175 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5175     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5176     cp $testname.$MOD conf
5177     rm -f conftest* CONFTEST*
5178 <   cat >conftest1.f90 <<EOF
5178 >   cat >conftest1.$ac_ext <<EOF
5179          program main
5180          use conftest
5181          print *, n
# Line 4471 | Line 5183 | EOF
5183   EOF
5184     F90_WORK_FILES_ARG=""
5185     F90MODINCSPEC=""
5186 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5186 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5187         MODDIRFLAG="-I"
5188         F90MODINCSPEC="-I<dir>"
5189         echo "$as_me:$LINENO: result: -I" >&5
5190   echo "${ECHO_T}-I" >&6
5191 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5191 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5192         MODDIRFLAG="-M"
5193         F90MODINCSPEC="-M<dir>"
5194         echo "$as_me:$LINENO: result: -M" >&5
5195   echo "${ECHO_T}-M" >&6
5196 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5196 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5197         MODDIRFLAG="-p"
5198         F90MODINCSPEC="-p<dir>"
5199         echo "$as_me:$LINENO: result: -p" >&5
# Line 4490 | Line 5202 | echo "${ECHO_T}-p" >&6
5202          cp work.pc conf/mpimod.pc
5203          echo "mpimod.pc" > conf/mpimod.pcl
5204          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5205 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5205 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5206              MODDIRFLAG='-cl,mpimod.pcl'
5207              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5208   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4520 | Line 5232 | else
5232   if test "${ac_cv_f90_module_names+set}" = set; then
5233    echo $ECHO_N "(cached) $ECHO_C" >&6
5234   else
5235 <  ac_ext=f90
5236 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5237 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5238 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5235 >  ac_ext=${FC_SRCEXT-f}
5236 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5237 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5238 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5239  
5240   # carry out the test in a new directory, so that we don't miss anything
5241   mkdir conftest
# Line 4541 | Line 5253 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5253    cat conftest.err >&5
5254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5255    (exit $ac_status); } &&
5256 <         { ac_try='test -z "$ac_f90_werror_flag"
5256 >         { ac_try='test -z "$ac_fc_werror_flag"
5257                           || test ! -s conftest.err'
5258    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5259    (eval $ac_try) 2>&5
# Line 4657 | Line 5369 | rm -rf conftest
5369   cd ..
5370   # cleanup
5371   rm -rf conftest
5372 < ac_ext=f90
5373 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5374 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5375 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5372 > ac_ext=${FC_SRCEXT-f}
5373 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5374 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5375 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5376  
5377   fi
5378   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4749 | Line 5461 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5461   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5462  
5463  
5464 < ac_ext=cc
5465 < ac_cpp='$CXXCPP $CPPFLAGS'
5466 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5467 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5468 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5464 > ac_ext=c
5465 > ac_cpp='$CPP $CPPFLAGS'
5466 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5467 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5468 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5469  
5470  
5471 < ac_ext=cc
5472 < ac_cpp='$CXXCPP $CPPFLAGS'
5473 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5474 < 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
5471 >
5472 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5473 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5474 > if test "${ac_cv_lib_m_asin+set}" = set; then
5475    echo $ECHO_N "(cached) $ECHO_C" >&6
5476   else
5477 <      # Double quotes because CXXCPP needs to be expanded
5478 <    for CXXCPP in "$CXX -E" "/lib/cpp"
5479 <    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
5477 >  ac_check_lib_save_LIBS=$LIBS
5478 > LIBS="-lm  $LIBS"
5479 > cat >conftest.$ac_ext <<_ACEOF
5480   /* confdefs.h.  */
5481   _ACEOF
5482   cat confdefs.h >>conftest.$ac_ext
5483   cat >>conftest.$ac_ext <<_ACEOF
5484   /* end confdefs.h.  */
5485 < #ifdef __STDC__
5486 < # include <limits.h>
5487 < #else
5488 < # include <assert.h>
5485 >
5486 > /* Override any gcc2 internal prototype to avoid an error.  */
5487 > #ifdef __cplusplus
5488 > extern "C"
5489   #endif
5490 <                     Syntax error
5490 > /* We use char because int might match the return type of a gcc2
5491 >   builtin and then its argument prototype would still apply.  */
5492 > char asin ();
5493 > #ifdef FC_DUMMY_MAIN
5494 > #ifndef FC_DUMMY_MAIN_EQ_F77
5495 > #  ifdef __cplusplus
5496 >     extern "C"
5497 > #  endif
5498 >   int FC_DUMMY_MAIN() { return 1; }
5499 > #endif
5500 > #endif
5501 > int
5502 > main ()
5503 > {
5504 > asin ();
5505 >  ;
5506 >  return 0;
5507 > }
5508   _ACEOF
5509 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5510 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5509 > rm -f conftest.$ac_objext conftest$ac_exeext
5510 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5511 >  (eval $ac_link) 2>conftest.er1
5512    ac_status=$?
5513    grep -v '^ *+' conftest.er1 >conftest.err
5514    rm -f conftest.er1
5515    cat conftest.err >&5
5516    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5517 <  (exit $ac_status); } >/dev/null; then
5518 <  if test -s conftest.err; then
5519 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5520 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5521 <  else
5522 <    ac_cpp_err=
5523 <  fi
5524 < else
5525 <  ac_cpp_err=yes
5526 < fi
5527 < if test -z "$ac_cpp_err"; then
5528 <  :
5517 >  (exit $ac_status); } &&
5518 >         { ac_try='test -z "$ac_c_werror_flag"
5519 >                         || test ! -s conftest.err'
5520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5521 >  (eval $ac_try) 2>&5
5522 >  ac_status=$?
5523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5524 >  (exit $ac_status); }; } &&
5525 >         { ac_try='test -s conftest$ac_exeext'
5526 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5527 >  (eval $ac_try) 2>&5
5528 >  ac_status=$?
5529 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5530 >  (exit $ac_status); }; }; then
5531 >  ac_cv_lib_m_asin=yes
5532   else
5533    echo "$as_me: failed program was:" >&5
5534   sed 's/^/| /' conftest.$ac_ext >&5
5535  
5536 <  # Broken: fails on valid input.
4819 < continue
5536 > ac_cv_lib_m_asin=no
5537   fi
5538 < rm -f conftest.err conftest.$ac_ext
5538 > rm -f conftest.err conftest.$ac_objext \
5539 >      conftest$ac_exeext conftest.$ac_ext
5540 > LIBS=$ac_check_lib_save_LIBS
5541 > fi
5542 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5543 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5544 > if test $ac_cv_lib_m_asin = yes; then
5545 >  cat >>confdefs.h <<_ACEOF
5546 > #define HAVE_LIBM 1
5547 > _ACEOF
5548  
5549 <  # OK, works on sane cases.  Now check whether non-existent headers
5550 <  # can be detected and how.
5549 >  LIBS="-lm $LIBS"
5550 >
5551 > else
5552 >  exit
5553 > fi
5554 >
5555 >
5556 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5557 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5558 > if test "${ac_cv_header_stdc+set}" = set; then
5559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5560 > else
5561    cat >conftest.$ac_ext <<_ACEOF
5562   /* confdefs.h.  */
5563   _ACEOF
5564   cat confdefs.h >>conftest.$ac_ext
5565   cat >>conftest.$ac_ext <<_ACEOF
5566   /* end confdefs.h.  */
5567 < #include <ac_nonexistent.h>
5567 > #include <stdlib.h>
5568 > #include <stdarg.h>
5569 > #include <string.h>
5570 > #include <float.h>
5571 >
5572 > #ifdef FC_DUMMY_MAIN
5573 > #ifndef FC_DUMMY_MAIN_EQ_F77
5574 > #  ifdef __cplusplus
5575 >     extern "C"
5576 > #  endif
5577 >   int FC_DUMMY_MAIN() { return 1; }
5578 > #endif
5579 > #endif
5580 > int
5581 > main ()
5582 > {
5583 >
5584 >  ;
5585 >  return 0;
5586 > }
5587   _ACEOF
5588 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5589 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5588 > rm -f conftest.$ac_objext
5589 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5590 >  (eval $ac_compile) 2>conftest.er1
5591    ac_status=$?
5592    grep -v '^ *+' conftest.er1 >conftest.err
5593    rm -f conftest.er1
5594    cat conftest.err >&5
5595    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5596 <  (exit $ac_status); } >/dev/null; then
5597 <  if test -s conftest.err; then
5598 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5599 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5600 <  else
5601 <    ac_cpp_err=
5602 <  fi
5596 >  (exit $ac_status); } &&
5597 >         { ac_try='test -z "$ac_c_werror_flag"
5598 >                         || test ! -s conftest.err'
5599 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5600 >  (eval $ac_try) 2>&5
5601 >  ac_status=$?
5602 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603 >  (exit $ac_status); }; } &&
5604 >         { ac_try='test -s conftest.$ac_objext'
5605 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5606 >  (eval $ac_try) 2>&5
5607 >  ac_status=$?
5608 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5609 >  (exit $ac_status); }; }; then
5610 >  ac_cv_header_stdc=yes
5611   else
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
5612    echo "$as_me: failed program was:" >&5
5613   sed 's/^/| /' conftest.$ac_ext >&5
5614  
5615 <  # Passes both tests.
4858 < ac_preproc_ok=:
4859 < break
5615 > ac_cv_header_stdc=no
5616   fi
5617 < rm -f conftest.err conftest.$ac_ext
5617 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5618  
5619 < done
5620 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5621 < rm -f conftest.err conftest.$ac_ext
5622 < if $ac_preproc_ok; then
5623 <  break
5624 < fi
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5621 >  cat >conftest.$ac_ext <<_ACEOF
5622 > /* confdefs.h.  */
5623 > _ACEOF
5624 > cat confdefs.h >>conftest.$ac_ext
5625 > cat >>conftest.$ac_ext <<_ACEOF
5626 > /* end confdefs.h.  */
5627 > #include <string.h>
5628  
4870    done
4871    ac_cv_prog_CXXCPP=$CXXCPP
4872
4873 fi
4874  CXXCPP=$ac_cv_prog_CXXCPP
4875 else
4876  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.  */
5629   _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
4918 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
4924
4925  # Broken: fails on valid input.
4926 continue
4927 fi
4928 rm -f conftest.err conftest.$ac_ext
4929
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
4990 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
4991 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
4992 if test "${ac_cv_header_stdc+set}" = set; then
4993  echo $ECHO_N "(cached) $ECHO_C" >&6
4994 else
4995  cat >conftest.$ac_ext <<_ACEOF
4996 /* confdefs.h.  */
4997 _ACEOF
4998 cat confdefs.h >>conftest.$ac_ext
4999 cat >>conftest.$ac_ext <<_ACEOF
5000 /* end confdefs.h.  */
5001 #include <stdlib.h>
5002 #include <stdarg.h>
5003 #include <string.h>
5004 #include <float.h>
5005
5006 int
5007 main ()
5008 {
5009
5010  ;
5011  return 0;
5012 }
5013 _ACEOF
5014 rm -f conftest.$ac_objext
5015 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5016  (eval $ac_compile) 2>conftest.er1
5017  ac_status=$?
5018  grep -v '^ *+' conftest.er1 >conftest.err
5019  rm -f conftest.er1
5020  cat conftest.err >&5
5021  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022  (exit $ac_status); } &&
5023         { ac_try='test -z "$ac_cxx_werror_flag"
5024                         || test ! -s conftest.err'
5025  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5026  (eval $ac_try) 2>&5
5027  ac_status=$?
5028  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5029  (exit $ac_status); }; } &&
5030         { ac_try='test -s conftest.$ac_objext'
5031  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5032  (eval $ac_try) 2>&5
5033  ac_status=$?
5034  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5035  (exit $ac_status); }; }; then
5036  ac_cv_header_stdc=yes
5037 else
5038  echo "$as_me: failed program was:" >&5
5039 sed 's/^/| /' conftest.$ac_ext >&5
5040
5041 ac_cv_header_stdc=no
5042 fi
5043 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5044
5045 if test $ac_cv_header_stdc = yes; then
5046  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5047  cat >conftest.$ac_ext <<_ACEOF
5048 /* confdefs.h.  */
5049 _ACEOF
5050 cat confdefs.h >>conftest.$ac_ext
5051 cat >>conftest.$ac_ext <<_ACEOF
5052 /* end confdefs.h.  */
5053 #include <string.h>
5054
5055 _ACEOF
5630   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5631    $EGREP "memchr" >/dev/null 2>&1; then
5632    :
# Line 5153 | Line 5727 | fi
5727  
5728   fi
5729  
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
5228 _ACEOF
5229
5230 fi
5231
5730   # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5731  
5732  
# Line 5267 | Line 5765 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5765    cat conftest.err >&5
5766    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5767    (exit $ac_status); } &&
5768 <         { ac_try='test -z "$ac_cxx_werror_flag"
5768 >         { ac_try='test -z "$ac_c_werror_flag"
5769                           || test ! -s conftest.err'
5770    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5771    (eval $ac_try) 2>&5
# Line 5301 | Line 5799 | done
5799   done
5800  
5801  
5802 < echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
5803 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
5804 < if test "${ac_cv_cxx_have_stl+set}" = set; then
5805 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5802 > #
5803 > # Handle user hints
5804 > #
5805 >
5806 > # Check whether --with-zlib or --without-zlib was given.
5807 > if test "${with_zlib+set}" = set; then
5808 >  withval="$with_zlib"
5809 >  zlib_dir="$withval"
5810   else
5811 +                zlib_dir="not_set"
5812 + fi;
5813 + if test "$zlib_dir" != "no"; then
5814  
5815 + if test "$zlib_dir" != "not_set" ; then
5816 +  if test -d "$zlib_dir"
5817 +  then
5818 +    ZLIB_HOME="$zlib_dir"
5819 +  else
5820 +    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5821 + echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5822 +  fi
5823 + fi
5824  
5825 + ZLIB_HOME=/usr/local
5826 + if test ! -f "${ZLIB_HOME}/include/zlib.h"
5827 + then
5828 +        ZLIB_HOME=/usr
5829 + fi
5830  
5831 < ac_ext=cc
5832 < ac_cpp='$CXXCPP $CPPFLAGS'
5833 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5834 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5835 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5831 > #
5832 > # Locate zlib, if wanted
5833 > #
5834 > if test -n "${ZLIB_HOME}"
5835 > then
5836 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5837 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5838 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5839 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5840  
5841 < cat >conftest.$ac_ext <<_ACEOF
5841 >
5842 >        ac_ext=c
5843 > ac_cpp='$CPP $CPPFLAGS'
5844 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5845 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5846 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5847 >
5848 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5849 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5850 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5851 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5852 > else
5853 >  ac_check_lib_save_LIBS=$LIBS
5854 > LIBS="-lz  $LIBS"
5855 > cat >conftest.$ac_ext <<_ACEOF
5856   /* confdefs.h.  */
5857   _ACEOF
5858   cat confdefs.h >>conftest.$ac_ext
5859   cat >>conftest.$ac_ext <<_ACEOF
5860   /* end confdefs.h.  */
5861 < #include <list>
5862 < #include <deque>
5863 < #ifdef HAVE_NAMESPACES
5864 < using namespace std;
5861 >
5862 > /* Override any gcc2 internal prototype to avoid an error.  */
5863 > #ifdef __cplusplus
5864 > extern "C"
5865   #endif
5866 + /* We use char because int might match the return type of a gcc2
5867 +   builtin and then its argument prototype would still apply.  */
5868 + char inflateEnd ();
5869 + #ifdef FC_DUMMY_MAIN
5870 + #ifndef FC_DUMMY_MAIN_EQ_F77
5871 + #  ifdef __cplusplus
5872 +     extern "C"
5873 + #  endif
5874 +   int FC_DUMMY_MAIN() { return 1; }
5875 + #endif
5876 + #endif
5877   int
5878   main ()
5879   {
5880 < list<int> x; x.push_back(5);
5333 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
5880 > inflateEnd ();
5881    ;
5882    return 0;
5883   }
5884   _ACEOF
5885 < rm -f conftest.$ac_objext
5886 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5887 <  (eval $ac_compile) 2>conftest.er1
5885 > rm -f conftest.$ac_objext conftest$ac_exeext
5886 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5887 >  (eval $ac_link) 2>conftest.er1
5888    ac_status=$?
5889    grep -v '^ *+' conftest.er1 >conftest.err
5890    rm -f conftest.er1
5891    cat conftest.err >&5
5892    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5893    (exit $ac_status); } &&
5894 <         { ac_try='test -z "$ac_cxx_werror_flag"
5894 >         { ac_try='test -z "$ac_c_werror_flag"
5895                           || test ! -s conftest.err'
5896    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5897    (eval $ac_try) 2>&5
5898    ac_status=$?
5899    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5900    (exit $ac_status); }; } &&
5901 <         { ac_try='test -s conftest.$ac_objext'
5901 >         { ac_try='test -s conftest$ac_exeext'
5902    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5903    (eval $ac_try) 2>&5
5904    ac_status=$?
5905    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5906    (exit $ac_status); }; }; then
5907 <  ac_cv_cxx_have_stl=yes
5907 >  ac_cv_lib_z_inflateEnd=yes
5908   else
5909    echo "$as_me: failed program was:" >&5
5910   sed 's/^/| /' conftest.$ac_ext >&5
5911  
5912 < ac_cv_cxx_have_stl=no
5912 > ac_cv_lib_z_inflateEnd=no
5913   fi
5914 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5915 < ac_ext=cc
5916 < ac_cpp='$CXXCPP $CPPFLAGS'
5370 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5371 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5372 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5373 <
5374 <
5914 > rm -f conftest.err conftest.$ac_objext \
5915 >      conftest$ac_exeext conftest.$ac_ext
5916 > LIBS=$ac_check_lib_save_LIBS
5917   fi
5918 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
5919 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
5920 < if test "$ac_cv_cxx_have_stl" = yes; then
5921 <
5922 < cat >>confdefs.h <<\_ACEOF
5923 < #define HAVE_STL
5382 < _ACEOF
5383 <
5918 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5919 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5920 > if test $ac_cv_lib_z_inflateEnd = yes; then
5921 >  zlib_cv_libz=yes
5922 > else
5923 >  zlib_cv_libz=no
5924   fi
5925  
5926 <
5927 <
5928 <  if test "${ac_cv_header_iostream+set}" = set; then
5929 <  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
5926 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5927 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5928 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5929 > if test "${ac_cv_header_zlib_h+set}" = set; then
5930    echo $ECHO_N "(cached) $ECHO_C" >&6
5931   fi
5932 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
5933 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
5932 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5933 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5934   else
5935    # Is the header compilable?
5936 < echo "$as_me:$LINENO: checking iostream usability" >&5
5937 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
5936 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5937 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5938   cat >conftest.$ac_ext <<_ACEOF
5939   /* confdefs.h.  */
5940   _ACEOF
# Line 5404 | Line 5942 | $ac_includes_default
5942   cat >>conftest.$ac_ext <<_ACEOF
5943   /* end confdefs.h.  */
5944   $ac_includes_default
5945 < #include <iostream>
5945 > #include <zlib.h>
5946   _ACEOF
5947   rm -f conftest.$ac_objext
5948   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5415 | Line 5953 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5953    cat conftest.err >&5
5954    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5955    (exit $ac_status); } &&
5956 <         { ac_try='test -z "$ac_cxx_werror_flag"
5956 >         { ac_try='test -z "$ac_c_werror_flag"
5957                           || test ! -s conftest.err'
5958    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5959    (eval $ac_try) 2>&5
# Line 5440 | Line 5978 | echo "${ECHO_T}$ac_header_compiler" >&6
5978   echo "${ECHO_T}$ac_header_compiler" >&6
5979  
5980   # Is the header present?
5981 < echo "$as_me:$LINENO: checking iostream presence" >&5
5982 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
5981 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5982 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5983   cat >conftest.$ac_ext <<_ACEOF
5984   /* confdefs.h.  */
5985   _ACEOF
5986   cat confdefs.h >>conftest.$ac_ext
5987   cat >>conftest.$ac_ext <<_ACEOF
5988   /* end confdefs.h.  */
5989 < #include <iostream>
5989 > #include <zlib.h>
5990   _ACEOF
5991   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5992    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5459 | Line 5997 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
5997    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5998    (exit $ac_status); } >/dev/null; then
5999    if test -s conftest.err; then
6000 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6001 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6000 >    ac_cpp_err=$ac_c_preproc_warn_flag
6001 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6002    else
6003      ac_cpp_err=
6004    fi
# Line 5480 | Line 6018 | echo "${ECHO_T}$ac_header_preproc" >&6
6018   echo "${ECHO_T}$ac_header_preproc" >&6
6019  
6020   # So?  What about this header?
6021 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6021 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6022    yes:no: )
6023 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
6024 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
6025 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
6026 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
6023 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6024 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6025 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6026 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6027      ac_header_preproc=yes
6028      ;;
6029    no:yes:* )
6030 <    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
6031 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
6032 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
6033 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
6034 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
6035 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
6036 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
6037 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
6038 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
6039 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
6040 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
6041 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
6030 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6031 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6032 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6033 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6034 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6035 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6036 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6037 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6038 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6039 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6040 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6041 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6042      (
6043        cat <<\_ASBOX
6044   ## ------------------------------ ##
# Line 5511 | Line 6049 | esac
6049        sed "s/^/$as_me: WARNING:     /" >&2
6050      ;;
6051   esac
6052 < echo "$as_me:$LINENO: checking for iostream" >&5
6053 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
6054 < if test "${ac_cv_header_iostream+set}" = set; then
6052 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6053 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6054 > if test "${ac_cv_header_zlib_h+set}" = set; then
6055    echo $ECHO_N "(cached) $ECHO_C" >&6
6056   else
6057 <  ac_cv_header_iostream=$ac_header_preproc
6057 >  ac_cv_header_zlib_h=$ac_header_preproc
6058   fi
6059 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6060 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
6059 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6060 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6061  
6062   fi
6063 < if test $ac_cv_header_iostream = yes; then
6063 > if test $ac_cv_header_zlib_h = yes; then
6064 >  zlib_cv_zlib_h=yes
6065 > else
6066 >  zlib_cv_zlib_h=no
6067 > fi
6068  
6069  
6070 +        ac_ext=c
6071 + ac_cpp='$CPP $CPPFLAGS'
6072 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6073 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6074 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
6075 +
6076 +
6077 +        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6078 +
6079   cat >>confdefs.h <<\_ACEOF
6080 < #define HAVE_IOSTREAM 1
6080 > #define HAVE_ZLIB_H 1
6081   _ACEOF
6082  
6083  
6084 + cat >>confdefs.h <<\_ACEOF
6085 + #define HAVE_LIBZ 1
6086 + _ACEOF
6087 +
6088 +                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6089 +                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6090 +                ZLIB="-lz"
6091 +        else
6092 +                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6093 + echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6094 +                ZLIB_INC_DIR=
6095 +                ZLIB_LIB_DIR=
6096 +                ZLIB=
6097 +                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6098 +                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6099 +                echo "$as_me:$LINENO: result: failed" >&5
6100 + echo "${ECHO_T}failed" >&6
6101 +                echo ""
6102 +                echo "*********************************************************"
6103 +                echo "* WARNING: Could not find a working zlib installation   *"
6104 +                echo "* If you need OOPSE to be able to deal with compressed  *"
6105 +                echo "* trajectory dump files be sure to specify a valid zlib *"
6106 +                echo "* installation with --with-zlib=DIR                     *"
6107 +                echo "*                                                       *"
6108 +                echo "* OOPSE will still work without zlib installed.         *"
6109 +                echo "*********************************************************"
6110 +                echo ""
6111 +        fi
6112 +
6113 +
6114 +
6115 + fi
6116 + fi
6117 +
6118 + #
6119 + # Handle user hints
6120 + #
6121 +
6122 + # Check whether --with-fftw or --without-fftw was given.
6123 + if test "${with_fftw+set}" = set; then
6124 +  withval="$with_fftw"
6125 +  fftw_dir="$withval"
6126   else
6127 +                fftw_dir="not_set"
6128 + fi;
6129 + if test "$fftw_dir" != "no"; then
6130  
6131 + if test "$fftw_dir" != "not_set" ; then
6132 +  if test -d "$fftw_dir"
6133 +  then
6134 +    FFTW_HOME="$fftw_dir"
6135 +  else
6136 +    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6137 + echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6138 +  fi
6139 + fi
6140  
6141 < for ac_header in iostream.h
6142 < do
6143 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6144 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6145 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6146 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6147 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6141 > FFTW_HOME=/usr/local
6142 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6143 > then
6144 >        FFTW_HOME=/usr
6145 > fi
6146 >
6147 > #
6148 > # Locate fftw, if wanted
6149 > #
6150 > if test -n "${FFTW_HOME}"
6151 > then
6152 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6153 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6154 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6155 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6156 >
6157 >
6158 >        ac_ext=c
6159 > ac_cpp='$CPP $CPPFLAGS'
6160 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6161 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6162 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6163 >
6164 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6165 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6166 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6167    echo $ECHO_N "(cached) $ECHO_C" >&6
6168 + else
6169 +  ac_check_lib_save_LIBS=$LIBS
6170 + LIBS="-lfftw3  $LIBS"
6171 + cat >conftest.$ac_ext <<_ACEOF
6172 + /* confdefs.h.  */
6173 + _ACEOF
6174 + cat confdefs.h >>conftest.$ac_ext
6175 + cat >>conftest.$ac_ext <<_ACEOF
6176 + /* end confdefs.h.  */
6177 +
6178 + /* Override any gcc2 internal prototype to avoid an error.  */
6179 + #ifdef __cplusplus
6180 + extern "C"
6181 + #endif
6182 + /* We use char because int might match the return type of a gcc2
6183 +   builtin and then its argument prototype would still apply.  */
6184 + char fftw_execute ();
6185 + #ifdef FC_DUMMY_MAIN
6186 + #ifndef FC_DUMMY_MAIN_EQ_F77
6187 + #  ifdef __cplusplus
6188 +     extern "C"
6189 + #  endif
6190 +   int FC_DUMMY_MAIN() { return 1; }
6191 + #endif
6192 + #endif
6193 + int
6194 + main ()
6195 + {
6196 + fftw_execute ();
6197 +  ;
6198 +  return 0;
6199 + }
6200 + _ACEOF
6201 + rm -f conftest.$ac_objext conftest$ac_exeext
6202 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6203 +  (eval $ac_link) 2>conftest.er1
6204 +  ac_status=$?
6205 +  grep -v '^ *+' conftest.er1 >conftest.err
6206 +  rm -f conftest.er1
6207 +  cat conftest.err >&5
6208 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6209 +  (exit $ac_status); } &&
6210 +         { ac_try='test -z "$ac_c_werror_flag"
6211 +                         || test ! -s conftest.err'
6212 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6213 +  (eval $ac_try) 2>&5
6214 +  ac_status=$?
6215 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6216 +  (exit $ac_status); }; } &&
6217 +         { ac_try='test -s conftest$ac_exeext'
6218 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6219 +  (eval $ac_try) 2>&5
6220 +  ac_status=$?
6221 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6222 +  (exit $ac_status); }; }; then
6223 +  ac_cv_lib_fftw3_fftw_execute=yes
6224 + else
6225 +  echo "$as_me: failed program was:" >&5
6226 + sed 's/^/| /' conftest.$ac_ext >&5
6227 +
6228 + ac_cv_lib_fftw3_fftw_execute=no
6229   fi
6230 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6231 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6230 > rm -f conftest.err conftest.$ac_objext \
6231 >      conftest$ac_exeext conftest.$ac_ext
6232 > LIBS=$ac_check_lib_save_LIBS
6233 > fi
6234 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6235 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6236 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6237 >  fftw_cv_libfftw3=yes
6238   else
6239 +  fftw_cv_libfftw3=no
6240 + fi
6241 +
6242 +        if test "${ac_cv_header_fftw3_h+set}" = set; then
6243 +  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6244 + echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6245 + if test "${ac_cv_header_fftw3_h+set}" = set; then
6246 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6247 + fi
6248 + echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6249 + echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6250 + else
6251    # Is the header compilable?
6252 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6253 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6252 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6253 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6254   cat >conftest.$ac_ext <<_ACEOF
6255   /* confdefs.h.  */
6256   _ACEOF
# Line 5555 | Line 6258 | $ac_includes_default
6258   cat >>conftest.$ac_ext <<_ACEOF
6259   /* end confdefs.h.  */
6260   $ac_includes_default
6261 < #include <$ac_header>
6261 > #include <fftw3.h>
6262   _ACEOF
6263   rm -f conftest.$ac_objext
6264   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5566 | Line 6269 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6269    cat conftest.err >&5
6270    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6271    (exit $ac_status); } &&
6272 <         { ac_try='test -z "$ac_cxx_werror_flag"
6272 >         { ac_try='test -z "$ac_c_werror_flag"
6273                           || test ! -s conftest.err'
6274    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6275    (eval $ac_try) 2>&5
# Line 5591 | Line 6294 | echo "${ECHO_T}$ac_header_compiler" >&6
6294   echo "${ECHO_T}$ac_header_compiler" >&6
6295  
6296   # Is the header present?
6297 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6298 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6297 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6298 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6299   cat >conftest.$ac_ext <<_ACEOF
6300   /* confdefs.h.  */
6301   _ACEOF
6302   cat confdefs.h >>conftest.$ac_ext
6303   cat >>conftest.$ac_ext <<_ACEOF
6304   /* end confdefs.h.  */
6305 < #include <$ac_header>
6305 > #include <fftw3.h>
6306   _ACEOF
6307   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6308    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5610 | Line 6313 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6313    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6314    (exit $ac_status); } >/dev/null; then
6315    if test -s conftest.err; then
6316 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6317 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6316 >    ac_cpp_err=$ac_c_preproc_warn_flag
6317 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6318    else
6319      ac_cpp_err=
6320    fi
# Line 5631 | Line 6334 | echo "${ECHO_T}$ac_header_preproc" >&6
6334   echo "${ECHO_T}$ac_header_preproc" >&6
6335  
6336   # So?  What about this header?
6337 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6337 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6338    yes:no: )
6339 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6340 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6341 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6342 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6339 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6340 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6341 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6342 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6343      ac_header_preproc=yes
6344      ;;
6345    no:yes:* )
6346 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6347 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6348 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6349 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6350 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6351 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6352 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6353 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6354 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6355 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6356 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6357 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6346 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6347 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6348 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6349 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6350 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6351 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6352 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6353 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6354 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6355 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6356 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6357 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6358      (
6359        cat <<\_ASBOX
6360   ## ------------------------------ ##
# Line 5662 | Line 6365 | esac
6365        sed "s/^/$as_me: WARNING:     /" >&2
6366      ;;
6367   esac
6368 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6369 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6370 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6368 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6369 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6370 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6371    echo $ECHO_N "(cached) $ECHO_C" >&6
6372   else
6373 <  eval "$as_ac_Header=\$ac_header_preproc"
6373 >  ac_cv_header_fftw3_h=$ac_header_preproc
6374   fi
6375 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6376 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6375 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6376 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6377  
6378   fi
6379 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6380 <  cat >>confdefs.h <<_ACEOF
6381 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6382 < _ACEOF
5680 <
6379 > if test $ac_cv_header_fftw3_h = yes; then
6380 >  fftw_cv_fftw3_h=yes
6381 > else
6382 >  fftw_cv_fftw3_h=no
6383   fi
6384  
5683 done
6385  
6386 +        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6387 +        then
6388 +                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6389 + echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6390 + if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6391 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6392 + else
6393 +  ac_check_lib_save_LIBS=$LIBS
6394 + LIBS="-lfftw  $LIBS"
6395 + cat >conftest.$ac_ext <<_ACEOF
6396 + /* confdefs.h.  */
6397 + _ACEOF
6398 + cat confdefs.h >>conftest.$ac_ext
6399 + cat >>conftest.$ac_ext <<_ACEOF
6400 + /* end confdefs.h.  */
6401  
6402 < fi
6403 <
6404 <
6402 > /* Override any gcc2 internal prototype to avoid an error.  */
6403 > #ifdef __cplusplus
6404 > extern "C"
6405 > #endif
6406 > /* We use char because int might match the return type of a gcc2
6407 >   builtin and then its argument prototype would still apply.  */
6408 > char fftwnd_one ();
6409 > #ifdef FC_DUMMY_MAIN
6410 > #ifndef FC_DUMMY_MAIN_EQ_F77
6411 > #  ifdef __cplusplus
6412 >     extern "C"
6413 > #  endif
6414 >   int FC_DUMMY_MAIN() { return 1; }
6415 > #endif
6416 > #endif
6417 > int
6418 > main ()
6419 > {
6420 > fftwnd_one ();
6421 >  ;
6422 >  return 0;
6423 > }
6424 > _ACEOF
6425 > rm -f conftest.$ac_objext conftest$ac_exeext
6426 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6427 >  (eval $ac_link) 2>conftest.er1
6428 >  ac_status=$?
6429 >  grep -v '^ *+' conftest.er1 >conftest.err
6430 >  rm -f conftest.er1
6431 >  cat conftest.err >&5
6432 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6433 >  (exit $ac_status); } &&
6434 >         { ac_try='test -z "$ac_c_werror_flag"
6435 >                         || test ! -s conftest.err'
6436 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6437 >  (eval $ac_try) 2>&5
6438 >  ac_status=$?
6439 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6440 >  (exit $ac_status); }; } &&
6441 >         { ac_try='test -s conftest$ac_exeext'
6442 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6443 >  (eval $ac_try) 2>&5
6444 >  ac_status=$?
6445 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6446 >  (exit $ac_status); }; }; then
6447 >  ac_cv_lib_fftw_fftwnd_one=yes
6448 > else
6449 >  echo "$as_me: failed program was:" >&5
6450 > sed 's/^/| /' conftest.$ac_ext >&5
6451  
6452 + ac_cv_lib_fftw_fftwnd_one=no
6453 + fi
6454 + rm -f conftest.err conftest.$ac_objext \
6455 +      conftest$ac_exeext conftest.$ac_ext
6456 + LIBS=$ac_check_lib_save_LIBS
6457 + fi
6458 + echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6459 + echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6460 + if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6461 +  fftw_cv_libfftw=yes
6462 + else
6463 +  fftw_cv_libfftw=no
6464 + fi
6465  
6466 <  if test "${ac_cv_header_iomanip+set}" = set; then
6467 <  echo "$as_me:$LINENO: checking for iomanip" >&5
6468 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
6469 < if test "${ac_cv_header_iomanip+set}" = set; then
6466 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6467 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6468 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6469 > if test "${ac_cv_header_fftw_h+set}" = set; then
6470    echo $ECHO_N "(cached) $ECHO_C" >&6
6471   fi
6472 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
6473 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6472 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6473 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6474   else
6475    # Is the header compilable?
6476 < echo "$as_me:$LINENO: checking iomanip usability" >&5
6477 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
6476 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6477 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6478   cat >conftest.$ac_ext <<_ACEOF
6479   /* confdefs.h.  */
6480   _ACEOF
# Line 5707 | Line 6482 | $ac_includes_default
6482   cat >>conftest.$ac_ext <<_ACEOF
6483   /* end confdefs.h.  */
6484   $ac_includes_default
6485 < #include <iomanip>
6485 > #include <fftw.h>
6486   _ACEOF
6487   rm -f conftest.$ac_objext
6488   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5718 | Line 6493 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6493    cat conftest.err >&5
6494    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6495    (exit $ac_status); } &&
6496 <         { ac_try='test -z "$ac_cxx_werror_flag"
6496 >         { ac_try='test -z "$ac_c_werror_flag"
6497                           || test ! -s conftest.err'
6498    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6499    (eval $ac_try) 2>&5
# Line 5743 | Line 6518 | echo "${ECHO_T}$ac_header_compiler" >&6
6518   echo "${ECHO_T}$ac_header_compiler" >&6
6519  
6520   # Is the header present?
6521 < echo "$as_me:$LINENO: checking iomanip presence" >&5
6522 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
6521 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6522 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6523   cat >conftest.$ac_ext <<_ACEOF
6524   /* confdefs.h.  */
6525   _ACEOF
6526   cat confdefs.h >>conftest.$ac_ext
6527   cat >>conftest.$ac_ext <<_ACEOF
6528   /* end confdefs.h.  */
6529 < #include <iomanip>
6529 > #include <fftw.h>
6530   _ACEOF
6531   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6532    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5762 | Line 6537 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6537    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6538    (exit $ac_status); } >/dev/null; then
6539    if test -s conftest.err; then
6540 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6541 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6540 >    ac_cpp_err=$ac_c_preproc_warn_flag
6541 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6542    else
6543      ac_cpp_err=
6544    fi
# Line 5783 | Line 6558 | echo "${ECHO_T}$ac_header_preproc" >&6
6558   echo "${ECHO_T}$ac_header_preproc" >&6
6559  
6560   # So?  What about this header?
6561 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6561 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6562    yes:no: )
6563 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
6564 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
6565 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
6566 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
6563 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6564 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6565 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6566 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6567      ac_header_preproc=yes
6568      ;;
6569    no:yes:* )
6570 <    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
6571 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
6572 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
6573 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
6574 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
6575 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
6576 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
6577 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
6578 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
6579 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
6580 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
6581 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
6570 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6571 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6572 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6573 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6574 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6575 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6576 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6577 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6578 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6579 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6580 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6581 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6582      (
6583        cat <<\_ASBOX
6584   ## ------------------------------ ##
# Line 5814 | Line 6589 | esac
6589        sed "s/^/$as_me: WARNING:     /" >&2
6590      ;;
6591   esac
6592 < echo "$as_me:$LINENO: checking for iomanip" >&5
6593 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
6594 < if test "${ac_cv_header_iomanip+set}" = set; then
6592 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6593 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6594 > if test "${ac_cv_header_fftw_h+set}" = set; then
6595    echo $ECHO_N "(cached) $ECHO_C" >&6
6596   else
6597 <  ac_cv_header_iomanip=$ac_header_preproc
6597 >  ac_cv_header_fftw_h=$ac_header_preproc
6598   fi
6599 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
6600 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6599 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6600 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6601  
6602   fi
6603 < if test $ac_cv_header_iomanip = yes; then
6603 > if test $ac_cv_header_fftw_h = yes; then
6604 >  fftw_cv_fftw_h=yes
6605 > else
6606 >  fftw_cv_fftw_h=no
6607 > fi
6608  
6609  
6610 < cat >>confdefs.h <<\_ACEOF
6611 < #define HAVE_IOMANIP 1
6610 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6611 >                then
6612 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6613 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6614 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6615 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6616 > else
6617 >  ac_check_lib_save_LIBS=$LIBS
6618 > LIBS="-ldfftw  $LIBS"
6619 > cat >conftest.$ac_ext <<_ACEOF
6620 > /* confdefs.h.  */
6621   _ACEOF
6622 + cat confdefs.h >>conftest.$ac_ext
6623 + cat >>conftest.$ac_ext <<_ACEOF
6624 + /* end confdefs.h.  */
6625  
6626 <
6626 > /* Override any gcc2 internal prototype to avoid an error.  */
6627 > #ifdef __cplusplus
6628 > extern "C"
6629 > #endif
6630 > /* We use char because int might match the return type of a gcc2
6631 >   builtin and then its argument prototype would still apply.  */
6632 > char fftwnd_one ();
6633 > #ifdef FC_DUMMY_MAIN
6634 > #ifndef FC_DUMMY_MAIN_EQ_F77
6635 > #  ifdef __cplusplus
6636 >     extern "C"
6637 > #  endif
6638 >   int FC_DUMMY_MAIN() { return 1; }
6639 > #endif
6640 > #endif
6641 > int
6642 > main ()
6643 > {
6644 > fftwnd_one ();
6645 >  ;
6646 >  return 0;
6647 > }
6648 > _ACEOF
6649 > rm -f conftest.$ac_objext conftest$ac_exeext
6650 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6651 >  (eval $ac_link) 2>conftest.er1
6652 >  ac_status=$?
6653 >  grep -v '^ *+' conftest.er1 >conftest.err
6654 >  rm -f conftest.er1
6655 >  cat conftest.err >&5
6656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6657 >  (exit $ac_status); } &&
6658 >         { ac_try='test -z "$ac_c_werror_flag"
6659 >                         || test ! -s conftest.err'
6660 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6661 >  (eval $ac_try) 2>&5
6662 >  ac_status=$?
6663 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6664 >  (exit $ac_status); }; } &&
6665 >         { ac_try='test -s conftest$ac_exeext'
6666 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6667 >  (eval $ac_try) 2>&5
6668 >  ac_status=$?
6669 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6670 >  (exit $ac_status); }; }; then
6671 >  ac_cv_lib_dfftw_fftwnd_one=yes
6672   else
6673 +  echo "$as_me: failed program was:" >&5
6674 + sed 's/^/| /' conftest.$ac_ext >&5
6675  
6676 + ac_cv_lib_dfftw_fftwnd_one=no
6677 + fi
6678 + rm -f conftest.err conftest.$ac_objext \
6679 +      conftest$ac_exeext conftest.$ac_ext
6680 + LIBS=$ac_check_lib_save_LIBS
6681 + fi
6682 + echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6683 + echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6684 + if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6685 +  fftw_cv_libdfftw=yes
6686 + else
6687 +  fftw_cv_libdfftw=no
6688 + fi
6689  
6690 < for ac_header in iomanip.h
6691 < do
6692 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6693 < 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
6690 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6691 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6692 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6693 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6694    echo $ECHO_N "(cached) $ECHO_C" >&6
6695   fi
6696 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6697 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6696 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6697 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6698   else
6699    # Is the header compilable?
6700 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6701 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6700 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6701 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6702   cat >conftest.$ac_ext <<_ACEOF
6703   /* confdefs.h.  */
6704   _ACEOF
# Line 5858 | Line 6706 | $ac_includes_default
6706   cat >>conftest.$ac_ext <<_ACEOF
6707   /* end confdefs.h.  */
6708   $ac_includes_default
6709 < #include <$ac_header>
6709 > #include <dfftw.h>
6710   _ACEOF
6711   rm -f conftest.$ac_objext
6712   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5869 | Line 6717 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6717    cat conftest.err >&5
6718    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6719    (exit $ac_status); } &&
6720 <         { ac_try='test -z "$ac_cxx_werror_flag"
6720 >         { ac_try='test -z "$ac_c_werror_flag"
6721                           || test ! -s conftest.err'
6722    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6723    (eval $ac_try) 2>&5
# Line 5894 | Line 6742 | echo "${ECHO_T}$ac_header_compiler" >&6
6742   echo "${ECHO_T}$ac_header_compiler" >&6
6743  
6744   # Is the header present?
6745 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6746 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6745 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6746 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6747   cat >conftest.$ac_ext <<_ACEOF
6748   /* confdefs.h.  */
6749   _ACEOF
6750   cat confdefs.h >>conftest.$ac_ext
6751   cat >>conftest.$ac_ext <<_ACEOF
6752   /* end confdefs.h.  */
6753 < #include <$ac_header>
6753 > #include <dfftw.h>
6754   _ACEOF
6755   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6756    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5913 | Line 6761 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6761    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6762    (exit $ac_status); } >/dev/null; then
6763    if test -s conftest.err; then
6764 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6765 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6764 >    ac_cpp_err=$ac_c_preproc_warn_flag
6765 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6766    else
6767      ac_cpp_err=
6768    fi
# Line 5934 | Line 6782 | echo "${ECHO_T}$ac_header_preproc" >&6
6782   echo "${ECHO_T}$ac_header_preproc" >&6
6783  
6784   # So?  What about this header?
6785 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6785 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6786    yes:no: )
6787 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6788 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6789 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6790 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6787 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6788 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6789 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6790 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6791      ac_header_preproc=yes
6792      ;;
6793    no:yes:* )
6794 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6795 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6796 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6797 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6798 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6799 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6800 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6801 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6802 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6803 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6804 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6805 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6806 <    (
6807 <      cat <<\_ASBOX
6808 < ## ------------------------------ ##
6809 < ## Report this to gezelter@nd.edu ##
6810 < ## ------------------------------ ##
6811 < _ASBOX
6812 <    ) |
6813 <      sed "s/^/$as_me: WARNING:     /" >&2
6814 <    ;;
6815 < esac
6816 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6817 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6818 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6819 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6820 < else
6821 <  eval "$as_ac_Header=\$ac_header_preproc"
6822 < fi
6823 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6824 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6825 <
6826 < fi
6827 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6828 <  cat >>confdefs.h <<_ACEOF
6829 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6830 < _ACEOF
6831 <
6832 < fi
6833 <
6834 < done
6835 <
6836 <
6837 < fi
6838 <
6839 <
6840 <
6841 <
6842 < for ac_header in cmath
6843 < do
6844 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6845 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6846 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6847 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6848 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6849 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6850 < fi
6851 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6852 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6853 < else
6854 <  # Is the header compilable?
6855 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6856 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6857 < cat >conftest.$ac_ext <<_ACEOF
6858 < /* confdefs.h.  */
6859 < _ACEOF
6860 < cat confdefs.h >>conftest.$ac_ext
6861 < cat >>conftest.$ac_ext <<_ACEOF
6862 < /* end confdefs.h.  */
6863 < $ac_includes_default
6864 < #include <$ac_header>
6865 < _ACEOF
6866 < rm -f conftest.$ac_objext
6867 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6868 <  (eval $ac_compile) 2>conftest.er1
6869 <  ac_status=$?
6870 <  grep -v '^ *+' conftest.er1 >conftest.err
6871 <  rm -f conftest.er1
6872 <  cat conftest.err >&5
6873 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6874 <  (exit $ac_status); } &&
6875 <         { ac_try='test -z "$ac_cxx_werror_flag"
6876 <                         || test ! -s conftest.err'
6877 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6878 <  (eval $ac_try) 2>&5
6879 <  ac_status=$?
6880 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6881 <  (exit $ac_status); }; } &&
6882 <         { ac_try='test -s conftest.$ac_objext'
6883 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6884 <  (eval $ac_try) 2>&5
6885 <  ac_status=$?
6886 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6887 <  (exit $ac_status); }; }; then
6888 <  ac_header_compiler=yes
6889 < else
6890 <  echo "$as_me: failed program was:" >&5
6891 < sed 's/^/| /' conftest.$ac_ext >&5
6892 <
6893 < ac_header_compiler=no
6894 < fi
6895 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6896 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6897 < echo "${ECHO_T}$ac_header_compiler" >&6
6898 <
6899 < # Is the header present?
6900 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6901 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6902 < cat >conftest.$ac_ext <<_ACEOF
6903 < /* confdefs.h.  */
6904 < _ACEOF
6905 < cat confdefs.h >>conftest.$ac_ext
6906 < cat >>conftest.$ac_ext <<_ACEOF
6907 < /* end confdefs.h.  */
6908 < #include <$ac_header>
6909 < _ACEOF
6910 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6911 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6912 <  ac_status=$?
6913 <  grep -v '^ *+' conftest.er1 >conftest.err
6914 <  rm -f conftest.er1
6915 <  cat conftest.err >&5
6916 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6917 <  (exit $ac_status); } >/dev/null; then
6918 <  if test -s conftest.err; then
6919 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6920 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6921 <  else
6922 <    ac_cpp_err=
6923 <  fi
6924 < else
6925 <  ac_cpp_err=yes
6926 < fi
6927 < if test -z "$ac_cpp_err"; then
6928 <  ac_header_preproc=yes
6929 < else
6930 <  echo "$as_me: failed program was:" >&5
6931 < sed 's/^/| /' conftest.$ac_ext >&5
6932 <
6933 <  ac_header_preproc=no
6934 < fi
6935 < rm -f conftest.err conftest.$ac_ext
6936 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6937 < echo "${ECHO_T}$ac_header_preproc" >&6
6938 <
6939 < # So?  What about this header?
6940 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6941 <  yes:no: )
6942 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6943 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6944 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6945 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6946 <    ac_header_preproc=yes
6947 <    ;;
6948 <  no:yes:* )
6949 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6950 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6951 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6952 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6953 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6954 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6955 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6956 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6957 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6958 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6959 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6960 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6961 <    (
6962 <      cat <<\_ASBOX
6963 < ## ------------------------------ ##
6964 < ## Report this to gezelter@nd.edu ##
6965 < ## ------------------------------ ##
6966 < _ASBOX
6967 <    ) |
6968 <      sed "s/^/$as_me: WARNING:     /" >&2
6969 <    ;;
6970 < esac
6971 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6972 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6973 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6974 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6975 < else
6976 <  eval "$as_ac_Header=\$ac_header_preproc"
6977 < fi
6978 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6979 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6980 <
6981 < fi
6982 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6983 <  cat >>confdefs.h <<_ACEOF
6984 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6985 < _ACEOF
6986 <
6987 < fi
6988 <
6989 < done
6990 <
6991 <
6992 <
6993 <
6994 <  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
6995 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
6996 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
6997 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6998 < else
6999 <
7000 <      ac_cv_cxx_have_std_iostream=no
7001 <      ac_cv_cxx_need_use_std_iostream=no
7002 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
7003 <
7004 <
7005 <        ac_ext=cc
7006 < ac_cpp='$CXXCPP $CPPFLAGS'
7007 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7008 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7009 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7010 <
7011 <        cat >conftest.$ac_ext <<_ACEOF
7012 < /* confdefs.h.  */
7013 < _ACEOF
7014 < cat confdefs.h >>conftest.$ac_ext
7015 < cat >>conftest.$ac_ext <<_ACEOF
7016 < /* end confdefs.h.  */
7017 <
7018 < #ifdef HAVE_IOSTREAM
7019 < #include <iostream>
7020 < #else
7021 < #include <iostream.h>
7022 < #endif
7023 <
7024 < int
7025 < main ()
7026 < {
7027 < std::cout<<"Hello World"<<std::endl;return 0;
7028 <  ;
7029 <  return 0;
7030 < }
7031 < _ACEOF
7032 < rm -f conftest.$ac_objext
7033 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7034 <  (eval $ac_compile) 2>conftest.er1
7035 <  ac_status=$?
7036 <  grep -v '^ *+' conftest.er1 >conftest.err
7037 <  rm -f conftest.er1
7038 <  cat conftest.err >&5
7039 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040 <  (exit $ac_status); } &&
7041 <         { ac_try='test -z "$ac_cxx_werror_flag"
7042 <                         || test ! -s conftest.err'
7043 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7044 <  (eval $ac_try) 2>&5
7045 <  ac_status=$?
7046 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7047 <  (exit $ac_status); }; } &&
7048 <         { ac_try='test -s conftest.$ac_objext'
7049 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7050 <  (eval $ac_try) 2>&5
7051 <  ac_status=$?
7052 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7053 <  (exit $ac_status); }; }; then
7054 <  ac_cv_cxx_have_std_iostream=yes
7055 < else
7056 <  echo "$as_me: failed program was:" >&5
7057 < sed 's/^/| /' conftest.$ac_ext >&5
7058 <
7059 < fi
7060 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7061 <        cat >conftest.$ac_ext <<_ACEOF
7062 < /* confdefs.h.  */
7063 < _ACEOF
7064 < cat confdefs.h >>conftest.$ac_ext
7065 < cat >>conftest.$ac_ext <<_ACEOF
7066 < /* end confdefs.h.  */
7067 <
7068 < #define __USE_STD_IOSTREAM 1
7069 < #ifdef HAVE_IOSTREAM
7070 < #include <iostream>
7071 < #else
7072 < #include <iostream.h>
7073 < #endif
7074 <
7075 < int
7076 < main ()
7077 < {
7078 < std::cout<<"Hello World"<<std::endl;return 0;
7079 <  ;
7080 <  return 0;
7081 < }
7082 < _ACEOF
7083 < rm -f conftest.$ac_objext
7084 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7085 <  (eval $ac_compile) 2>conftest.er1
7086 <  ac_status=$?
7087 <  grep -v '^ *+' conftest.er1 >conftest.err
7088 <  rm -f conftest.er1
7089 <  cat conftest.err >&5
7090 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7091 <  (exit $ac_status); } &&
7092 <         { ac_try='test -z "$ac_cxx_werror_flag"
7093 <                         || test ! -s conftest.err'
7094 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7095 <  (eval $ac_try) 2>&5
7096 <  ac_status=$?
7097 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7098 <  (exit $ac_status); }; } &&
7099 <         { ac_try='test -s conftest.$ac_objext'
7100 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7101 <  (eval $ac_try) 2>&5
7102 <  ac_status=$?
7103 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7104 <  (exit $ac_status); }; }; then
7105 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
7106 < else
7107 <  echo "$as_me: failed program was:" >&5
7108 < sed 's/^/| /' conftest.$ac_ext >&5
7109 <
7110 < fi
7111 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7112 <        ac_ext=cc
7113 < ac_cpp='$CXXCPP $CPPFLAGS'
7114 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7115 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7116 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7117 <
7118 <      fi
7119 <
7120 < fi
7121 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
7122 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
7123 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
7124 <
7125 < cat >>confdefs.h <<\_ACEOF
7126 < #define HAVE_STD_IOSTREAM 1
7127 < _ACEOF
7128 <
7129 <  fi
7130 <  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
7131 <
7132 < cat >>confdefs.h <<\_ACEOF
7133 < #define __USE_STD_IOSTREAM 1
7134 < _ACEOF
7135 <
7136 <  fi
7137 <
7138 <
7139 <
7140 <
7141 <  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
7142 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
7143 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
7144 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7145 < else
7146 <
7147 <      ac_cv_cxx_have_std_stl=no
7148 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
7149 <
7150 <
7151 <        ac_ext=cc
7152 < ac_cpp='$CXXCPP $CPPFLAGS'
7153 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7154 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7155 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7156 <
7157 <        cat >conftest.$ac_ext <<_ACEOF
7158 < /* confdefs.h.  */
7159 < _ACEOF
7160 < cat confdefs.h >>conftest.$ac_ext
7161 < cat >>conftest.$ac_ext <<_ACEOF
7162 < /* end confdefs.h.  */
7163 < #include <list>
7164 <
7165 < int
7166 < main ()
7167 < {
7168 < std::list<int> foo;return 0;
7169 <  ;
7170 <  return 0;
7171 < }
7172 < _ACEOF
7173 < rm -f conftest.$ac_objext
7174 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7175 <  (eval $ac_compile) 2>conftest.er1
7176 <  ac_status=$?
7177 <  grep -v '^ *+' conftest.er1 >conftest.err
7178 <  rm -f conftest.er1
7179 <  cat conftest.err >&5
7180 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7181 <  (exit $ac_status); } &&
7182 <         { ac_try='test -z "$ac_cxx_werror_flag"
7183 <                         || test ! -s conftest.err'
7184 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7185 <  (eval $ac_try) 2>&5
7186 <  ac_status=$?
7187 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7188 <  (exit $ac_status); }; } &&
7189 <         { ac_try='test -s conftest.$ac_objext'
7190 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7191 <  (eval $ac_try) 2>&5
7192 <  ac_status=$?
7193 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7194 <  (exit $ac_status); }; }; then
7195 <  ac_cv_cxx_have_std_stl=yes
7196 < else
7197 <  echo "$as_me: failed program was:" >&5
7198 < sed 's/^/| /' conftest.$ac_ext >&5
7199 <
6794 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6795 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6796 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6797 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6798 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6799 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6800 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6801 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6802 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6803 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6804 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6805 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6806 >    (
6807 >      cat <<\_ASBOX
6808 > ## ------------------------------ ##
6809 > ## Report this to gezelter@nd.edu ##
6810 > ## ------------------------------ ##
6811 > _ASBOX
6812 >    ) |
6813 >      sed "s/^/$as_me: WARNING:     /" >&2
6814 >    ;;
6815 > esac
6816 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6817 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6818 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6819 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6820 > else
6821 >  ac_cv_header_dfftw_h=$ac_header_preproc
6822 > fi
6823 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6824 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6825 >
6826 > fi
6827 > if test $ac_cv_header_dfftw_h = yes; then
6828 >  fftw_cv_dfftw_h=yes
6829 > else
6830 >  fftw_cv_dfftw_h=no
6831 > fi
6832 >
6833 >
6834 >                fi
6835 >        fi
6836 >        ac_ext=c
6837 > ac_cpp='$CPP $CPPFLAGS'
6838 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6839 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6840 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6841 >
6842 >
6843 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6844 >        then
6845 >
6846 > cat >>confdefs.h <<\_ACEOF
6847 > #define HAVE_FFTW3_H 1
6848 > _ACEOF
6849 >
6850 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6851 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6852 >                FFTW_LIBS="-lfftw3"
6853 >        else
6854 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6855 >        then
6856 >
6857 > cat >>confdefs.h <<\_ACEOF
6858 > #define HAVE_FFTW_H 1
6859 > _ACEOF
6860 >
6861 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6862 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6863 >                FFTW_LIBS="-lfftw"
6864 >        else
6865 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6866 >        then
6867 >
6868 > cat >>confdefs.h <<\_ACEOF
6869 > #define HAVE_DFFTW_H 1
6870 > _ACEOF
6871 >
6872 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6873 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6874 >                FFTW_LIBS="-ldfftw"
6875 >        else
6876 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6877 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6878 >                FFTW_INC_DIR=
6879 >                FFTW_LIB_DIR=
6880 >                FFTW_LIBS=
6881 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6882 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6883 >                echo "$as_me:$LINENO: result: failed" >&5
6884 > echo "${ECHO_T}failed" >&6
6885 >        echo ""
6886 >        echo "*********************************************************"
6887 >        echo "* WARNING: Could not find a working FFTW installation   *"
6888 >        echo "* If you need the staticProps program to be able to     *"
6889 >        echo "* compute undulation spectra, be sure to specify a      *"
6890 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6891 >        echo "*                                                       *"
6892 >        echo "* OOPSE will still work without fftw installed.         *"
6893 >        echo "*********************************************************"
6894 >        echo ""
6895 >        fi
6896 >        fi
6897 >        fi
6898 >
6899 >
6900 >
6901 > fi
6902 > fi
6903 >
6904 >
6905 >
6906 > # Checks for header files.
6907 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6908 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6909 > if test "${ac_cv_header_stdc+set}" = set; then
6910 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6911 > else
6912 >  cat >conftest.$ac_ext <<_ACEOF
6913 > /* confdefs.h.  */
6914 > _ACEOF
6915 > cat confdefs.h >>conftest.$ac_ext
6916 > cat >>conftest.$ac_ext <<_ACEOF
6917 > /* end confdefs.h.  */
6918 > #include <stdlib.h>
6919 > #include <stdarg.h>
6920 > #include <string.h>
6921 > #include <float.h>
6922 >
6923 > #ifdef FC_DUMMY_MAIN
6924 > #ifndef FC_DUMMY_MAIN_EQ_F77
6925 > #  ifdef __cplusplus
6926 >     extern "C"
6927 > #  endif
6928 >   int FC_DUMMY_MAIN() { return 1; }
6929 > #endif
6930 > #endif
6931 > int
6932 > main ()
6933 > {
6934 >
6935 >  ;
6936 >  return 0;
6937 > }
6938 > _ACEOF
6939 > rm -f conftest.$ac_objext
6940 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6941 >  (eval $ac_compile) 2>conftest.er1
6942 >  ac_status=$?
6943 >  grep -v '^ *+' conftest.er1 >conftest.err
6944 >  rm -f conftest.er1
6945 >  cat conftest.err >&5
6946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947 >  (exit $ac_status); } &&
6948 >         { ac_try='test -z "$ac_c_werror_flag"
6949 >                         || test ! -s conftest.err'
6950 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6951 >  (eval $ac_try) 2>&5
6952 >  ac_status=$?
6953 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6954 >  (exit $ac_status); }; } &&
6955 >         { ac_try='test -s conftest.$ac_objext'
6956 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6957 >  (eval $ac_try) 2>&5
6958 >  ac_status=$?
6959 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6960 >  (exit $ac_status); }; }; then
6961 >  ac_cv_header_stdc=yes
6962 > else
6963 >  echo "$as_me: failed program was:" >&5
6964 > sed 's/^/| /' conftest.$ac_ext >&5
6965 >
6966 > ac_cv_header_stdc=no
6967 > fi
6968 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6969 >
6970 > if test $ac_cv_header_stdc = yes; then
6971 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6972 >  cat >conftest.$ac_ext <<_ACEOF
6973 > /* confdefs.h.  */
6974 > _ACEOF
6975 > cat confdefs.h >>conftest.$ac_ext
6976 > cat >>conftest.$ac_ext <<_ACEOF
6977 > /* end confdefs.h.  */
6978 > #include <string.h>
6979 >
6980 > _ACEOF
6981 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6982 >  $EGREP "memchr" >/dev/null 2>&1; then
6983 >  :
6984 > else
6985 >  ac_cv_header_stdc=no
6986 > fi
6987 > rm -f conftest*
6988 >
6989 > fi
6990 >
6991 > if test $ac_cv_header_stdc = yes; then
6992 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6993 >  cat >conftest.$ac_ext <<_ACEOF
6994 > /* confdefs.h.  */
6995 > _ACEOF
6996 > cat confdefs.h >>conftest.$ac_ext
6997 > cat >>conftest.$ac_ext <<_ACEOF
6998 > /* end confdefs.h.  */
6999 > #include <stdlib.h>
7000 >
7001 > _ACEOF
7002 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7003 >  $EGREP "free" >/dev/null 2>&1; then
7004 >  :
7005 > else
7006 >  ac_cv_header_stdc=no
7007 > fi
7008 > rm -f conftest*
7009 >
7010 > fi
7011 >
7012 > if test $ac_cv_header_stdc = yes; then
7013 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7014 >  if test "$cross_compiling" = yes; then
7015 >  :
7016 > else
7017 >  cat >conftest.$ac_ext <<_ACEOF
7018 > /* confdefs.h.  */
7019 > _ACEOF
7020 > cat confdefs.h >>conftest.$ac_ext
7021 > cat >>conftest.$ac_ext <<_ACEOF
7022 > /* end confdefs.h.  */
7023 > #include <ctype.h>
7024 > #if ((' ' & 0x0FF) == 0x020)
7025 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7026 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7027 > #else
7028 > # define ISLOWER(c) \
7029 >                   (('a' <= (c) && (c) <= 'i') \
7030 >                     || ('j' <= (c) && (c) <= 'r') \
7031 >                     || ('s' <= (c) && (c) <= 'z'))
7032 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7033 > #endif
7034 >
7035 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7036 > int
7037 > main ()
7038 > {
7039 >  int i;
7040 >  for (i = 0; i < 256; i++)
7041 >    if (XOR (islower (i), ISLOWER (i))
7042 >        || toupper (i) != TOUPPER (i))
7043 >      exit(2);
7044 >  exit (0);
7045 > }
7046 > _ACEOF
7047 > rm -f conftest$ac_exeext
7048 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7049 >  (eval $ac_link) 2>&5
7050 >  ac_status=$?
7051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7052 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7054 >  (eval $ac_try) 2>&5
7055 >  ac_status=$?
7056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7057 >  (exit $ac_status); }; }; then
7058 >  :
7059 > else
7060 >  echo "$as_me: program exited with status $ac_status" >&5
7061 > echo "$as_me: failed program was:" >&5
7062 > sed 's/^/| /' conftest.$ac_ext >&5
7063 >
7064 > ( exit $ac_status )
7065 > ac_cv_header_stdc=no
7066 > fi
7067 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7068 > fi
7069 > fi
7070 > fi
7071 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7072 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7073 > if test $ac_cv_header_stdc = yes; then
7074 >
7075 > cat >>confdefs.h <<\_ACEOF
7076 > #define STDC_HEADERS 1
7077 > _ACEOF
7078 >
7079 > fi
7080 >
7081 >
7082 >
7083 >
7084 >
7085 >
7086 >
7087 >
7088 >
7089 >
7090 >
7091 >
7092 >
7093 >
7094 >
7095 >
7096 >
7097 >
7098 >
7099 >
7100 >
7101 >
7102 >
7103 >
7104 >
7105 >
7106 > for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7107 > do
7108 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7109 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7110 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7111 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7112 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7113 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7114 > fi
7115 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7116 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7117 > else
7118 >  # Is the header compilable?
7119 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7120 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7121 > cat >conftest.$ac_ext <<_ACEOF
7122 > /* confdefs.h.  */
7123 > _ACEOF
7124 > cat confdefs.h >>conftest.$ac_ext
7125 > cat >>conftest.$ac_ext <<_ACEOF
7126 > /* end confdefs.h.  */
7127 > $ac_includes_default
7128 > #include <$ac_header>
7129 > _ACEOF
7130 > rm -f conftest.$ac_objext
7131 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7132 >  (eval $ac_compile) 2>conftest.er1
7133 >  ac_status=$?
7134 >  grep -v '^ *+' conftest.er1 >conftest.err
7135 >  rm -f conftest.er1
7136 >  cat conftest.err >&5
7137 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7138 >  (exit $ac_status); } &&
7139 >         { ac_try='test -z "$ac_c_werror_flag"
7140 >                         || test ! -s conftest.err'
7141 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7142 >  (eval $ac_try) 2>&5
7143 >  ac_status=$?
7144 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7145 >  (exit $ac_status); }; } &&
7146 >         { ac_try='test -s conftest.$ac_objext'
7147 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7148 >  (eval $ac_try) 2>&5
7149 >  ac_status=$?
7150 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7151 >  (exit $ac_status); }; }; then
7152 >  ac_header_compiler=yes
7153 > else
7154 >  echo "$as_me: failed program was:" >&5
7155 > sed 's/^/| /' conftest.$ac_ext >&5
7156 >
7157 > ac_header_compiler=no
7158 > fi
7159 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7160 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7161 > echo "${ECHO_T}$ac_header_compiler" >&6
7162 >
7163 > # Is the header present?
7164 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7165 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7166 > cat >conftest.$ac_ext <<_ACEOF
7167 > /* confdefs.h.  */
7168 > _ACEOF
7169 > cat confdefs.h >>conftest.$ac_ext
7170 > cat >>conftest.$ac_ext <<_ACEOF
7171 > /* end confdefs.h.  */
7172 > #include <$ac_header>
7173 > _ACEOF
7174 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7175 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7176 >  ac_status=$?
7177 >  grep -v '^ *+' conftest.er1 >conftest.err
7178 >  rm -f conftest.er1
7179 >  cat conftest.err >&5
7180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7181 >  (exit $ac_status); } >/dev/null; then
7182 >  if test -s conftest.err; then
7183 >    ac_cpp_err=$ac_c_preproc_warn_flag
7184 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7185 >  else
7186 >    ac_cpp_err=
7187 >  fi
7188 > else
7189 >  ac_cpp_err=yes
7190 > fi
7191 > if test -z "$ac_cpp_err"; then
7192 >  ac_header_preproc=yes
7193 > else
7194 >  echo "$as_me: failed program was:" >&5
7195 > sed 's/^/| /' conftest.$ac_ext >&5
7196 >
7197 >  ac_header_preproc=no
7198 > fi
7199 > rm -f conftest.err conftest.$ac_ext
7200 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7201 > echo "${ECHO_T}$ac_header_preproc" >&6
7202 >
7203 > # So?  What about this header?
7204 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7205 >  yes:no: )
7206 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7207 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7208 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7209 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7210 >    ac_header_preproc=yes
7211 >    ;;
7212 >  no:yes:* )
7213 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7214 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7215 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7216 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7217 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7218 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7219 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7220 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7221 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7222 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7223 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7224 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7225 >    (
7226 >      cat <<\_ASBOX
7227 > ## ------------------------------ ##
7228 > ## Report this to gezelter@nd.edu ##
7229 > ## ------------------------------ ##
7230 > _ASBOX
7231 >    ) |
7232 >      sed "s/^/$as_me: WARNING:     /" >&2
7233 >    ;;
7234 > esac
7235 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7236 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7237 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7238 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7239 > else
7240 >  eval "$as_ac_Header=\$ac_header_preproc"
7241 > fi
7242 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7243 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7244 >
7245 > fi
7246 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7247 >  cat >>confdefs.h <<_ACEOF
7248 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7249 > _ACEOF
7250 >
7251 > fi
7252 >
7253 > done
7254 >
7255 >
7256 > # Checks for typedefs, structures, and compiler characteristics.
7257 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7258 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7259 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7260 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7261 > else
7262 >  cat >conftest.$ac_ext <<_ACEOF
7263 > /* confdefs.h.  */
7264 > _ACEOF
7265 > cat confdefs.h >>conftest.$ac_ext
7266 > cat >>conftest.$ac_ext <<_ACEOF
7267 > /* end confdefs.h.  */
7268 >
7269 > #include <stdbool.h>
7270 > #ifndef bool
7271 > # error bool is not defined
7272 > #endif
7273 > #ifndef false
7274 > # error false is not defined
7275 > #endif
7276 > #if false
7277 > # error false is not 0
7278 > #endif
7279 > #ifndef true
7280 > # error true is not defined
7281 > #endif
7282 > #if true != 1
7283 > # error true is not 1
7284 > #endif
7285 > #ifndef __bool_true_false_are_defined
7286 > # error __bool_true_false_are_defined is not defined
7287 > #endif
7288 >
7289 >        struct s { _Bool s: 1; _Bool t; } s;
7290 >
7291 >        char a[true == 1 ? 1 : -1];
7292 >        char b[false == 0 ? 1 : -1];
7293 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7294 >        char d[(bool) -0.5 == true ? 1 : -1];
7295 >        bool e = &s;
7296 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7297 >        char g[true];
7298 >        char h[sizeof (_Bool)];
7299 >        char i[sizeof s.t];
7300 >
7301 > #ifdef FC_DUMMY_MAIN
7302 > #ifndef FC_DUMMY_MAIN_EQ_F77
7303 > #  ifdef __cplusplus
7304 >     extern "C"
7305 > #  endif
7306 >   int FC_DUMMY_MAIN() { return 1; }
7307 > #endif
7308 > #endif
7309 > int
7310 > main ()
7311 > {
7312 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7313 >  ;
7314 >  return 0;
7315 > }
7316 > _ACEOF
7317 > rm -f conftest.$ac_objext
7318 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7319 >  (eval $ac_compile) 2>conftest.er1
7320 >  ac_status=$?
7321 >  grep -v '^ *+' conftest.er1 >conftest.err
7322 >  rm -f conftest.er1
7323 >  cat conftest.err >&5
7324 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7325 >  (exit $ac_status); } &&
7326 >         { ac_try='test -z "$ac_c_werror_flag"
7327 >                         || test ! -s conftest.err'
7328 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7329 >  (eval $ac_try) 2>&5
7330 >  ac_status=$?
7331 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7332 >  (exit $ac_status); }; } &&
7333 >         { ac_try='test -s conftest.$ac_objext'
7334 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7335 >  (eval $ac_try) 2>&5
7336 >  ac_status=$?
7337 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7338 >  (exit $ac_status); }; }; then
7339 >  ac_cv_header_stdbool_h=yes
7340 > else
7341 >  echo "$as_me: failed program was:" >&5
7342 > sed 's/^/| /' conftest.$ac_ext >&5
7343 >
7344 > ac_cv_header_stdbool_h=no
7345 > fi
7346 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7347 > fi
7348 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7349 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7350 > echo "$as_me:$LINENO: checking for _Bool" >&5
7351 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7352 > if test "${ac_cv_type__Bool+set}" = set; then
7353 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7354 > else
7355 >  cat >conftest.$ac_ext <<_ACEOF
7356 > /* confdefs.h.  */
7357 > _ACEOF
7358 > cat confdefs.h >>conftest.$ac_ext
7359 > cat >>conftest.$ac_ext <<_ACEOF
7360 > /* end confdefs.h.  */
7361 > $ac_includes_default
7362 > #ifdef FC_DUMMY_MAIN
7363 > #ifndef FC_DUMMY_MAIN_EQ_F77
7364 > #  ifdef __cplusplus
7365 >     extern "C"
7366 > #  endif
7367 >   int FC_DUMMY_MAIN() { return 1; }
7368 > #endif
7369 > #endif
7370 > int
7371 > main ()
7372 > {
7373 > if ((_Bool *) 0)
7374 >  return 0;
7375 > if (sizeof (_Bool))
7376 >  return 0;
7377 >  ;
7378 >  return 0;
7379 > }
7380 > _ACEOF
7381 > rm -f conftest.$ac_objext
7382 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7383 >  (eval $ac_compile) 2>conftest.er1
7384 >  ac_status=$?
7385 >  grep -v '^ *+' conftest.er1 >conftest.err
7386 >  rm -f conftest.er1
7387 >  cat conftest.err >&5
7388 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7389 >  (exit $ac_status); } &&
7390 >         { ac_try='test -z "$ac_c_werror_flag"
7391 >                         || test ! -s conftest.err'
7392 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7393 >  (eval $ac_try) 2>&5
7394 >  ac_status=$?
7395 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7396 >  (exit $ac_status); }; } &&
7397 >         { ac_try='test -s conftest.$ac_objext'
7398 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7399 >  (eval $ac_try) 2>&5
7400 >  ac_status=$?
7401 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7402 >  (exit $ac_status); }; }; then
7403 >  ac_cv_type__Bool=yes
7404 > else
7405 >  echo "$as_me: failed program was:" >&5
7406 > sed 's/^/| /' conftest.$ac_ext >&5
7407 >
7408 > ac_cv_type__Bool=no
7409 > fi
7410 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7411 > fi
7412 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7413 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7414 > if test $ac_cv_type__Bool = yes; then
7415 >
7416 > cat >>confdefs.h <<_ACEOF
7417 > #define HAVE__BOOL 1
7418 > _ACEOF
7419 >
7420 >
7421 > fi
7422 >
7423 > if test $ac_cv_header_stdbool_h = yes; then
7424 >
7425 > cat >>confdefs.h <<\_ACEOF
7426 > #define HAVE_STDBOOL_H 1
7427 > _ACEOF
7428 >
7429 > fi
7430 >
7431 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7432 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7433 > if test "${ac_cv_c_const+set}" = set; then
7434 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7435 > else
7436 >  cat >conftest.$ac_ext <<_ACEOF
7437 > /* confdefs.h.  */
7438 > _ACEOF
7439 > cat confdefs.h >>conftest.$ac_ext
7440 > cat >>conftest.$ac_ext <<_ACEOF
7441 > /* end confdefs.h.  */
7442 >
7443 > #ifdef FC_DUMMY_MAIN
7444 > #ifndef FC_DUMMY_MAIN_EQ_F77
7445 > #  ifdef __cplusplus
7446 >     extern "C"
7447 > #  endif
7448 >   int FC_DUMMY_MAIN() { return 1; }
7449 > #endif
7450 > #endif
7451 > int
7452 > main ()
7453 > {
7454 > /* FIXME: Include the comments suggested by Paul. */
7455 > #ifndef __cplusplus
7456 >  /* Ultrix mips cc rejects this.  */
7457 >  typedef int charset[2];
7458 >  const charset x;
7459 >  /* SunOS 4.1.1 cc rejects this.  */
7460 >  char const *const *ccp;
7461 >  char **p;
7462 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7463 >  struct point {int x, y;};
7464 >  static struct point const zero = {0,0};
7465 >  /* AIX XL C 1.02.0.0 rejects this.
7466 >     It does not let you subtract one const X* pointer from another in
7467 >     an arm of an if-expression whose if-part is not a constant
7468 >     expression */
7469 >  const char *g = "string";
7470 >  ccp = &g + (g ? g-g : 0);
7471 >  /* HPUX 7.0 cc rejects these. */
7472 >  ++ccp;
7473 >  p = (char**) ccp;
7474 >  ccp = (char const *const *) p;
7475 >  { /* SCO 3.2v4 cc rejects this.  */
7476 >    char *t;
7477 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7478 >
7479 >    *t++ = 0;
7480 >  }
7481 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7482 >    int x[] = {25, 17};
7483 >    const int *foo = &x[0];
7484 >    ++foo;
7485 >  }
7486 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7487 >    typedef const int *iptr;
7488 >    iptr p = 0;
7489 >    ++p;
7490 >  }
7491 >  { /* AIX XL C 1.02.0.0 rejects this saying
7492 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7493 >    struct s { int j; const int *ap[3]; };
7494 >    struct s *b; b->j = 5;
7495 >  }
7496 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7497 >    const int foo = 10;
7498 >  }
7499 > #endif
7500 >
7501 >  ;
7502 >  return 0;
7503 > }
7504 > _ACEOF
7505 > rm -f conftest.$ac_objext
7506 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7507 >  (eval $ac_compile) 2>conftest.er1
7508 >  ac_status=$?
7509 >  grep -v '^ *+' conftest.er1 >conftest.err
7510 >  rm -f conftest.er1
7511 >  cat conftest.err >&5
7512 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7513 >  (exit $ac_status); } &&
7514 >         { ac_try='test -z "$ac_c_werror_flag"
7515 >                         || test ! -s conftest.err'
7516 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7517 >  (eval $ac_try) 2>&5
7518 >  ac_status=$?
7519 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7520 >  (exit $ac_status); }; } &&
7521 >         { ac_try='test -s conftest.$ac_objext'
7522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7523 >  (eval $ac_try) 2>&5
7524 >  ac_status=$?
7525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7526 >  (exit $ac_status); }; }; then
7527 >  ac_cv_c_const=yes
7528 > else
7529 >  echo "$as_me: failed program was:" >&5
7530 > sed 's/^/| /' conftest.$ac_ext >&5
7531 >
7532 > ac_cv_c_const=no
7533 > fi
7534 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7535 > fi
7536 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7537 > echo "${ECHO_T}$ac_cv_c_const" >&6
7538 > if test $ac_cv_c_const = no; then
7539 >
7540 > cat >>confdefs.h <<\_ACEOF
7541 > #define const
7542 > _ACEOF
7543 >
7544 > fi
7545 >
7546 > echo "$as_me:$LINENO: checking for inline" >&5
7547 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7548 > if test "${ac_cv_c_inline+set}" = set; then
7549 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7550 > else
7551 >  ac_cv_c_inline=no
7552 > for ac_kw in inline __inline__ __inline; do
7553 >  cat >conftest.$ac_ext <<_ACEOF
7554 > /* confdefs.h.  */
7555 > _ACEOF
7556 > cat confdefs.h >>conftest.$ac_ext
7557 > cat >>conftest.$ac_ext <<_ACEOF
7558 > /* end confdefs.h.  */
7559 > #ifndef __cplusplus
7560 > typedef int foo_t;
7561 > static $ac_kw foo_t static_foo () {return 0; }
7562 > $ac_kw foo_t foo () {return 0; }
7563 > #endif
7564 >
7565 > _ACEOF
7566 > rm -f conftest.$ac_objext
7567 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7568 >  (eval $ac_compile) 2>conftest.er1
7569 >  ac_status=$?
7570 >  grep -v '^ *+' conftest.er1 >conftest.err
7571 >  rm -f conftest.er1
7572 >  cat conftest.err >&5
7573 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7574 >  (exit $ac_status); } &&
7575 >         { ac_try='test -z "$ac_c_werror_flag"
7576 >                         || test ! -s conftest.err'
7577 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7578 >  (eval $ac_try) 2>&5
7579 >  ac_status=$?
7580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7581 >  (exit $ac_status); }; } &&
7582 >         { ac_try='test -s conftest.$ac_objext'
7583 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7584 >  (eval $ac_try) 2>&5
7585 >  ac_status=$?
7586 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7587 >  (exit $ac_status); }; }; then
7588 >  ac_cv_c_inline=$ac_kw; break
7589 > else
7590 >  echo "$as_me: failed program was:" >&5
7591 > sed 's/^/| /' conftest.$ac_ext >&5
7592 >
7593 > fi
7594 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7595 > done
7596 >
7597 > fi
7598 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7599 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7600 >
7601 >
7602 > case $ac_cv_c_inline in
7603 >  inline | yes) ;;
7604 >  *)
7605 >    case $ac_cv_c_inline in
7606 >      no) ac_val=;;
7607 >      *) ac_val=$ac_cv_c_inline;;
7608 >    esac
7609 >    cat >>confdefs.h <<_ACEOF
7610 > #ifndef __cplusplus
7611 > #define inline $ac_val
7612 > #endif
7613 > _ACEOF
7614 >    ;;
7615 > esac
7616 >
7617 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7618 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7619 > if test "${ac_cv_c_restrict+set}" = set; then
7620 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7621 > else
7622 >  ac_cv_c_restrict=no
7623 >   # Try the official restrict keyword, then gcc's __restrict, and
7624 >   # the less common variants.
7625 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7626 >     cat >conftest.$ac_ext <<_ACEOF
7627 > /* confdefs.h.  */
7628 > _ACEOF
7629 > cat confdefs.h >>conftest.$ac_ext
7630 > cat >>conftest.$ac_ext <<_ACEOF
7631 > /* end confdefs.h.  */
7632 > float * $ac_kw x;
7633 > _ACEOF
7634 > rm -f conftest.$ac_objext
7635 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7636 >  (eval $ac_compile) 2>conftest.er1
7637 >  ac_status=$?
7638 >  grep -v '^ *+' conftest.er1 >conftest.err
7639 >  rm -f conftest.er1
7640 >  cat conftest.err >&5
7641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7642 >  (exit $ac_status); } &&
7643 >         { ac_try='test -z "$ac_c_werror_flag"
7644 >                         || test ! -s conftest.err'
7645 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7646 >  (eval $ac_try) 2>&5
7647 >  ac_status=$?
7648 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7649 >  (exit $ac_status); }; } &&
7650 >         { ac_try='test -s conftest.$ac_objext'
7651 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7652 >  (eval $ac_try) 2>&5
7653 >  ac_status=$?
7654 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7655 >  (exit $ac_status); }; }; then
7656 >  ac_cv_c_restrict=$ac_kw; break
7657 > else
7658 >  echo "$as_me: failed program was:" >&5
7659 > sed 's/^/| /' conftest.$ac_ext >&5
7660 >
7661 > fi
7662 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7663 >   done
7664 >
7665 > fi
7666 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7667 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7668 > case $ac_cv_c_restrict in
7669 >   restrict) ;;
7670 >   no)
7671 > cat >>confdefs.h <<\_ACEOF
7672 > #define restrict
7673 > _ACEOF
7674 > ;;
7675 >   *)  cat >>confdefs.h <<_ACEOF
7676 > #define restrict $ac_cv_c_restrict
7677 > _ACEOF
7678 > ;;
7679 > esac
7680 >
7681 > echo "$as_me:$LINENO: checking for size_t" >&5
7682 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7683 > if test "${ac_cv_type_size_t+set}" = set; then
7684 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7685 > else
7686 >  cat >conftest.$ac_ext <<_ACEOF
7687 > /* confdefs.h.  */
7688 > _ACEOF
7689 > cat confdefs.h >>conftest.$ac_ext
7690 > cat >>conftest.$ac_ext <<_ACEOF
7691 > /* end confdefs.h.  */
7692 > $ac_includes_default
7693 > #ifdef FC_DUMMY_MAIN
7694 > #ifndef FC_DUMMY_MAIN_EQ_F77
7695 > #  ifdef __cplusplus
7696 >     extern "C"
7697 > #  endif
7698 >   int FC_DUMMY_MAIN() { return 1; }
7699 > #endif
7700 > #endif
7701 > int
7702 > main ()
7703 > {
7704 > if ((size_t *) 0)
7705 >  return 0;
7706 > if (sizeof (size_t))
7707 >  return 0;
7708 >  ;
7709 >  return 0;
7710 > }
7711 > _ACEOF
7712 > rm -f conftest.$ac_objext
7713 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7714 >  (eval $ac_compile) 2>conftest.er1
7715 >  ac_status=$?
7716 >  grep -v '^ *+' conftest.er1 >conftest.err
7717 >  rm -f conftest.er1
7718 >  cat conftest.err >&5
7719 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720 >  (exit $ac_status); } &&
7721 >         { ac_try='test -z "$ac_c_werror_flag"
7722 >                         || test ! -s conftest.err'
7723 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7724 >  (eval $ac_try) 2>&5
7725 >  ac_status=$?
7726 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7727 >  (exit $ac_status); }; } &&
7728 >         { ac_try='test -s conftest.$ac_objext'
7729 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7730 >  (eval $ac_try) 2>&5
7731 >  ac_status=$?
7732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7733 >  (exit $ac_status); }; }; then
7734 >  ac_cv_type_size_t=yes
7735 > else
7736 >  echo "$as_me: failed program was:" >&5
7737 > sed 's/^/| /' conftest.$ac_ext >&5
7738 >
7739 > ac_cv_type_size_t=no
7740 > fi
7741 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7742 > fi
7743 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7744 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7745 > if test $ac_cv_type_size_t = yes; then
7746 >  :
7747 > else
7748 >
7749 > cat >>confdefs.h <<_ACEOF
7750 > #define size_t unsigned
7751 > _ACEOF
7752 >
7753 > fi
7754 >
7755 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7756 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7757 > if test "${ac_cv_header_time+set}" = set; then
7758 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7759 > else
7760 >  cat >conftest.$ac_ext <<_ACEOF
7761 > /* confdefs.h.  */
7762 > _ACEOF
7763 > cat confdefs.h >>conftest.$ac_ext
7764 > cat >>conftest.$ac_ext <<_ACEOF
7765 > /* end confdefs.h.  */
7766 > #include <sys/types.h>
7767 > #include <sys/time.h>
7768 > #include <time.h>
7769 >
7770 > #ifdef FC_DUMMY_MAIN
7771 > #ifndef FC_DUMMY_MAIN_EQ_F77
7772 > #  ifdef __cplusplus
7773 >     extern "C"
7774 > #  endif
7775 >   int FC_DUMMY_MAIN() { return 1; }
7776 > #endif
7777 > #endif
7778 > int
7779 > main ()
7780 > {
7781 > if ((struct tm *) 0)
7782 > return 0;
7783 >  ;
7784 >  return 0;
7785 > }
7786 > _ACEOF
7787 > rm -f conftest.$ac_objext
7788 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7789 >  (eval $ac_compile) 2>conftest.er1
7790 >  ac_status=$?
7791 >  grep -v '^ *+' conftest.er1 >conftest.err
7792 >  rm -f conftest.er1
7793 >  cat conftest.err >&5
7794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7795 >  (exit $ac_status); } &&
7796 >         { ac_try='test -z "$ac_c_werror_flag"
7797 >                         || test ! -s conftest.err'
7798 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7799 >  (eval $ac_try) 2>&5
7800 >  ac_status=$?
7801 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7802 >  (exit $ac_status); }; } &&
7803 >         { ac_try='test -s conftest.$ac_objext'
7804 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7805 >  (eval $ac_try) 2>&5
7806 >  ac_status=$?
7807 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7808 >  (exit $ac_status); }; }; then
7809 >  ac_cv_header_time=yes
7810 > else
7811 >  echo "$as_me: failed program was:" >&5
7812 > sed 's/^/| /' conftest.$ac_ext >&5
7813 >
7814 > ac_cv_header_time=no
7815 > fi
7816 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7817 > fi
7818 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7819 > echo "${ECHO_T}$ac_cv_header_time" >&6
7820 > if test $ac_cv_header_time = yes; then
7821 >
7822 > cat >>confdefs.h <<\_ACEOF
7823 > #define TIME_WITH_SYS_TIME 1
7824 > _ACEOF
7825 >
7826 > fi
7827 >
7828 > echo "$as_me:$LINENO: checking for clock_t" >&5
7829 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7830 > if test "${ac_cv_type_clock_t+set}" = set; then
7831 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7832 > else
7833 >  cat >conftest.$ac_ext <<_ACEOF
7834 > /* confdefs.h.  */
7835 > _ACEOF
7836 > cat confdefs.h >>conftest.$ac_ext
7837 > cat >>conftest.$ac_ext <<_ACEOF
7838 > /* end confdefs.h.  */
7839 > $ac_includes_default
7840 > #ifdef FC_DUMMY_MAIN
7841 > #ifndef FC_DUMMY_MAIN_EQ_F77
7842 > #  ifdef __cplusplus
7843 >     extern "C"
7844 > #  endif
7845 >   int FC_DUMMY_MAIN() { return 1; }
7846 > #endif
7847 > #endif
7848 > int
7849 > main ()
7850 > {
7851 > if ((clock_t *) 0)
7852 >  return 0;
7853 > if (sizeof (clock_t))
7854 >  return 0;
7855 >  ;
7856 >  return 0;
7857 > }
7858 > _ACEOF
7859 > rm -f conftest.$ac_objext
7860 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7861 >  (eval $ac_compile) 2>conftest.er1
7862 >  ac_status=$?
7863 >  grep -v '^ *+' conftest.er1 >conftest.err
7864 >  rm -f conftest.er1
7865 >  cat conftest.err >&5
7866 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7867 >  (exit $ac_status); } &&
7868 >         { ac_try='test -z "$ac_c_werror_flag"
7869 >                         || test ! -s conftest.err'
7870 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7871 >  (eval $ac_try) 2>&5
7872 >  ac_status=$?
7873 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7874 >  (exit $ac_status); }; } &&
7875 >         { ac_try='test -s conftest.$ac_objext'
7876 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7877 >  (eval $ac_try) 2>&5
7878 >  ac_status=$?
7879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7880 >  (exit $ac_status); }; }; then
7881 >  ac_cv_type_clock_t=yes
7882 > else
7883 >  echo "$as_me: failed program was:" >&5
7884 > sed 's/^/| /' conftest.$ac_ext >&5
7885 >
7886 > ac_cv_type_clock_t=no
7887 > fi
7888 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7889 > fi
7890 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7891 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7892 > if test $ac_cv_type_clock_t = yes; then
7893 >
7894 > cat >>confdefs.h <<_ACEOF
7895 > #define HAVE_CLOCK_T 1
7896 > _ACEOF
7897 >
7898 >
7899 > fi
7900 >
7901 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7902 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7903 > if test "${ac_cv_c_const+set}" = set; then
7904 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7905 > else
7906 >  cat >conftest.$ac_ext <<_ACEOF
7907 > /* confdefs.h.  */
7908 > _ACEOF
7909 > cat confdefs.h >>conftest.$ac_ext
7910 > cat >>conftest.$ac_ext <<_ACEOF
7911 > /* end confdefs.h.  */
7912 >
7913 > #ifdef FC_DUMMY_MAIN
7914 > #ifndef FC_DUMMY_MAIN_EQ_F77
7915 > #  ifdef __cplusplus
7916 >     extern "C"
7917 > #  endif
7918 >   int FC_DUMMY_MAIN() { return 1; }
7919 > #endif
7920 > #endif
7921 > int
7922 > main ()
7923 > {
7924 > /* FIXME: Include the comments suggested by Paul. */
7925 > #ifndef __cplusplus
7926 >  /* Ultrix mips cc rejects this.  */
7927 >  typedef int charset[2];
7928 >  const charset x;
7929 >  /* SunOS 4.1.1 cc rejects this.  */
7930 >  char const *const *ccp;
7931 >  char **p;
7932 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7933 >  struct point {int x, y;};
7934 >  static struct point const zero = {0,0};
7935 >  /* AIX XL C 1.02.0.0 rejects this.
7936 >     It does not let you subtract one const X* pointer from another in
7937 >     an arm of an if-expression whose if-part is not a constant
7938 >     expression */
7939 >  const char *g = "string";
7940 >  ccp = &g + (g ? g-g : 0);
7941 >  /* HPUX 7.0 cc rejects these. */
7942 >  ++ccp;
7943 >  p = (char**) ccp;
7944 >  ccp = (char const *const *) p;
7945 >  { /* SCO 3.2v4 cc rejects this.  */
7946 >    char *t;
7947 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7948 >
7949 >    *t++ = 0;
7950 >  }
7951 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7952 >    int x[] = {25, 17};
7953 >    const int *foo = &x[0];
7954 >    ++foo;
7955 >  }
7956 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7957 >    typedef const int *iptr;
7958 >    iptr p = 0;
7959 >    ++p;
7960 >  }
7961 >  { /* AIX XL C 1.02.0.0 rejects this saying
7962 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7963 >    struct s { int j; const int *ap[3]; };
7964 >    struct s *b; b->j = 5;
7965 >  }
7966 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7967 >    const int foo = 10;
7968 >  }
7969 > #endif
7970 >
7971 >  ;
7972 >  return 0;
7973 > }
7974 > _ACEOF
7975 > rm -f conftest.$ac_objext
7976 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7977 >  (eval $ac_compile) 2>conftest.er1
7978 >  ac_status=$?
7979 >  grep -v '^ *+' conftest.er1 >conftest.err
7980 >  rm -f conftest.er1
7981 >  cat conftest.err >&5
7982 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7983 >  (exit $ac_status); } &&
7984 >         { ac_try='test -z "$ac_c_werror_flag"
7985 >                         || test ! -s conftest.err'
7986 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7987 >  (eval $ac_try) 2>&5
7988 >  ac_status=$?
7989 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7990 >  (exit $ac_status); }; } &&
7991 >         { ac_try='test -s conftest.$ac_objext'
7992 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7993 >  (eval $ac_try) 2>&5
7994 >  ac_status=$?
7995 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7996 >  (exit $ac_status); }; }; then
7997 >  ac_cv_c_const=yes
7998 > else
7999 >  echo "$as_me: failed program was:" >&5
8000 > sed 's/^/| /' conftest.$ac_ext >&5
8001 >
8002 > ac_cv_c_const=no
8003 > fi
8004 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8005 > fi
8006 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8007 > echo "${ECHO_T}$ac_cv_c_const" >&6
8008 > if test $ac_cv_c_const = no; then
8009 >
8010 > cat >>confdefs.h <<\_ACEOF
8011 > #define const
8012 > _ACEOF
8013 >
8014 > fi
8015 >
8016 > echo "$as_me:$LINENO: checking for inline" >&5
8017 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8018 > if test "${ac_cv_c_inline+set}" = set; then
8019 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8020 > else
8021 >  ac_cv_c_inline=no
8022 > for ac_kw in inline __inline__ __inline; do
8023 >  cat >conftest.$ac_ext <<_ACEOF
8024 > /* confdefs.h.  */
8025 > _ACEOF
8026 > cat confdefs.h >>conftest.$ac_ext
8027 > cat >>conftest.$ac_ext <<_ACEOF
8028 > /* end confdefs.h.  */
8029 > #ifndef __cplusplus
8030 > typedef int foo_t;
8031 > static $ac_kw foo_t static_foo () {return 0; }
8032 > $ac_kw foo_t foo () {return 0; }
8033 > #endif
8034 >
8035 > _ACEOF
8036 > rm -f conftest.$ac_objext
8037 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8038 >  (eval $ac_compile) 2>conftest.er1
8039 >  ac_status=$?
8040 >  grep -v '^ *+' conftest.er1 >conftest.err
8041 >  rm -f conftest.er1
8042 >  cat conftest.err >&5
8043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8044 >  (exit $ac_status); } &&
8045 >         { ac_try='test -z "$ac_c_werror_flag"
8046 >                         || test ! -s conftest.err'
8047 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8048 >  (eval $ac_try) 2>&5
8049 >  ac_status=$?
8050 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8051 >  (exit $ac_status); }; } &&
8052 >         { ac_try='test -s conftest.$ac_objext'
8053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8054 >  (eval $ac_try) 2>&5
8055 >  ac_status=$?
8056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8057 >  (exit $ac_status); }; }; then
8058 >  ac_cv_c_inline=$ac_kw; break
8059 > else
8060 >  echo "$as_me: failed program was:" >&5
8061 > sed 's/^/| /' conftest.$ac_ext >&5
8062 >
8063 > fi
8064 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8065 > done
8066 >
8067 > fi
8068 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8069 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8070 >
8071 >
8072 > case $ac_cv_c_inline in
8073 >  inline | yes) ;;
8074 >  *)
8075 >    case $ac_cv_c_inline in
8076 >      no) ac_val=;;
8077 >      *) ac_val=$ac_cv_c_inline;;
8078 >    esac
8079 >    cat >>confdefs.h <<_ACEOF
8080 > #ifndef __cplusplus
8081 > #define inline $ac_val
8082 > #endif
8083 > _ACEOF
8084 >    ;;
8085 > esac
8086 >
8087 >
8088 > # Checks for library functions.
8089 >
8090 > for ac_header in stdlib.h
8091 > do
8092 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8093 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8094 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8095 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8096 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8097 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8098 > fi
8099 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8100 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8101 > else
8102 >  # Is the header compilable?
8103 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8104 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8105 > cat >conftest.$ac_ext <<_ACEOF
8106 > /* confdefs.h.  */
8107 > _ACEOF
8108 > cat confdefs.h >>conftest.$ac_ext
8109 > cat >>conftest.$ac_ext <<_ACEOF
8110 > /* end confdefs.h.  */
8111 > $ac_includes_default
8112 > #include <$ac_header>
8113 > _ACEOF
8114 > rm -f conftest.$ac_objext
8115 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8116 >  (eval $ac_compile) 2>conftest.er1
8117 >  ac_status=$?
8118 >  grep -v '^ *+' conftest.er1 >conftest.err
8119 >  rm -f conftest.er1
8120 >  cat conftest.err >&5
8121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122 >  (exit $ac_status); } &&
8123 >         { ac_try='test -z "$ac_c_werror_flag"
8124 >                         || test ! -s conftest.err'
8125 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8126 >  (eval $ac_try) 2>&5
8127 >  ac_status=$?
8128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8129 >  (exit $ac_status); }; } &&
8130 >         { ac_try='test -s conftest.$ac_objext'
8131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8132 >  (eval $ac_try) 2>&5
8133 >  ac_status=$?
8134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8135 >  (exit $ac_status); }; }; then
8136 >  ac_header_compiler=yes
8137 > else
8138 >  echo "$as_me: failed program was:" >&5
8139 > sed 's/^/| /' conftest.$ac_ext >&5
8140 >
8141 > ac_header_compiler=no
8142 > fi
8143 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8144 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8145 > echo "${ECHO_T}$ac_header_compiler" >&6
8146 >
8147 > # Is the header present?
8148 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8149 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8150 > cat >conftest.$ac_ext <<_ACEOF
8151 > /* confdefs.h.  */
8152 > _ACEOF
8153 > cat confdefs.h >>conftest.$ac_ext
8154 > cat >>conftest.$ac_ext <<_ACEOF
8155 > /* end confdefs.h.  */
8156 > #include <$ac_header>
8157 > _ACEOF
8158 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8159 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8160 >  ac_status=$?
8161 >  grep -v '^ *+' conftest.er1 >conftest.err
8162 >  rm -f conftest.er1
8163 >  cat conftest.err >&5
8164 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8165 >  (exit $ac_status); } >/dev/null; then
8166 >  if test -s conftest.err; then
8167 >    ac_cpp_err=$ac_c_preproc_warn_flag
8168 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8169 >  else
8170 >    ac_cpp_err=
8171 >  fi
8172 > else
8173 >  ac_cpp_err=yes
8174 > fi
8175 > if test -z "$ac_cpp_err"; then
8176 >  ac_header_preproc=yes
8177 > else
8178 >  echo "$as_me: failed program was:" >&5
8179 > sed 's/^/| /' conftest.$ac_ext >&5
8180 >
8181 >  ac_header_preproc=no
8182 > fi
8183 > rm -f conftest.err conftest.$ac_ext
8184 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8185 > echo "${ECHO_T}$ac_header_preproc" >&6
8186 >
8187 > # So?  What about this header?
8188 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8189 >  yes:no: )
8190 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8191 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8192 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8193 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8194 >    ac_header_preproc=yes
8195 >    ;;
8196 >  no:yes:* )
8197 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8198 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8199 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8200 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8201 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8202 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8203 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8204 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8205 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8206 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8207 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8208 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8209 >    (
8210 >      cat <<\_ASBOX
8211 > ## ------------------------------ ##
8212 > ## Report this to gezelter@nd.edu ##
8213 > ## ------------------------------ ##
8214 > _ASBOX
8215 >    ) |
8216 >      sed "s/^/$as_me: WARNING:     /" >&2
8217 >    ;;
8218 > esac
8219 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8220 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8221 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8222 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8223 > else
8224 >  eval "$as_ac_Header=\$ac_header_preproc"
8225 > fi
8226 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8227 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8228 >
8229 > fi
8230 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8231 >  cat >>confdefs.h <<_ACEOF
8232 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8233 > _ACEOF
8234 >
8235 > fi
8236 >
8237 > done
8238 >
8239 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8240 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8241 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8242 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8243 > else
8244 >  if test "$cross_compiling" = yes; then
8245 >  ac_cv_func_malloc_0_nonnull=no
8246 > else
8247 >  cat >conftest.$ac_ext <<_ACEOF
8248 > /* confdefs.h.  */
8249 > _ACEOF
8250 > cat confdefs.h >>conftest.$ac_ext
8251 > cat >>conftest.$ac_ext <<_ACEOF
8252 > /* end confdefs.h.  */
8253 > #if STDC_HEADERS || HAVE_STDLIB_H
8254 > # include <stdlib.h>
8255 > #else
8256 > char *malloc ();
8257 > #endif
8258 >
8259 > #ifdef FC_DUMMY_MAIN
8260 > #ifndef FC_DUMMY_MAIN_EQ_F77
8261 > #  ifdef __cplusplus
8262 >     extern "C"
8263 > #  endif
8264 >   int FC_DUMMY_MAIN() { return 1; }
8265 > #endif
8266 > #endif
8267 > int
8268 > main ()
8269 > {
8270 > exit (malloc (0) ? 0 : 1);
8271 >  ;
8272 >  return 0;
8273 > }
8274 > _ACEOF
8275 > rm -f conftest$ac_exeext
8276 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8277 >  (eval $ac_link) 2>&5
8278 >  ac_status=$?
8279 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8280 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8281 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8282 >  (eval $ac_try) 2>&5
8283 >  ac_status=$?
8284 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8285 >  (exit $ac_status); }; }; then
8286 >  ac_cv_func_malloc_0_nonnull=yes
8287 > else
8288 >  echo "$as_me: program exited with status $ac_status" >&5
8289 > echo "$as_me: failed program was:" >&5
8290 > sed 's/^/| /' conftest.$ac_ext >&5
8291 >
8292 > ( exit $ac_status )
8293 > ac_cv_func_malloc_0_nonnull=no
8294 > fi
8295 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8296 > fi
8297 > fi
8298 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8299 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8300 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8301 >
8302 > cat >>confdefs.h <<\_ACEOF
8303 > #define HAVE_MALLOC 1
8304 > _ACEOF
8305 >
8306 > else
8307 >  cat >>confdefs.h <<\_ACEOF
8308 > #define HAVE_MALLOC 0
8309 > _ACEOF
8310 >
8311 >   case $LIBOBJS in
8312 >    "malloc.$ac_objext"   | \
8313 >  *" malloc.$ac_objext"   | \
8314 >    "malloc.$ac_objext "* | \
8315 >  *" malloc.$ac_objext "* ) ;;
8316 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8317 > esac
8318 >
8319 >
8320 > cat >>confdefs.h <<\_ACEOF
8321 > #define malloc rpl_malloc
8322 > _ACEOF
8323 >
8324 > fi
8325 >
8326 >
8327 >
8328 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8329 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8330 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8331 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8332 > else
8333 >  if test "$cross_compiling" = yes; then
8334 >  ac_cv_func_memcmp_working=no
8335 > else
8336 >  cat >conftest.$ac_ext <<_ACEOF
8337 > /* confdefs.h.  */
8338 > _ACEOF
8339 > cat confdefs.h >>conftest.$ac_ext
8340 > cat >>conftest.$ac_ext <<_ACEOF
8341 > /* end confdefs.h.  */
8342 > $ac_includes_default
8343 > #ifdef FC_DUMMY_MAIN
8344 > #ifndef FC_DUMMY_MAIN_EQ_F77
8345 > #  ifdef __cplusplus
8346 >     extern "C"
8347 > #  endif
8348 >   int FC_DUMMY_MAIN() { return 1; }
8349 > #endif
8350 > #endif
8351 > int
8352 > main ()
8353 > {
8354 >
8355 >  /* Some versions of memcmp are not 8-bit clean.  */
8356 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8357 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8358 >    exit (1);
8359 >
8360 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8361 >     or more and with at least one buffer not starting on a 4-byte boundary.
8362 >     William Lewis provided this test program.   */
8363 >  {
8364 >    char foo[21];
8365 >    char bar[21];
8366 >    int i;
8367 >    for (i = 0; i < 4; i++)
8368 >      {
8369 >        char *a = foo + i;
8370 >        char *b = bar + i;
8371 >        strcpy (a, "--------01111111");
8372 >        strcpy (b, "--------10000000");
8373 >        if (memcmp (a, b, 16) >= 0)
8374 >          exit (1);
8375 >      }
8376 >    exit (0);
8377 >  }
8378 >
8379 >  ;
8380 >  return 0;
8381 > }
8382 > _ACEOF
8383 > rm -f conftest$ac_exeext
8384 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8385 >  (eval $ac_link) 2>&5
8386 >  ac_status=$?
8387 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8388 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8389 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8390 >  (eval $ac_try) 2>&5
8391 >  ac_status=$?
8392 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8393 >  (exit $ac_status); }; }; then
8394 >  ac_cv_func_memcmp_working=yes
8395 > else
8396 >  echo "$as_me: program exited with status $ac_status" >&5
8397 > echo "$as_me: failed program was:" >&5
8398 > sed 's/^/| /' conftest.$ac_ext >&5
8399 >
8400 > ( exit $ac_status )
8401 > ac_cv_func_memcmp_working=no
8402 > fi
8403 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8404 > fi
8405 > fi
8406 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8407 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8408 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8409 >    "memcmp.$ac_objext"   | \
8410 >  *" memcmp.$ac_objext"   | \
8411 >    "memcmp.$ac_objext "* | \
8412 >  *" memcmp.$ac_objext "* ) ;;
8413 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8414 > esac
8415 >
8416 >
8417 >
8418 > for ac_header in stdlib.h
8419 > do
8420 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8421 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8422 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8423 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8424 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8425 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8426 > fi
8427 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8428 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8429 > else
8430 >  # Is the header compilable?
8431 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8432 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8433 > cat >conftest.$ac_ext <<_ACEOF
8434 > /* confdefs.h.  */
8435 > _ACEOF
8436 > cat confdefs.h >>conftest.$ac_ext
8437 > cat >>conftest.$ac_ext <<_ACEOF
8438 > /* end confdefs.h.  */
8439 > $ac_includes_default
8440 > #include <$ac_header>
8441 > _ACEOF
8442 > rm -f conftest.$ac_objext
8443 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8444 >  (eval $ac_compile) 2>conftest.er1
8445 >  ac_status=$?
8446 >  grep -v '^ *+' conftest.er1 >conftest.err
8447 >  rm -f conftest.er1
8448 >  cat conftest.err >&5
8449 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8450 >  (exit $ac_status); } &&
8451 >         { ac_try='test -z "$ac_c_werror_flag"
8452 >                         || test ! -s conftest.err'
8453 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8454 >  (eval $ac_try) 2>&5
8455 >  ac_status=$?
8456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8457 >  (exit $ac_status); }; } &&
8458 >         { ac_try='test -s conftest.$ac_objext'
8459 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8460 >  (eval $ac_try) 2>&5
8461 >  ac_status=$?
8462 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8463 >  (exit $ac_status); }; }; then
8464 >  ac_header_compiler=yes
8465 > else
8466 >  echo "$as_me: failed program was:" >&5
8467 > sed 's/^/| /' conftest.$ac_ext >&5
8468 >
8469 > ac_header_compiler=no
8470 > fi
8471 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8472 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8473 > echo "${ECHO_T}$ac_header_compiler" >&6
8474 >
8475 > # Is the header present?
8476 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8477 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8478 > cat >conftest.$ac_ext <<_ACEOF
8479 > /* confdefs.h.  */
8480 > _ACEOF
8481 > cat confdefs.h >>conftest.$ac_ext
8482 > cat >>conftest.$ac_ext <<_ACEOF
8483 > /* end confdefs.h.  */
8484 > #include <$ac_header>
8485 > _ACEOF
8486 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8487 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8488 >  ac_status=$?
8489 >  grep -v '^ *+' conftest.er1 >conftest.err
8490 >  rm -f conftest.er1
8491 >  cat conftest.err >&5
8492 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8493 >  (exit $ac_status); } >/dev/null; then
8494 >  if test -s conftest.err; then
8495 >    ac_cpp_err=$ac_c_preproc_warn_flag
8496 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8497 >  else
8498 >    ac_cpp_err=
8499 >  fi
8500 > else
8501 >  ac_cpp_err=yes
8502 > fi
8503 > if test -z "$ac_cpp_err"; then
8504 >  ac_header_preproc=yes
8505 > else
8506 >  echo "$as_me: failed program was:" >&5
8507 > sed 's/^/| /' conftest.$ac_ext >&5
8508 >
8509 >  ac_header_preproc=no
8510 > fi
8511 > rm -f conftest.err conftest.$ac_ext
8512 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8513 > echo "${ECHO_T}$ac_header_preproc" >&6
8514 >
8515 > # So?  What about this header?
8516 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8517 >  yes:no: )
8518 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8519 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8520 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8521 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8522 >    ac_header_preproc=yes
8523 >    ;;
8524 >  no:yes:* )
8525 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8526 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8527 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8528 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8529 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8530 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8531 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8532 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8533 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8534 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8535 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8536 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8537 >    (
8538 >      cat <<\_ASBOX
8539 > ## ------------------------------ ##
8540 > ## Report this to gezelter@nd.edu ##
8541 > ## ------------------------------ ##
8542 > _ASBOX
8543 >    ) |
8544 >      sed "s/^/$as_me: WARNING:     /" >&2
8545 >    ;;
8546 > esac
8547 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8548 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8549 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8550 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8551 > else
8552 >  eval "$as_ac_Header=\$ac_header_preproc"
8553 > fi
8554 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8555 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8556 >
8557 > fi
8558 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8559 >  cat >>confdefs.h <<_ACEOF
8560 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8561 > _ACEOF
8562 >
8563 > fi
8564 >
8565 > done
8566 >
8567 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8568 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8569 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8570 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8571 > else
8572 >  if test "$cross_compiling" = yes; then
8573 >  ac_cv_func_realloc_0_nonnull=no
8574 > else
8575 >  cat >conftest.$ac_ext <<_ACEOF
8576 > /* confdefs.h.  */
8577 > _ACEOF
8578 > cat confdefs.h >>conftest.$ac_ext
8579 > cat >>conftest.$ac_ext <<_ACEOF
8580 > /* end confdefs.h.  */
8581 > #if STDC_HEADERS || HAVE_STDLIB_H
8582 > # include <stdlib.h>
8583 > #else
8584 > char *realloc ();
8585 > #endif
8586 >
8587 > #ifdef FC_DUMMY_MAIN
8588 > #ifndef FC_DUMMY_MAIN_EQ_F77
8589 > #  ifdef __cplusplus
8590 >     extern "C"
8591 > #  endif
8592 >   int FC_DUMMY_MAIN() { return 1; }
8593 > #endif
8594 > #endif
8595 > int
8596 > main ()
8597 > {
8598 > exit (realloc (0, 0) ? 0 : 1);
8599 >  ;
8600 >  return 0;
8601 > }
8602 > _ACEOF
8603 > rm -f conftest$ac_exeext
8604 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8605 >  (eval $ac_link) 2>&5
8606 >  ac_status=$?
8607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8608 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8610 >  (eval $ac_try) 2>&5
8611 >  ac_status=$?
8612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8613 >  (exit $ac_status); }; }; then
8614 >  ac_cv_func_realloc_0_nonnull=yes
8615 > else
8616 >  echo "$as_me: program exited with status $ac_status" >&5
8617 > echo "$as_me: failed program was:" >&5
8618 > sed 's/^/| /' conftest.$ac_ext >&5
8619 >
8620 > ( exit $ac_status )
8621 > ac_cv_func_realloc_0_nonnull=no
8622 > fi
8623 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8624 > fi
8625 > fi
8626 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8627 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8628 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8629 >
8630 > cat >>confdefs.h <<\_ACEOF
8631 > #define HAVE_REALLOC 1
8632 > _ACEOF
8633 >
8634 > else
8635 >  cat >>confdefs.h <<\_ACEOF
8636 > #define HAVE_REALLOC 0
8637 > _ACEOF
8638 >
8639 >   case $LIBOBJS in
8640 >    "realloc.$ac_objext"   | \
8641 >  *" realloc.$ac_objext"   | \
8642 >    "realloc.$ac_objext "* | \
8643 >  *" realloc.$ac_objext "* ) ;;
8644 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8645 > esac
8646 >
8647 >
8648 > cat >>confdefs.h <<\_ACEOF
8649 > #define realloc rpl_realloc
8650 > _ACEOF
8651 >
8652 > fi
8653 >
8654 >
8655 >
8656 >
8657 >
8658 > for ac_header in sys/select.h sys/socket.h
8659 > do
8660 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8661 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8662 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8663 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8664 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8665 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8666 > fi
8667 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8668 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8669 > else
8670 >  # Is the header compilable?
8671 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8672 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8673 > cat >conftest.$ac_ext <<_ACEOF
8674 > /* confdefs.h.  */
8675 > _ACEOF
8676 > cat confdefs.h >>conftest.$ac_ext
8677 > cat >>conftest.$ac_ext <<_ACEOF
8678 > /* end confdefs.h.  */
8679 > $ac_includes_default
8680 > #include <$ac_header>
8681 > _ACEOF
8682 > rm -f conftest.$ac_objext
8683 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8684 >  (eval $ac_compile) 2>conftest.er1
8685 >  ac_status=$?
8686 >  grep -v '^ *+' conftest.er1 >conftest.err
8687 >  rm -f conftest.er1
8688 >  cat conftest.err >&5
8689 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8690 >  (exit $ac_status); } &&
8691 >         { ac_try='test -z "$ac_c_werror_flag"
8692 >                         || test ! -s conftest.err'
8693 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8694 >  (eval $ac_try) 2>&5
8695 >  ac_status=$?
8696 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8697 >  (exit $ac_status); }; } &&
8698 >         { ac_try='test -s conftest.$ac_objext'
8699 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8700 >  (eval $ac_try) 2>&5
8701 >  ac_status=$?
8702 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8703 >  (exit $ac_status); }; }; then
8704 >  ac_header_compiler=yes
8705 > else
8706 >  echo "$as_me: failed program was:" >&5
8707 > sed 's/^/| /' conftest.$ac_ext >&5
8708 >
8709 > ac_header_compiler=no
8710 > fi
8711 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8712 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8713 > echo "${ECHO_T}$ac_header_compiler" >&6
8714 >
8715 > # Is the header present?
8716 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8717 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8718 > cat >conftest.$ac_ext <<_ACEOF
8719 > /* confdefs.h.  */
8720 > _ACEOF
8721 > cat confdefs.h >>conftest.$ac_ext
8722 > cat >>conftest.$ac_ext <<_ACEOF
8723 > /* end confdefs.h.  */
8724 > #include <$ac_header>
8725 > _ACEOF
8726 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8727 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8728 >  ac_status=$?
8729 >  grep -v '^ *+' conftest.er1 >conftest.err
8730 >  rm -f conftest.er1
8731 >  cat conftest.err >&5
8732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8733 >  (exit $ac_status); } >/dev/null; then
8734 >  if test -s conftest.err; then
8735 >    ac_cpp_err=$ac_c_preproc_warn_flag
8736 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8737 >  else
8738 >    ac_cpp_err=
8739 >  fi
8740 > else
8741 >  ac_cpp_err=yes
8742 > fi
8743 > if test -z "$ac_cpp_err"; then
8744 >  ac_header_preproc=yes
8745 > else
8746 >  echo "$as_me: failed program was:" >&5
8747 > sed 's/^/| /' conftest.$ac_ext >&5
8748 >
8749 >  ac_header_preproc=no
8750 > fi
8751 > rm -f conftest.err conftest.$ac_ext
8752 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8753 > echo "${ECHO_T}$ac_header_preproc" >&6
8754 >
8755 > # So?  What about this header?
8756 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8757 >  yes:no: )
8758 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8759 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8760 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8761 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8762 >    ac_header_preproc=yes
8763 >    ;;
8764 >  no:yes:* )
8765 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8766 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8767 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8768 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8769 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8770 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8771 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8772 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8773 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8774 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8775 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8776 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8777 >    (
8778 >      cat <<\_ASBOX
8779 > ## ------------------------------ ##
8780 > ## Report this to gezelter@nd.edu ##
8781 > ## ------------------------------ ##
8782 > _ASBOX
8783 >    ) |
8784 >      sed "s/^/$as_me: WARNING:     /" >&2
8785 >    ;;
8786 > esac
8787 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8788 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8789 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8790 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8791 > else
8792 >  eval "$as_ac_Header=\$ac_header_preproc"
8793 > fi
8794 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8795 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8796 >
8797 > fi
8798 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8799 >  cat >>confdefs.h <<_ACEOF
8800 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8801 > _ACEOF
8802 >
8803 > fi
8804 >
8805 > done
8806 >
8807 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8808 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8809 > if test "${ac_cv_func_select_args+set}" = set; then
8810 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8811 > else
8812 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8813 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8814 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8815 >   cat >conftest.$ac_ext <<_ACEOF
8816 > /* confdefs.h.  */
8817 > _ACEOF
8818 > cat confdefs.h >>conftest.$ac_ext
8819 > cat >>conftest.$ac_ext <<_ACEOF
8820 > /* end confdefs.h.  */
8821 > $ac_includes_default
8822 > #if HAVE_SYS_SELECT_H
8823 > # include <sys/select.h>
8824 > #endif
8825 > #if HAVE_SYS_SOCKET_H
8826 > # include <sys/socket.h>
8827 > #endif
8828 >
8829 > #ifdef FC_DUMMY_MAIN
8830 > #ifndef FC_DUMMY_MAIN_EQ_F77
8831 > #  ifdef __cplusplus
8832 >     extern "C"
8833 > #  endif
8834 >   int FC_DUMMY_MAIN() { return 1; }
8835 > #endif
8836 > #endif
8837 > int
8838 > main ()
8839 > {
8840 > extern int select ($ac_arg1,
8841 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8842 >                                            $ac_arg5);
8843 >  ;
8844 >  return 0;
8845 > }
8846 > _ACEOF
8847 > rm -f conftest.$ac_objext
8848 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8849 >  (eval $ac_compile) 2>conftest.er1
8850 >  ac_status=$?
8851 >  grep -v '^ *+' conftest.er1 >conftest.err
8852 >  rm -f conftest.er1
8853 >  cat conftest.err >&5
8854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8855 >  (exit $ac_status); } &&
8856 >         { ac_try='test -z "$ac_c_werror_flag"
8857 >                         || test ! -s conftest.err'
8858 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8859 >  (eval $ac_try) 2>&5
8860 >  ac_status=$?
8861 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8862 >  (exit $ac_status); }; } &&
8863 >         { ac_try='test -s conftest.$ac_objext'
8864 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8865 >  (eval $ac_try) 2>&5
8866 >  ac_status=$?
8867 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8868 >  (exit $ac_status); }; }; then
8869 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8870 > else
8871 >  echo "$as_me: failed program was:" >&5
8872 > sed 's/^/| /' conftest.$ac_ext >&5
8873 >
8874 > fi
8875 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8876 >  done
8877 > done
8878 > done
8879 > # Provide a safe default value.
8880 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8881 >
8882 > fi
8883 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8884 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8885 > ac_save_IFS=$IFS; IFS=','
8886 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8887 > IFS=$ac_save_IFS
8888 > shift
8889 >
8890 > cat >>confdefs.h <<_ACEOF
8891 > #define SELECT_TYPE_ARG1 $1
8892 > _ACEOF
8893 >
8894 >
8895 > cat >>confdefs.h <<_ACEOF
8896 > #define SELECT_TYPE_ARG234 ($2)
8897 > _ACEOF
8898 >
8899 >
8900 > cat >>confdefs.h <<_ACEOF
8901 > #define SELECT_TYPE_ARG5 ($3)
8902 > _ACEOF
8903 >
8904 > rm -f conftest*
8905 >
8906 >
8907 > for ac_func in strftime
8908 > do
8909 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8910 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8911 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8912 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8913 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8914 > else
8915 >  cat >conftest.$ac_ext <<_ACEOF
8916 > /* confdefs.h.  */
8917 > _ACEOF
8918 > cat confdefs.h >>conftest.$ac_ext
8919 > cat >>conftest.$ac_ext <<_ACEOF
8920 > /* end confdefs.h.  */
8921 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8922 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8923 > #define $ac_func innocuous_$ac_func
8924 >
8925 > /* System header to define __stub macros and hopefully few prototypes,
8926 >    which can conflict with char $ac_func (); below.
8927 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8928 >    <limits.h> exists even on freestanding compilers.  */
8929 >
8930 > #ifdef __STDC__
8931 > # include <limits.h>
8932 > #else
8933 > # include <assert.h>
8934 > #endif
8935 >
8936 > #undef $ac_func
8937 >
8938 > /* Override any gcc2 internal prototype to avoid an error.  */
8939 > #ifdef __cplusplus
8940 > extern "C"
8941 > {
8942 > #endif
8943 > /* We use char because int might match the return type of a gcc2
8944 >   builtin and then its argument prototype would still apply.  */
8945 > char $ac_func ();
8946 > /* The GNU C library defines this for functions which it implements
8947 >    to always fail with ENOSYS.  Some functions are actually named
8948 >    something starting with __ and the normal name is an alias.  */
8949 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8950 > choke me
8951 > #else
8952 > char (*f) () = $ac_func;
8953 > #endif
8954 > #ifdef __cplusplus
8955 > }
8956 > #endif
8957 >
8958 > #ifdef FC_DUMMY_MAIN
8959 > #ifndef FC_DUMMY_MAIN_EQ_F77
8960 > #  ifdef __cplusplus
8961 >     extern "C"
8962 > #  endif
8963 >   int FC_DUMMY_MAIN() { return 1; }
8964 > #endif
8965 > #endif
8966 > int
8967 > main ()
8968 > {
8969 > return f != $ac_func;
8970 >  ;
8971 >  return 0;
8972 > }
8973 > _ACEOF
8974 > rm -f conftest.$ac_objext conftest$ac_exeext
8975 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8976 >  (eval $ac_link) 2>conftest.er1
8977 >  ac_status=$?
8978 >  grep -v '^ *+' conftest.er1 >conftest.err
8979 >  rm -f conftest.er1
8980 >  cat conftest.err >&5
8981 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8982 >  (exit $ac_status); } &&
8983 >         { ac_try='test -z "$ac_c_werror_flag"
8984 >                         || test ! -s conftest.err'
8985 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8986 >  (eval $ac_try) 2>&5
8987 >  ac_status=$?
8988 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8989 >  (exit $ac_status); }; } &&
8990 >         { ac_try='test -s conftest$ac_exeext'
8991 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8992 >  (eval $ac_try) 2>&5
8993 >  ac_status=$?
8994 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8995 >  (exit $ac_status); }; }; then
8996 >  eval "$as_ac_var=yes"
8997 > else
8998 >  echo "$as_me: failed program was:" >&5
8999 > sed 's/^/| /' conftest.$ac_ext >&5
9000 >
9001 > eval "$as_ac_var=no"
9002 > fi
9003 > rm -f conftest.err conftest.$ac_objext \
9004 >      conftest$ac_exeext conftest.$ac_ext
9005 > fi
9006 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9007 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9008 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9009 >  cat >>confdefs.h <<_ACEOF
9010 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9011 > _ACEOF
9012 >
9013 > else
9014 >  # strftime is in -lintl on SCO UNIX.
9015 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9016 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9017 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9018 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9019 > else
9020 >  ac_check_lib_save_LIBS=$LIBS
9021 > LIBS="-lintl  $LIBS"
9022 > cat >conftest.$ac_ext <<_ACEOF
9023 > /* confdefs.h.  */
9024 > _ACEOF
9025 > cat confdefs.h >>conftest.$ac_ext
9026 > cat >>conftest.$ac_ext <<_ACEOF
9027 > /* end confdefs.h.  */
9028 >
9029 > /* Override any gcc2 internal prototype to avoid an error.  */
9030 > #ifdef __cplusplus
9031 > extern "C"
9032 > #endif
9033 > /* We use char because int might match the return type of a gcc2
9034 >   builtin and then its argument prototype would still apply.  */
9035 > char strftime ();
9036 > #ifdef FC_DUMMY_MAIN
9037 > #ifndef FC_DUMMY_MAIN_EQ_F77
9038 > #  ifdef __cplusplus
9039 >     extern "C"
9040 > #  endif
9041 >   int FC_DUMMY_MAIN() { return 1; }
9042 > #endif
9043 > #endif
9044 > int
9045 > main ()
9046 > {
9047 > strftime ();
9048 >  ;
9049 >  return 0;
9050 > }
9051 > _ACEOF
9052 > rm -f conftest.$ac_objext conftest$ac_exeext
9053 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9054 >  (eval $ac_link) 2>conftest.er1
9055 >  ac_status=$?
9056 >  grep -v '^ *+' conftest.er1 >conftest.err
9057 >  rm -f conftest.er1
9058 >  cat conftest.err >&5
9059 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9060 >  (exit $ac_status); } &&
9061 >         { ac_try='test -z "$ac_c_werror_flag"
9062 >                         || test ! -s conftest.err'
9063 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9064 >  (eval $ac_try) 2>&5
9065 >  ac_status=$?
9066 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067 >  (exit $ac_status); }; } &&
9068 >         { ac_try='test -s conftest$ac_exeext'
9069 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9070 >  (eval $ac_try) 2>&5
9071 >  ac_status=$?
9072 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073 >  (exit $ac_status); }; }; then
9074 >  ac_cv_lib_intl_strftime=yes
9075 > else
9076 >  echo "$as_me: failed program was:" >&5
9077 > sed 's/^/| /' conftest.$ac_ext >&5
9078 >
9079 > ac_cv_lib_intl_strftime=no
9080 > fi
9081 > rm -f conftest.err conftest.$ac_objext \
9082 >      conftest$ac_exeext conftest.$ac_ext
9083 > LIBS=$ac_check_lib_save_LIBS
9084 > fi
9085 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9086 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9087 > if test $ac_cv_lib_intl_strftime = yes; then
9088 >  cat >>confdefs.h <<\_ACEOF
9089 > #define HAVE_STRFTIME 1
9090 > _ACEOF
9091 >
9092 > LIBS="-lintl $LIBS"
9093 > fi
9094 >
9095 > fi
9096 > done
9097 >
9098 > echo "$as_me:$LINENO: checking for working strtod" >&5
9099 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9100 > if test "${ac_cv_func_strtod+set}" = set; then
9101 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9102 > else
9103 >  if test "$cross_compiling" = yes; then
9104 >  ac_cv_func_strtod=no
9105 > else
9106 >  cat >conftest.$ac_ext <<_ACEOF
9107 > /* confdefs.h.  */
9108 > _ACEOF
9109 > cat confdefs.h >>conftest.$ac_ext
9110 > cat >>conftest.$ac_ext <<_ACEOF
9111 > /* end confdefs.h.  */
9112 >
9113 > double strtod ();
9114 > int
9115 > main()
9116 > {
9117 >  {
9118 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9119 >    char *string = " +69";
9120 >    char *term;
9121 >    double value;
9122 >    value = strtod (string, &term);
9123 >    if (value != 69 || term != (string + 4))
9124 >      exit (1);
9125 >  }
9126 >
9127 >  {
9128 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9129 >       terminating character under some conditions.  */
9130 >    char *string = "NaN";
9131 >    char *term;
9132 >    strtod (string, &term);
9133 >    if (term != string && *(term - 1) == 0)
9134 >      exit (1);
9135 >  }
9136 >  exit (0);
9137 > }
9138 >
9139 > _ACEOF
9140 > rm -f conftest$ac_exeext
9141 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9142 >  (eval $ac_link) 2>&5
9143 >  ac_status=$?
9144 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9145 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9146 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9147 >  (eval $ac_try) 2>&5
9148 >  ac_status=$?
9149 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9150 >  (exit $ac_status); }; }; then
9151 >  ac_cv_func_strtod=yes
9152 > else
9153 >  echo "$as_me: program exited with status $ac_status" >&5
9154 > echo "$as_me: failed program was:" >&5
9155 > sed 's/^/| /' conftest.$ac_ext >&5
9156 >
9157 > ( exit $ac_status )
9158 > ac_cv_func_strtod=no
9159 > fi
9160 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9161 > fi
9162 > fi
9163 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9164 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9165 > if test $ac_cv_func_strtod = no; then
9166 >  case $LIBOBJS in
9167 >    "strtod.$ac_objext"   | \
9168 >  *" strtod.$ac_objext"   | \
9169 >    "strtod.$ac_objext "* | \
9170 >  *" strtod.$ac_objext "* ) ;;
9171 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9172 > esac
9173 >
9174 > echo "$as_me:$LINENO: checking for pow" >&5
9175 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9176 > if test "${ac_cv_func_pow+set}" = set; then
9177 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9178 > else
9179 >  cat >conftest.$ac_ext <<_ACEOF
9180 > /* confdefs.h.  */
9181 > _ACEOF
9182 > cat confdefs.h >>conftest.$ac_ext
9183 > cat >>conftest.$ac_ext <<_ACEOF
9184 > /* end confdefs.h.  */
9185 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9186 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9187 > #define pow innocuous_pow
9188 >
9189 > /* System header to define __stub macros and hopefully few prototypes,
9190 >    which can conflict with char pow (); below.
9191 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9192 >    <limits.h> exists even on freestanding compilers.  */
9193 >
9194 > #ifdef __STDC__
9195 > # include <limits.h>
9196 > #else
9197 > # include <assert.h>
9198 > #endif
9199 >
9200 > #undef pow
9201 >
9202 > /* Override any gcc2 internal prototype to avoid an error.  */
9203 > #ifdef __cplusplus
9204 > extern "C"
9205 > {
9206 > #endif
9207 > /* We use char because int might match the return type of a gcc2
9208 >   builtin and then its argument prototype would still apply.  */
9209 > char pow ();
9210 > /* The GNU C library defines this for functions which it implements
9211 >    to always fail with ENOSYS.  Some functions are actually named
9212 >    something starting with __ and the normal name is an alias.  */
9213 > #if defined (__stub_pow) || defined (__stub___pow)
9214 > choke me
9215 > #else
9216 > char (*f) () = pow;
9217 > #endif
9218 > #ifdef __cplusplus
9219 > }
9220 > #endif
9221 >
9222 > #ifdef FC_DUMMY_MAIN
9223 > #ifndef FC_DUMMY_MAIN_EQ_F77
9224 > #  ifdef __cplusplus
9225 >     extern "C"
9226 > #  endif
9227 >   int FC_DUMMY_MAIN() { return 1; }
9228 > #endif
9229 > #endif
9230 > int
9231 > main ()
9232 > {
9233 > return f != pow;
9234 >  ;
9235 >  return 0;
9236 > }
9237 > _ACEOF
9238 > rm -f conftest.$ac_objext conftest$ac_exeext
9239 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9240 >  (eval $ac_link) 2>conftest.er1
9241 >  ac_status=$?
9242 >  grep -v '^ *+' conftest.er1 >conftest.err
9243 >  rm -f conftest.er1
9244 >  cat conftest.err >&5
9245 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9246 >  (exit $ac_status); } &&
9247 >         { ac_try='test -z "$ac_c_werror_flag"
9248 >                         || test ! -s conftest.err'
9249 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9250 >  (eval $ac_try) 2>&5
9251 >  ac_status=$?
9252 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9253 >  (exit $ac_status); }; } &&
9254 >         { ac_try='test -s conftest$ac_exeext'
9255 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9256 >  (eval $ac_try) 2>&5
9257 >  ac_status=$?
9258 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9259 >  (exit $ac_status); }; }; then
9260 >  ac_cv_func_pow=yes
9261 > else
9262 >  echo "$as_me: failed program was:" >&5
9263 > sed 's/^/| /' conftest.$ac_ext >&5
9264 >
9265 > ac_cv_func_pow=no
9266 > fi
9267 > rm -f conftest.err conftest.$ac_objext \
9268 >      conftest$ac_exeext conftest.$ac_ext
9269 > fi
9270 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9271 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9272 >
9273 > if test $ac_cv_func_pow = no; then
9274 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9275 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9276 > if test "${ac_cv_lib_m_pow+set}" = set; then
9277 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9278 > else
9279 >  ac_check_lib_save_LIBS=$LIBS
9280 > LIBS="-lm  $LIBS"
9281 > cat >conftest.$ac_ext <<_ACEOF
9282 > /* confdefs.h.  */
9283 > _ACEOF
9284 > cat confdefs.h >>conftest.$ac_ext
9285 > cat >>conftest.$ac_ext <<_ACEOF
9286 > /* end confdefs.h.  */
9287 >
9288 > /* Override any gcc2 internal prototype to avoid an error.  */
9289 > #ifdef __cplusplus
9290 > extern "C"
9291 > #endif
9292 > /* We use char because int might match the return type of a gcc2
9293 >   builtin and then its argument prototype would still apply.  */
9294 > char pow ();
9295 > #ifdef FC_DUMMY_MAIN
9296 > #ifndef FC_DUMMY_MAIN_EQ_F77
9297 > #  ifdef __cplusplus
9298 >     extern "C"
9299 > #  endif
9300 >   int FC_DUMMY_MAIN() { return 1; }
9301 > #endif
9302 > #endif
9303 > int
9304 > main ()
9305 > {
9306 > pow ();
9307 >  ;
9308 >  return 0;
9309 > }
9310 > _ACEOF
9311 > rm -f conftest.$ac_objext conftest$ac_exeext
9312 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9313 >  (eval $ac_link) 2>conftest.er1
9314 >  ac_status=$?
9315 >  grep -v '^ *+' conftest.er1 >conftest.err
9316 >  rm -f conftest.er1
9317 >  cat conftest.err >&5
9318 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9319 >  (exit $ac_status); } &&
9320 >         { ac_try='test -z "$ac_c_werror_flag"
9321 >                         || test ! -s conftest.err'
9322 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9323 >  (eval $ac_try) 2>&5
9324 >  ac_status=$?
9325 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9326 >  (exit $ac_status); }; } &&
9327 >         { ac_try='test -s conftest$ac_exeext'
9328 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9329 >  (eval $ac_try) 2>&5
9330 >  ac_status=$?
9331 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9332 >  (exit $ac_status); }; }; then
9333 >  ac_cv_lib_m_pow=yes
9334 > else
9335 >  echo "$as_me: failed program was:" >&5
9336 > sed 's/^/| /' conftest.$ac_ext >&5
9337 >
9338 > ac_cv_lib_m_pow=no
9339 > fi
9340 > rm -f conftest.err conftest.$ac_objext \
9341 >      conftest$ac_exeext conftest.$ac_ext
9342 > LIBS=$ac_check_lib_save_LIBS
9343 > fi
9344 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9345 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9346 > if test $ac_cv_lib_m_pow = yes; then
9347 >  POW_LIB=-lm
9348 > else
9349 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9350 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9351 > fi
9352 >
9353 > fi
9354 >
9355 > fi
9356 >
9357 >
9358 >
9359 >
9360 >
9361 >
9362 >
9363 >
9364 >
9365 >
9366 >
9367 >
9368 >
9369 >
9370 >
9371 >
9372 >
9373 >
9374 >
9375 >
9376 >
9377 >
9378 >
9379 >
9380 >
9381 >
9382 >
9383 >
9384 > for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9385 > do
9386 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9387 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9388 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9389 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9391 > else
9392 >  cat >conftest.$ac_ext <<_ACEOF
9393 > /* confdefs.h.  */
9394 > _ACEOF
9395 > cat confdefs.h >>conftest.$ac_ext
9396 > cat >>conftest.$ac_ext <<_ACEOF
9397 > /* end confdefs.h.  */
9398 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9399 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9400 > #define $ac_func innocuous_$ac_func
9401 >
9402 > /* System header to define __stub macros and hopefully few prototypes,
9403 >    which can conflict with char $ac_func (); below.
9404 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9405 >    <limits.h> exists even on freestanding compilers.  */
9406 >
9407 > #ifdef __STDC__
9408 > # include <limits.h>
9409 > #else
9410 > # include <assert.h>
9411 > #endif
9412 >
9413 > #undef $ac_func
9414 >
9415 > /* Override any gcc2 internal prototype to avoid an error.  */
9416 > #ifdef __cplusplus
9417 > extern "C"
9418 > {
9419 > #endif
9420 > /* We use char because int might match the return type of a gcc2
9421 >   builtin and then its argument prototype would still apply.  */
9422 > char $ac_func ();
9423 > /* The GNU C library defines this for functions which it implements
9424 >    to always fail with ENOSYS.  Some functions are actually named
9425 >    something starting with __ and the normal name is an alias.  */
9426 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9427 > choke me
9428 > #else
9429 > char (*f) () = $ac_func;
9430 > #endif
9431 > #ifdef __cplusplus
9432 > }
9433 > #endif
9434 >
9435 > #ifdef FC_DUMMY_MAIN
9436 > #ifndef FC_DUMMY_MAIN_EQ_F77
9437 > #  ifdef __cplusplus
9438 >     extern "C"
9439 > #  endif
9440 >   int FC_DUMMY_MAIN() { return 1; }
9441 > #endif
9442 > #endif
9443 > int
9444 > main ()
9445 > {
9446 > return f != $ac_func;
9447 >  ;
9448 >  return 0;
9449 > }
9450 > _ACEOF
9451 > rm -f conftest.$ac_objext conftest$ac_exeext
9452 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9453 >  (eval $ac_link) 2>conftest.er1
9454 >  ac_status=$?
9455 >  grep -v '^ *+' conftest.er1 >conftest.err
9456 >  rm -f conftest.er1
9457 >  cat conftest.err >&5
9458 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9459 >  (exit $ac_status); } &&
9460 >         { ac_try='test -z "$ac_c_werror_flag"
9461 >                         || test ! -s conftest.err'
9462 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9463 >  (eval $ac_try) 2>&5
9464 >  ac_status=$?
9465 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9466 >  (exit $ac_status); }; } &&
9467 >         { ac_try='test -s conftest$ac_exeext'
9468 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9469 >  (eval $ac_try) 2>&5
9470 >  ac_status=$?
9471 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9472 >  (exit $ac_status); }; }; then
9473 >  eval "$as_ac_var=yes"
9474 > else
9475 >  echo "$as_me: failed program was:" >&5
9476 > sed 's/^/| /' conftest.$ac_ext >&5
9477 >
9478 > eval "$as_ac_var=no"
9479 > fi
9480 > rm -f conftest.err conftest.$ac_objext \
9481 >      conftest$ac_exeext conftest.$ac_ext
9482 > fi
9483 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9484 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9485 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9486 >  cat >>confdefs.h <<_ACEOF
9487 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9488 > _ACEOF
9489 >
9490 > fi
9491 > done
9492 >
9493 >
9494 > # special check for _system_configuration because AIX <4.3.2 do not
9495 > # contain the `physmem' member.
9496 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9497 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9498 > cat >conftest.$ac_ext <<_ACEOF
9499 > /* confdefs.h.  */
9500 > _ACEOF
9501 > cat confdefs.h >>conftest.$ac_ext
9502 > cat >>conftest.$ac_ext <<_ACEOF
9503 > /* end confdefs.h.  */
9504 > #include <sys/systemcfg.h>
9505 > #ifdef FC_DUMMY_MAIN
9506 > #ifndef FC_DUMMY_MAIN_EQ_F77
9507 > #  ifdef __cplusplus
9508 >     extern "C"
9509 > #  endif
9510 >   int FC_DUMMY_MAIN() { return 1; }
9511 > #endif
9512 > #endif
9513 > int
9514 > main ()
9515 > {
9516 > double x = _system_configuration.physmem;
9517 >  ;
9518 >  return 0;
9519 > }
9520 > _ACEOF
9521 > rm -f conftest.$ac_objext
9522 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9523 >  (eval $ac_compile) 2>conftest.er1
9524 >  ac_status=$?
9525 >  grep -v '^ *+' conftest.er1 >conftest.err
9526 >  rm -f conftest.er1
9527 >  cat conftest.err >&5
9528 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9529 >  (exit $ac_status); } &&
9530 >         { ac_try='test -z "$ac_c_werror_flag"
9531 >                         || test ! -s conftest.err'
9532 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9533 >  (eval $ac_try) 2>&5
9534 >  ac_status=$?
9535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9536 >  (exit $ac_status); }; } &&
9537 >         { ac_try='test -s conftest.$ac_objext'
9538 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9539 >  (eval $ac_try) 2>&5
9540 >  ac_status=$?
9541 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9542 >  (exit $ac_status); }; }; then
9543 >  echo "$as_me:$LINENO: result: yes" >&5
9544 > echo "${ECHO_T}yes" >&6
9545 >
9546 > cat >>confdefs.h <<\_ACEOF
9547 > #define HAVE__SYSTEM_CONFIGURATION 1
9548 > _ACEOF
9549 >
9550 > else
9551 >  echo "$as_me: failed program was:" >&5
9552 > sed 's/^/| /' conftest.$ac_ext >&5
9553 >
9554 > echo "$as_me:$LINENO: result: no" >&5
9555 > echo "${ECHO_T}no" >&6
9556 > fi
9557 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9558 >
9559 >  # clean out junk possibly left behind by a previous configuration
9560 >  rm -f src/getopt.h
9561 >  # Check for getopt_long support
9562 >
9563 > for ac_header in getopt.h
9564 > do
9565 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9566 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9567 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9568 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9569 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9570 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9571 > fi
9572 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9573 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9574 > else
9575 >  # Is the header compilable?
9576 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9577 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9578 > cat >conftest.$ac_ext <<_ACEOF
9579 > /* confdefs.h.  */
9580 > _ACEOF
9581 > cat confdefs.h >>conftest.$ac_ext
9582 > cat >>conftest.$ac_ext <<_ACEOF
9583 > /* end confdefs.h.  */
9584 > $ac_includes_default
9585 > #include <$ac_header>
9586 > _ACEOF
9587 > rm -f conftest.$ac_objext
9588 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9589 >  (eval $ac_compile) 2>conftest.er1
9590 >  ac_status=$?
9591 >  grep -v '^ *+' conftest.er1 >conftest.err
9592 >  rm -f conftest.er1
9593 >  cat conftest.err >&5
9594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9595 >  (exit $ac_status); } &&
9596 >         { ac_try='test -z "$ac_c_werror_flag"
9597 >                         || test ! -s conftest.err'
9598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9599 >  (eval $ac_try) 2>&5
9600 >  ac_status=$?
9601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9602 >  (exit $ac_status); }; } &&
9603 >         { ac_try='test -s conftest.$ac_objext'
9604 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9605 >  (eval $ac_try) 2>&5
9606 >  ac_status=$?
9607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9608 >  (exit $ac_status); }; }; then
9609 >  ac_header_compiler=yes
9610 > else
9611 >  echo "$as_me: failed program was:" >&5
9612 > sed 's/^/| /' conftest.$ac_ext >&5
9613 >
9614 > ac_header_compiler=no
9615 > fi
9616 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9617 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9618 > echo "${ECHO_T}$ac_header_compiler" >&6
9619 >
9620 > # Is the header present?
9621 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9622 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9623 > cat >conftest.$ac_ext <<_ACEOF
9624 > /* confdefs.h.  */
9625 > _ACEOF
9626 > cat confdefs.h >>conftest.$ac_ext
9627 > cat >>conftest.$ac_ext <<_ACEOF
9628 > /* end confdefs.h.  */
9629 > #include <$ac_header>
9630 > _ACEOF
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9632 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9633 >  ac_status=$?
9634 >  grep -v '^ *+' conftest.er1 >conftest.err
9635 >  rm -f conftest.er1
9636 >  cat conftest.err >&5
9637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638 >  (exit $ac_status); } >/dev/null; then
9639 >  if test -s conftest.err; then
9640 >    ac_cpp_err=$ac_c_preproc_warn_flag
9641 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9642 >  else
9643 >    ac_cpp_err=
9644 >  fi
9645 > else
9646 >  ac_cpp_err=yes
9647 > fi
9648 > if test -z "$ac_cpp_err"; then
9649 >  ac_header_preproc=yes
9650 > else
9651 >  echo "$as_me: failed program was:" >&5
9652 > sed 's/^/| /' conftest.$ac_ext >&5
9653 >
9654 >  ac_header_preproc=no
9655 > fi
9656 > rm -f conftest.err conftest.$ac_ext
9657 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9658 > echo "${ECHO_T}$ac_header_preproc" >&6
9659 >
9660 > # So?  What about this header?
9661 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9662 >  yes:no: )
9663 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9664 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9665 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9666 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9667 >    ac_header_preproc=yes
9668 >    ;;
9669 >  no:yes:* )
9670 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9671 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9672 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9673 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9674 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9675 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9676 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9677 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9678 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9679 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9680 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9681 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9682 >    (
9683 >      cat <<\_ASBOX
9684 > ## ------------------------------ ##
9685 > ## Report this to gezelter@nd.edu ##
9686 > ## ------------------------------ ##
9687 > _ASBOX
9688 >    ) |
9689 >      sed "s/^/$as_me: WARNING:     /" >&2
9690 >    ;;
9691 > esac
9692 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9693 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9694 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9695 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9696 > else
9697 >  eval "$as_ac_Header=\$ac_header_preproc"
9698 > fi
9699 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9700 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9701 >
9702 > fi
9703 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9704 >  cat >>confdefs.h <<_ACEOF
9705 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9706 > _ACEOF
9707 >
9708 > fi
9709 >
9710 > done
9711 >
9712 >
9713 > for ac_func in getopt_long
9714 > do
9715 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9716 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9717 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9718 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9719 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9720 > else
9721 >  cat >conftest.$ac_ext <<_ACEOF
9722 > /* confdefs.h.  */
9723 > _ACEOF
9724 > cat confdefs.h >>conftest.$ac_ext
9725 > cat >>conftest.$ac_ext <<_ACEOF
9726 > /* end confdefs.h.  */
9727 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9728 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9729 > #define $ac_func innocuous_$ac_func
9730 >
9731 > /* System header to define __stub macros and hopefully few prototypes,
9732 >    which can conflict with char $ac_func (); below.
9733 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9734 >    <limits.h> exists even on freestanding compilers.  */
9735 >
9736 > #ifdef __STDC__
9737 > # include <limits.h>
9738 > #else
9739 > # include <assert.h>
9740 > #endif
9741 >
9742 > #undef $ac_func
9743 >
9744 > /* Override any gcc2 internal prototype to avoid an error.  */
9745 > #ifdef __cplusplus
9746 > extern "C"
9747 > {
9748 > #endif
9749 > /* We use char because int might match the return type of a gcc2
9750 >   builtin and then its argument prototype would still apply.  */
9751 > char $ac_func ();
9752 > /* The GNU C library defines this for functions which it implements
9753 >    to always fail with ENOSYS.  Some functions are actually named
9754 >    something starting with __ and the normal name is an alias.  */
9755 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9756 > choke me
9757 > #else
9758 > char (*f) () = $ac_func;
9759 > #endif
9760 > #ifdef __cplusplus
9761 > }
9762 > #endif
9763 >
9764 > #ifdef FC_DUMMY_MAIN
9765 > #ifndef FC_DUMMY_MAIN_EQ_F77
9766 > #  ifdef __cplusplus
9767 >     extern "C"
9768 > #  endif
9769 >   int FC_DUMMY_MAIN() { return 1; }
9770 > #endif
9771 > #endif
9772 > int
9773 > main ()
9774 > {
9775 > return f != $ac_func;
9776 >  ;
9777 >  return 0;
9778 > }
9779 > _ACEOF
9780 > rm -f conftest.$ac_objext conftest$ac_exeext
9781 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9782 >  (eval $ac_link) 2>conftest.er1
9783 >  ac_status=$?
9784 >  grep -v '^ *+' conftest.er1 >conftest.err
9785 >  rm -f conftest.er1
9786 >  cat conftest.err >&5
9787 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9788 >  (exit $ac_status); } &&
9789 >         { ac_try='test -z "$ac_c_werror_flag"
9790 >                         || test ! -s conftest.err'
9791 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9792 >  (eval $ac_try) 2>&5
9793 >  ac_status=$?
9794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9795 >  (exit $ac_status); }; } &&
9796 >         { ac_try='test -s conftest$ac_exeext'
9797 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9798 >  (eval $ac_try) 2>&5
9799 >  ac_status=$?
9800 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9801 >  (exit $ac_status); }; }; then
9802 >  eval "$as_ac_var=yes"
9803 > else
9804 >  echo "$as_me: failed program was:" >&5
9805 > sed 's/^/| /' conftest.$ac_ext >&5
9806 >
9807 > eval "$as_ac_var=no"
9808 > fi
9809 > rm -f conftest.err conftest.$ac_objext \
9810 >      conftest$ac_exeext conftest.$ac_ext
9811 > fi
9812 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9813 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9814 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9815 >  cat >>confdefs.h <<_ACEOF
9816 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9817 > _ACEOF
9818 >
9819 > else
9820 >  # FreeBSD has a gnugetopt library for this
9821 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9822 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9823 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9824 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9825 > else
9826 >  ac_check_lib_save_LIBS=$LIBS
9827 > LIBS="-lgnugetopt  $LIBS"
9828 > cat >conftest.$ac_ext <<_ACEOF
9829 > /* confdefs.h.  */
9830 > _ACEOF
9831 > cat confdefs.h >>conftest.$ac_ext
9832 > cat >>conftest.$ac_ext <<_ACEOF
9833 > /* end confdefs.h.  */
9834 >
9835 > /* Override any gcc2 internal prototype to avoid an error.  */
9836 > #ifdef __cplusplus
9837 > extern "C"
9838 > #endif
9839 > /* We use char because int might match the return type of a gcc2
9840 >   builtin and then its argument prototype would still apply.  */
9841 > char getopt_long ();
9842 > #ifdef FC_DUMMY_MAIN
9843 > #ifndef FC_DUMMY_MAIN_EQ_F77
9844 > #  ifdef __cplusplus
9845 >     extern "C"
9846 > #  endif
9847 >   int FC_DUMMY_MAIN() { return 1; }
9848 > #endif
9849 > #endif
9850 > int
9851 > main ()
9852 > {
9853 > getopt_long ();
9854 >  ;
9855 >  return 0;
9856 > }
9857 > _ACEOF
9858 > rm -f conftest.$ac_objext conftest$ac_exeext
9859 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9860 >  (eval $ac_link) 2>conftest.er1
9861 >  ac_status=$?
9862 >  grep -v '^ *+' conftest.er1 >conftest.err
9863 >  rm -f conftest.er1
9864 >  cat conftest.err >&5
9865 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866 >  (exit $ac_status); } &&
9867 >         { ac_try='test -z "$ac_c_werror_flag"
9868 >                         || test ! -s conftest.err'
9869 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9870 >  (eval $ac_try) 2>&5
9871 >  ac_status=$?
9872 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9873 >  (exit $ac_status); }; } &&
9874 >         { ac_try='test -s conftest$ac_exeext'
9875 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9876 >  (eval $ac_try) 2>&5
9877 >  ac_status=$?
9878 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9879 >  (exit $ac_status); }; }; then
9880 >  ac_cv_lib_gnugetopt_getopt_long=yes
9881 > else
9882 >  echo "$as_me: failed program was:" >&5
9883 > sed 's/^/| /' conftest.$ac_ext >&5
9884 >
9885 > ac_cv_lib_gnugetopt_getopt_long=no
9886 > fi
9887 > rm -f conftest.err conftest.$ac_objext \
9888 >      conftest$ac_exeext conftest.$ac_ext
9889 > LIBS=$ac_check_lib_save_LIBS
9890 > fi
9891 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9892 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9893 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9894 >  cat >>confdefs.h <<\_ACEOF
9895 > #define HAVE_GETOPT_LONG 1
9896 > _ACEOF
9897 >
9898 > else
9899 >  # use the GNU replacement
9900 >      case $LIBOBJS in
9901 >    "getopt.$ac_objext"   | \
9902 >  *" getopt.$ac_objext"   | \
9903 >    "getopt.$ac_objext "* | \
9904 >  *" getopt.$ac_objext "* ) ;;
9905 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9906 > esac
9907 >
9908 >      case $LIBOBJS in
9909 >    "getopt1.$ac_objext"   | \
9910 >  *" getopt1.$ac_objext"   | \
9911 >    "getopt1.$ac_objext "* | \
9912 >  *" getopt1.$ac_objext "* ) ;;
9913 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9914 > esac
9915 >
9916 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9917 >
9918 > fi
9919 >
9920 > fi
9921 > done
9922 >
9923 >
9924 > ac_ext=cc
9925 > ac_cpp='$CXXCPP $CPPFLAGS'
9926 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9927 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9928 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9929 >
9930 >
9931 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9932 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9933 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9934 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9935 > else
9936 >
9937 >
9938 > ac_ext=cc
9939 > ac_cpp='$CXXCPP $CPPFLAGS'
9940 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9941 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9942 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9943 >
9944 > cat >conftest.$ac_ext <<_ACEOF
9945 > /* confdefs.h.  */
9946 > _ACEOF
9947 > cat confdefs.h >>conftest.$ac_ext
9948 > cat >>conftest.$ac_ext <<_ACEOF
9949 > /* end confdefs.h.  */
9950 > namespace Outer { namespace Inner { int i = 0; }}
9951 > #ifdef FC_DUMMY_MAIN
9952 > #ifndef FC_DUMMY_MAIN_EQ_F77
9953 > #  ifdef __cplusplus
9954 >     extern "C"
9955 > #  endif
9956 >   int FC_DUMMY_MAIN() { return 1; }
9957 > #endif
9958 > #endif
9959 > int
9960 > main ()
9961 > {
9962 > using namespace Outer::Inner; return i;
9963 >  ;
9964 >  return 0;
9965 > }
9966 > _ACEOF
9967 > rm -f conftest.$ac_objext
9968 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9969 >  (eval $ac_compile) 2>conftest.er1
9970 >  ac_status=$?
9971 >  grep -v '^ *+' conftest.er1 >conftest.err
9972 >  rm -f conftest.er1
9973 >  cat conftest.err >&5
9974 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9975 >  (exit $ac_status); } &&
9976 >         { ac_try='test -z "$ac_cxx_werror_flag"
9977 >                         || test ! -s conftest.err'
9978 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9979 >  (eval $ac_try) 2>&5
9980 >  ac_status=$?
9981 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9982 >  (exit $ac_status); }; } &&
9983 >         { ac_try='test -s conftest.$ac_objext'
9984 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9985 >  (eval $ac_try) 2>&5
9986 >  ac_status=$?
9987 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9988 >  (exit $ac_status); }; }; then
9989 >  ac_cv_cxx_namespaces=yes
9990 > else
9991 >  echo "$as_me: failed program was:" >&5
9992 > sed 's/^/| /' conftest.$ac_ext >&5
9993 >
9994 > ac_cv_cxx_namespaces=no
9995 > fi
9996 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9997 > ac_ext=cc
9998 > ac_cpp='$CXXCPP $CPPFLAGS'
9999 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10000 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10001 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10002 >
10003 >
10004 > fi
10005 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10006 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10007 > if test "$ac_cv_cxx_namespaces" = yes; then
10008 >
10009 > cat >>confdefs.h <<\_ACEOF
10010 > #define HAVE_NAMESPACES
10011 > _ACEOF
10012 >
10013 > fi
10014 >
10015 > ac_ext=cc
10016 > ac_cpp='$CXXCPP $CPPFLAGS'
10017 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10018 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10019 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10020 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10021 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10022 > if test -z "$CXXCPP"; then
10023 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10024 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10025 > else
10026 >      # Double quotes because CXXCPP needs to be expanded
10027 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10028 >    do
10029 >      ac_preproc_ok=false
10030 > for ac_cxx_preproc_warn_flag in '' yes
10031 > do
10032 >  # Use a header file that comes with gcc, so configuring glibc
10033 >  # with a fresh cross-compiler works.
10034 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10035 >  # <limits.h> exists even on freestanding compilers.
10036 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10037 >  # not just through cpp. "Syntax error" is here to catch this case.
10038 >  cat >conftest.$ac_ext <<_ACEOF
10039 > /* confdefs.h.  */
10040 > _ACEOF
10041 > cat confdefs.h >>conftest.$ac_ext
10042 > cat >>conftest.$ac_ext <<_ACEOF
10043 > /* end confdefs.h.  */
10044 > #ifdef __STDC__
10045 > # include <limits.h>
10046 > #else
10047 > # include <assert.h>
10048 > #endif
10049 >                     Syntax error
10050 > _ACEOF
10051 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10052 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10053 >  ac_status=$?
10054 >  grep -v '^ *+' conftest.er1 >conftest.err
10055 >  rm -f conftest.er1
10056 >  cat conftest.err >&5
10057 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10058 >  (exit $ac_status); } >/dev/null; then
10059 >  if test -s conftest.err; then
10060 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10061 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10062 >  else
10063 >    ac_cpp_err=
10064 >  fi
10065 > else
10066 >  ac_cpp_err=yes
10067 > fi
10068 > if test -z "$ac_cpp_err"; then
10069 >  :
10070 > else
10071 >  echo "$as_me: failed program was:" >&5
10072 > sed 's/^/| /' conftest.$ac_ext >&5
10073 >
10074 >  # Broken: fails on valid input.
10075 > continue
10076 > fi
10077 > rm -f conftest.err conftest.$ac_ext
10078 >
10079 >  # OK, works on sane cases.  Now check whether non-existent headers
10080 >  # can be detected and how.
10081 >  cat >conftest.$ac_ext <<_ACEOF
10082 > /* confdefs.h.  */
10083 > _ACEOF
10084 > cat confdefs.h >>conftest.$ac_ext
10085 > cat >>conftest.$ac_ext <<_ACEOF
10086 > /* end confdefs.h.  */
10087 > #include <ac_nonexistent.h>
10088 > _ACEOF
10089 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10090 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10091 >  ac_status=$?
10092 >  grep -v '^ *+' conftest.er1 >conftest.err
10093 >  rm -f conftest.er1
10094 >  cat conftest.err >&5
10095 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10096 >  (exit $ac_status); } >/dev/null; then
10097 >  if test -s conftest.err; then
10098 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10099 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10100 >  else
10101 >    ac_cpp_err=
10102 >  fi
10103 > else
10104 >  ac_cpp_err=yes
10105 > fi
10106 > if test -z "$ac_cpp_err"; then
10107 >  # Broken: success on invalid input.
10108 > continue
10109 > else
10110 >  echo "$as_me: failed program was:" >&5
10111 > sed 's/^/| /' conftest.$ac_ext >&5
10112 >
10113 >  # Passes both tests.
10114 > ac_preproc_ok=:
10115 > break
10116 > fi
10117 > rm -f conftest.err conftest.$ac_ext
10118 >
10119 > done
10120 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10121 > rm -f conftest.err conftest.$ac_ext
10122 > if $ac_preproc_ok; then
10123 >  break
10124 > fi
10125 >
10126 >    done
10127 >    ac_cv_prog_CXXCPP=$CXXCPP
10128 >
10129 > fi
10130 >  CXXCPP=$ac_cv_prog_CXXCPP
10131 > else
10132 >  ac_cv_prog_CXXCPP=$CXXCPP
10133 > fi
10134 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10135 > echo "${ECHO_T}$CXXCPP" >&6
10136 > ac_preproc_ok=false
10137 > for ac_cxx_preproc_warn_flag in '' yes
10138 > do
10139 >  # Use a header file that comes with gcc, so configuring glibc
10140 >  # with a fresh cross-compiler works.
10141 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10142 >  # <limits.h> exists even on freestanding compilers.
10143 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10144 >  # not just through cpp. "Syntax error" is here to catch this case.
10145 >  cat >conftest.$ac_ext <<_ACEOF
10146 > /* confdefs.h.  */
10147 > _ACEOF
10148 > cat confdefs.h >>conftest.$ac_ext
10149 > cat >>conftest.$ac_ext <<_ACEOF
10150 > /* end confdefs.h.  */
10151 > #ifdef __STDC__
10152 > # include <limits.h>
10153 > #else
10154 > # include <assert.h>
10155 > #endif
10156 >                     Syntax error
10157 > _ACEOF
10158 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10159 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10160 >  ac_status=$?
10161 >  grep -v '^ *+' conftest.er1 >conftest.err
10162 >  rm -f conftest.er1
10163 >  cat conftest.err >&5
10164 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10165 >  (exit $ac_status); } >/dev/null; then
10166 >  if test -s conftest.err; then
10167 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10168 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10169 >  else
10170 >    ac_cpp_err=
10171 >  fi
10172 > else
10173 >  ac_cpp_err=yes
10174 > fi
10175 > if test -z "$ac_cpp_err"; then
10176 >  :
10177 > else
10178 >  echo "$as_me: failed program was:" >&5
10179 > sed 's/^/| /' conftest.$ac_ext >&5
10180 >
10181 >  # Broken: fails on valid input.
10182 > continue
10183 > fi
10184 > rm -f conftest.err conftest.$ac_ext
10185 >
10186 >  # OK, works on sane cases.  Now check whether non-existent headers
10187 >  # can be detected and how.
10188 >  cat >conftest.$ac_ext <<_ACEOF
10189 > /* confdefs.h.  */
10190 > _ACEOF
10191 > cat confdefs.h >>conftest.$ac_ext
10192 > cat >>conftest.$ac_ext <<_ACEOF
10193 > /* end confdefs.h.  */
10194 > #include <ac_nonexistent.h>
10195 > _ACEOF
10196 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10197 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10198 >  ac_status=$?
10199 >  grep -v '^ *+' conftest.er1 >conftest.err
10200 >  rm -f conftest.er1
10201 >  cat conftest.err >&5
10202 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10203 >  (exit $ac_status); } >/dev/null; then
10204 >  if test -s conftest.err; then
10205 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10206 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10207 >  else
10208 >    ac_cpp_err=
10209 >  fi
10210 > else
10211 >  ac_cpp_err=yes
10212 > fi
10213 > if test -z "$ac_cpp_err"; then
10214 >  # Broken: success on invalid input.
10215 > continue
10216 > else
10217 >  echo "$as_me: failed program was:" >&5
10218 > sed 's/^/| /' conftest.$ac_ext >&5
10219 >
10220 >  # Passes both tests.
10221 > ac_preproc_ok=:
10222 > break
10223 > fi
10224 > rm -f conftest.err conftest.$ac_ext
10225 >
10226 > done
10227 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10228 > rm -f conftest.err conftest.$ac_ext
10229 > if $ac_preproc_ok; then
10230 >  :
10231 > else
10232 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10233 > See \`config.log' for more details." >&5
10234 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10235 > See \`config.log' for more details." >&2;}
10236 >   { (exit 1); exit 1; }; }
10237   fi
10238 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10239 <        ac_ext=cc
10238 >
10239 > ac_ext=cc
10240   ac_cpp='$CXXCPP $CPPFLAGS'
10241   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10242   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10243   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10244  
6360      fi
10245  
10246 < fi
10247 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
10248 < 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
10246 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10247 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10248 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10249    echo $ECHO_N "(cached) $ECHO_C" >&6
10250   else
10251  
6381    ac_cv_cxx_have_fstream_attach=no
10252  
10253  
10254 <    ac_ext=cc
10254 > ac_ext=cc
10255   ac_cpp='$CXXCPP $CPPFLAGS'
10256   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10257   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10258   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10259  
10260 <    cat >conftest.$ac_ext <<_ACEOF
10260 > cat >conftest.$ac_ext <<_ACEOF
10261   /* confdefs.h.  */
10262   _ACEOF
10263   cat confdefs.h >>conftest.$ac_ext
10264   cat >>conftest.$ac_ext <<_ACEOF
10265   /* end confdefs.h.  */
10266 <
10267 < #ifdef HAVE_IOSTREAM
10268 < #include <fstream>
6399 < #else
6400 < #include <fstream.h>
6401 < #endif
6402 < #ifdef HAVE_STD_IOSTREAM
10266 > #include <list>
10267 > #include <deque>
10268 > #ifdef HAVE_NAMESPACES
10269   using namespace std;
10270   #endif
10271 <
10271 > #ifdef FC_DUMMY_MAIN
10272 > #ifndef FC_DUMMY_MAIN_EQ_F77
10273 > #  ifdef __cplusplus
10274 >     extern "C"
10275 > #  endif
10276 >   int FC_DUMMY_MAIN() { return 1; }
10277 > #endif
10278 > #endif
10279   int
10280   main ()
10281   {
10282 < int fd=0;ofstream s;s.attach(fd);
10282 > list<int> x; x.push_back(5);
10283 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10284    ;
10285    return 0;
10286   }
# Line 6433 | Line 10307 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10307    ac_status=$?
10308    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10309    (exit $ac_status); }; }; then
10310 <  ac_cv_cxx_have_fstream_attach=yes
10310 >  ac_cv_cxx_have_stl=yes
10311   else
10312    echo "$as_me: failed program was:" >&5
10313   sed 's/^/| /' conftest.$ac_ext >&5
10314  
10315 + ac_cv_cxx_have_stl=no
10316   fi
10317   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10318 <    ac_ext=cc
10318 > ac_ext=cc
10319   ac_cpp='$CXXCPP $CPPFLAGS'
10320   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10321   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
# Line 6448 | Line 10323 | fi
10323  
10324  
10325   fi
10326 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
10327 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
10328 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
10326 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10327 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10328 > if test "$ac_cv_cxx_have_stl" = yes; then
10329  
10330   cat >>confdefs.h <<\_ACEOF
10331 < #define HAVE_FSTREAM_ATTACH 1
10331 > #define HAVE_STL
10332   _ACEOF
10333  
10334 <  fi
10334 > fi
10335  
10336  
10337  
10338 <  echo "$as_me:$LINENO: checking for fstream::open()" >&5
10339 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
10340 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
10338 >  if test "${ac_cv_header_iostream+set}" = set; then
10339 >  echo "$as_me:$LINENO: checking for iostream" >&5
10340 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10341 > if test "${ac_cv_header_iostream+set}" = set; then
10342    echo $ECHO_N "(cached) $ECHO_C" >&6
10343 + fi
10344 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10345 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10346   else
10347 <
10348 <    ac_cv_cxx_have_fstream_open=no
10349 <    ac_cv_cxx_fstream_open_prot=no
10350 <
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
10347 >  # Is the header compilable?
10348 > echo "$as_me:$LINENO: checking iostream usability" >&5
10349 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10350 > cat >conftest.$ac_ext <<_ACEOF
10351   /* confdefs.h.  */
10352   _ACEOF
10353   cat confdefs.h >>conftest.$ac_ext
10354   cat >>conftest.$ac_ext <<_ACEOF
10355   /* end confdefs.h.  */
10356 <
10357 < #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 < }
10356 > $ac_includes_default
10357 > #include <iostream>
10358   _ACEOF
10359   rm -f conftest.$ac_objext
10360   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6523 | Line 10378 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10378    ac_status=$?
10379    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380    (exit $ac_status); }; }; then
10381 <  ac_cv_cxx_have_fstream_open=yes
10381 >  ac_header_compiler=yes
10382   else
10383    echo "$as_me: failed program was:" >&5
10384   sed 's/^/| /' conftest.$ac_ext >&5
10385  
10386 + ac_header_compiler=no
10387   fi
10388   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10389 <    # Try with mode parameter
10390 <    cat >conftest.$ac_ext <<_ACEOF
10389 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10390 > echo "${ECHO_T}$ac_header_compiler" >&6
10391 >
10392 > # Is the header present?
10393 > echo "$as_me:$LINENO: checking iostream presence" >&5
10394 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10395 > cat >conftest.$ac_ext <<_ACEOF
10396   /* confdefs.h.  */
10397   _ACEOF
10398   cat confdefs.h >>conftest.$ac_ext
10399   cat >>conftest.$ac_ext <<_ACEOF
10400   /* end confdefs.h.  */
10401 <
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 < }
10401 > #include <iostream>
10402   _ACEOF
10403 < rm -f conftest.$ac_objext
10404 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6560 <  (eval $ac_compile) 2>conftest.er1
10403 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10404 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10405    ac_status=$?
10406    grep -v '^ *+' conftest.er1 >conftest.err
10407    rm -f conftest.er1
10408    cat conftest.err >&5
10409    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10410 <  (exit $ac_status); } &&
10411 <         { ac_try='test -z "$ac_cxx_werror_flag"
10412 <                         || test ! -s conftest.err'
10413 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10414 <  (eval $ac_try) 2>&5
10415 <  ac_status=$?
10416 <  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
10410 >  (exit $ac_status); } >/dev/null; then
10411 >  if test -s conftest.err; then
10412 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10413 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10414 >  else
10415 >    ac_cpp_err=
10416 >  fi
10417   else
10418 +  ac_cpp_err=yes
10419 + fi
10420 + if test -z "$ac_cpp_err"; then
10421 +  ac_header_preproc=yes
10422 + else
10423    echo "$as_me: failed program was:" >&5
10424   sed 's/^/| /' conftest.$ac_ext >&5
10425  
10426 +  ac_header_preproc=no
10427   fi
10428 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10429 <    ac_ext=cc
10430 < 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
10428 > rm -f conftest.err conftest.$ac_ext
10429 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10430 > echo "${ECHO_T}$ac_header_preproc" >&6
10431  
10432 + # So?  What about this header?
10433 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10434 +  yes:no: )
10435 +    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10436 + echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10437 +    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10438 + echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10439 +    ac_header_preproc=yes
10440 +    ;;
10441 +  no:yes:* )
10442 +    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10443 + echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10444 +    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10445 + echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10446 +    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10447 + echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10448 +    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10449 + echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10450 +    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10451 + echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10452 +    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10453 + echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10454 +    (
10455 +      cat <<\_ASBOX
10456 + ## ------------------------------ ##
10457 + ## Report this to gezelter@nd.edu ##
10458 + ## ------------------------------ ##
10459 + _ASBOX
10460 +    ) |
10461 +      sed "s/^/$as_me: WARNING:     /" >&2
10462 +    ;;
10463 + esac
10464 + echo "$as_me:$LINENO: checking for iostream" >&5
10465 + echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10466 + if test "${ac_cv_header_iostream+set}" = set; then
10467 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10468 + else
10469 +  ac_cv_header_iostream=$ac_header_preproc
10470 + fi
10471 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10472 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10473  
10474   fi
10475 < 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
10475 > if test $ac_cv_header_iostream = yes; then
10476  
6599 cat >>confdefs.h <<\_ACEOF
6600 #define HAVE_FSTREAM_OPEN 1
6601 _ACEOF
10477  
6603  fi
6604  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
6605
10478   cat >>confdefs.h <<\_ACEOF
10479 < #define FSTREAM_OPEN_PROT 1
10479 > #define HAVE_IOSTREAM 1
10480   _ACEOF
10481  
6610  fi
10482  
10483 + else
10484  
10485  
10486 <
10487 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
10488 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
10489 < if test "${ac_cv_lib_m_asin+set}" = set; then
10486 > for ac_header in iostream.h
10487 > do
10488 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10489 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10490 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10491 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10492 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10493    echo $ECHO_N "(cached) $ECHO_C" >&6
10494 + fi
10495 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10496 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10497   else
10498 <  ac_check_lib_save_LIBS=$LIBS
10499 < LIBS="-lm  $LIBS"
10498 >  # Is the header compilable?
10499 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10500 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10501   cat >conftest.$ac_ext <<_ACEOF
10502   /* confdefs.h.  */
10503   _ACEOF
10504   cat confdefs.h >>conftest.$ac_ext
10505   cat >>conftest.$ac_ext <<_ACEOF
10506   /* end confdefs.h.  */
10507 <
10508 < /* 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 < }
10507 > $ac_includes_default
10508 > #include <$ac_header>
10509   _ACEOF
10510 < rm -f conftest.$ac_objext conftest$ac_exeext
10511 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10512 <  (eval $ac_link) 2>conftest.er1
10510 > rm -f conftest.$ac_objext
10511 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10512 >  (eval $ac_compile) 2>conftest.er1
10513    ac_status=$?
10514    grep -v '^ *+' conftest.er1 >conftest.err
10515    rm -f conftest.er1
# Line 6657 | Line 10523 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10523    ac_status=$?
10524    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10525    (exit $ac_status); }; } &&
10526 <         { ac_try='test -s conftest$ac_exeext'
10526 >         { ac_try='test -s conftest.$ac_objext'
10527    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10528    (eval $ac_try) 2>&5
10529    ac_status=$?
10530    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10531    (exit $ac_status); }; }; then
10532 <  ac_cv_lib_m_asin=yes
10532 >  ac_header_compiler=yes
10533   else
10534    echo "$as_me: failed program was:" >&5
10535   sed 's/^/| /' conftest.$ac_ext >&5
10536  
10537 < ac_cv_lib_m_asin=no
10537 > ac_header_compiler=no
10538   fi
10539 < rm -f conftest.err conftest.$ac_objext \
10540 <      conftest$ac_exeext conftest.$ac_ext
10541 < 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
10539 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10540 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10541 > echo "${ECHO_T}$ac_header_compiler" >&6
10542  
10543 <  LIBS="-lm $LIBS"
10544 <
10545 < 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"
10543 > # Is the header present?
10544 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10545 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10546   cat >conftest.$ac_ext <<_ACEOF
10547   /* confdefs.h.  */
10548   _ACEOF
10549   cat confdefs.h >>conftest.$ac_ext
10550   cat >>conftest.$ac_ext <<_ACEOF
10551   /* end confdefs.h.  */
10552 <
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 < }
10552 > #include <$ac_header>
10553   _ACEOF
10554 < rm -f conftest.$ac_objext conftest$ac_exeext
10555 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6777 <  (eval $ac_link) 2>conftest.er1
10554 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10555 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10556    ac_status=$?
10557    grep -v '^ *+' conftest.er1 >conftest.err
10558    rm -f conftest.er1
10559    cat conftest.err >&5
10560    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10561 <  (exit $ac_status); } &&
10562 <         { ac_try='test -z "$ac_c_werror_flag"
10563 <                         || test ! -s conftest.err'
10564 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10565 <  (eval $ac_try) 2>&5
10566 <  ac_status=$?
10567 <  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
10561 >  (exit $ac_status); } >/dev/null; then
10562 >  if test -s conftest.err; then
10563 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10564 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10565 >  else
10566 >    ac_cpp_err=
10567 >  fi
10568   else
10569 +  ac_cpp_err=yes
10570 + fi
10571 + if test -z "$ac_cpp_err"; then
10572 +  ac_header_preproc=yes
10573 + else
10574    echo "$as_me: failed program was:" >&5
10575   sed 's/^/| /' conftest.$ac_ext >&5
10576  
10577 < ac_cv_lib_z_inflateEnd=no
10577 >  ac_header_preproc=no
10578   fi
10579 < rm -f conftest.err conftest.$ac_objext \
10580 <      conftest$ac_exeext conftest.$ac_ext
10581 < LIBS=$ac_check_lib_save_LIBS
10582 < fi
10583 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
10584 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
10585 < if test $ac_cv_lib_z_inflateEnd = yes; then
10586 <  zlib_cv_libz=yes
10579 > rm -f conftest.err conftest.$ac_ext
10580 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10581 > echo "${ECHO_T}$ac_header_preproc" >&6
10582 >
10583 > # So?  What about this header?
10584 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10585 >  yes:no: )
10586 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10587 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10588 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10589 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10590 >    ac_header_preproc=yes
10591 >    ;;
10592 >  no:yes:* )
10593 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10594 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10595 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10596 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10598 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10599 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10600 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10601 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10602 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10603 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10604 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10605 >    (
10606 >      cat <<\_ASBOX
10607 > ## ------------------------------ ##
10608 > ## Report this to gezelter@nd.edu ##
10609 > ## ------------------------------ ##
10610 > _ASBOX
10611 >    ) |
10612 >      sed "s/^/$as_me: WARNING:     /" >&2
10613 >    ;;
10614 > esac
10615 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10616 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10617 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10618 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10619   else
10620 <  zlib_cv_libz=no
10620 >  eval "$as_ac_Header=\$ac_header_preproc"
10621   fi
10622 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10623 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10624  
10625 <        if test "${ac_cv_header_zlib_h+set}" = set; then
10626 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
10627 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10628 < if test "${ac_cv_header_zlib_h+set}" = set; then
10625 > fi
10626 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10627 >  cat >>confdefs.h <<_ACEOF
10628 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10629 > _ACEOF
10630 >
10631 > fi
10632 >
10633 > done
10634 >
10635 >
10636 > fi
10637 >
10638 >
10639 >
10640 >
10641 >  if test "${ac_cv_header_iomanip+set}" = set; then
10642 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10643 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10644 > if test "${ac_cv_header_iomanip+set}" = set; then
10645    echo $ECHO_N "(cached) $ECHO_C" >&6
10646   fi
10647 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10648 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10647 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10648 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10649   else
10650    # Is the header compilable?
10651 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
10652 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
10651 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10652 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10653   cat >conftest.$ac_ext <<_ACEOF
10654   /* confdefs.h.  */
10655   _ACEOF
# Line 6832 | Line 10657 | $ac_includes_default
10657   cat >>conftest.$ac_ext <<_ACEOF
10658   /* end confdefs.h.  */
10659   $ac_includes_default
10660 < #include <zlib.h>
10660 > #include <iomanip>
10661   _ACEOF
10662   rm -f conftest.$ac_objext
10663   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6843 | Line 10668 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10668    cat conftest.err >&5
10669    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10670    (exit $ac_status); } &&
10671 <         { ac_try='test -z "$ac_c_werror_flag"
10671 >         { ac_try='test -z "$ac_cxx_werror_flag"
10672                           || test ! -s conftest.err'
10673    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10674    (eval $ac_try) 2>&5
# Line 6868 | Line 10693 | echo "${ECHO_T}$ac_header_compiler" >&6
10693   echo "${ECHO_T}$ac_header_compiler" >&6
10694  
10695   # Is the header present?
10696 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
10697 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
10696 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10697 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10698   cat >conftest.$ac_ext <<_ACEOF
10699   /* confdefs.h.  */
10700   _ACEOF
10701   cat confdefs.h >>conftest.$ac_ext
10702   cat >>conftest.$ac_ext <<_ACEOF
10703   /* end confdefs.h.  */
10704 < #include <zlib.h>
10704 > #include <iomanip>
10705   _ACEOF
10706   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10707    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6887 | Line 10712 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10712    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10713    (exit $ac_status); } >/dev/null; then
10714    if test -s conftest.err; then
10715 <    ac_cpp_err=$ac_c_preproc_warn_flag
10716 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10715 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10716 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10717    else
10718      ac_cpp_err=
10719    fi
# Line 6908 | Line 10733 | echo "${ECHO_T}$ac_header_preproc" >&6
10733   echo "${ECHO_T}$ac_header_preproc" >&6
10734  
10735   # So?  What about this header?
10736 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10736 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10737    yes:no: )
10738 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
10739 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
10740 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
10741 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
10738 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10739 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10740 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10741 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10742      ac_header_preproc=yes
10743      ;;
10744    no:yes:* )
10745 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
10746 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
10747 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
10748 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
10749 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
10750 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
10751 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
10752 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
10753 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
10754 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
10755 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
10756 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
10745 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10746 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10747 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10748 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10749 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10750 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10751 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10752 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10753 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10754 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10755 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10756 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10757      (
10758        cat <<\_ASBOX
10759   ## ------------------------------ ##
# Line 6939 | Line 10764 | esac
10764        sed "s/^/$as_me: WARNING:     /" >&2
10765      ;;
10766   esac
10767 < echo "$as_me:$LINENO: checking for zlib.h" >&5
10768 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10769 < if test "${ac_cv_header_zlib_h+set}" = set; then
10767 > echo "$as_me:$LINENO: checking for iomanip" >&5
10768 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10769 > if test "${ac_cv_header_iomanip+set}" = set; then
10770    echo $ECHO_N "(cached) $ECHO_C" >&6
10771   else
10772 <  ac_cv_header_zlib_h=$ac_header_preproc
10772 >  ac_cv_header_iomanip=$ac_header_preproc
10773   fi
10774 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10775 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10774 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10775 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10776  
10777   fi
10778 < if test $ac_cv_header_zlib_h = yes; then
6954 <  zlib_cv_zlib_h=yes
6955 < else
6956 <  zlib_cv_zlib_h=no
6957 < fi
10778 > if test $ac_cv_header_iomanip = yes; then
10779  
10780  
10781 <        ac_ext=c
10782 < 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
10781 > cat >>confdefs.h <<\_ACEOF
10782 > #define HAVE_IOMANIP 1
10783   _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
7075
7076
10784  
10785  
10786 + else
10787  
10788  
10789 <
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
10789 > for ac_header in iomanip.h
10790   do
10791   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10792   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7115 | Line 10819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10819    cat conftest.err >&5
10820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10821    (exit $ac_status); } &&
10822 <         { ac_try='test -z "$ac_c_werror_flag"
10822 >         { ac_try='test -z "$ac_cxx_werror_flag"
10823                           || test ! -s conftest.err'
10824    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10825    (eval $ac_try) 2>&5
# Line 7159 | Line 10863 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10863    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10864    (exit $ac_status); } >/dev/null; then
10865    if test -s conftest.err; then
10866 <    ac_cpp_err=$ac_c_preproc_warn_flag
10867 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10866 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10867 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10868    else
10869      ac_cpp_err=
10870    fi
# Line 7180 | Line 10884 | echo "${ECHO_T}$ac_header_preproc" >&6
10884   echo "${ECHO_T}$ac_header_preproc" >&6
10885  
10886   # So?  What about this header?
10887 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10887 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10888    yes:no: )
10889      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10890   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7231 | Line 10935 | done
10935  
10936   done
10937  
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
10938  
10939 + fi
10940  
10941  
10942  
10943  
10944 <
7245 < for ac_header in ctype.h iostream fstream sstream strstream
10944 > for ac_header in cmath
10945   do
10946   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10947   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7391 | Line 11090 | done
11090  
11091   done
11092  
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
11093  
11094  
11095  
11096 <
11097 <
11096 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11097 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11098 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11099 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11100 > else
11101  
11102 +      ac_cv_cxx_have_std_iostream=no
11103 +      ac_cv_cxx_need_use_std_iostream=no
11104 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11105  
11106  
11107 +        ac_ext=cc
11108 + ac_cpp='$CXXCPP $CPPFLAGS'
11109 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11110 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11111 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11112  
11113 <
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
11113 >        cat >conftest.$ac_ext <<_ACEOF
11114   /* confdefs.h.  */
11115   _ACEOF
11116   cat confdefs.h >>conftest.$ac_ext
11117   cat >>conftest.$ac_ext <<_ACEOF
11118   /* end confdefs.h.  */
11119 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11120 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11121 < #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>
11119 >
11120 > #ifdef HAVE_IOSTREAM
11121 > #include <iostream>
11122   #else
11123 < # include <assert.h>
11123 > #include <iostream.h>
11124   #endif
11125  
11126 < #undef $ac_func
11127 <
11128 < /* Override any gcc2 internal prototype to avoid an error.  */
11129 < #ifdef __cplusplus
11130 < extern "C"
11131 < {
11126 > #ifdef FC_DUMMY_MAIN
11127 > #ifndef FC_DUMMY_MAIN_EQ_F77
11128 > #  ifdef __cplusplus
11129 >     extern "C"
11130 > #  endif
11131 >   int FC_DUMMY_MAIN() { return 1; }
11132   #endif
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;
11133   #endif
7459 #ifdef __cplusplus
7460 }
7461 #endif
7462
11134   int
11135   main ()
11136   {
11137 < return f != $ac_func;
11137 > std::cout<<"Hello World"<<std::endl;return 0;
11138    ;
11139    return 0;
11140   }
11141   _ACEOF
11142 < rm -f conftest.$ac_objext conftest$ac_exeext
11143 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11144 <  (eval $ac_link) 2>conftest.er1
11142 > rm -f conftest.$ac_objext
11143 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11144 >  (eval $ac_compile) 2>conftest.er1
11145    ac_status=$?
11146    grep -v '^ *+' conftest.er1 >conftest.err
11147    rm -f conftest.er1
11148    cat conftest.err >&5
11149    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11150    (exit $ac_status); } &&
11151 <         { ac_try='test -z "$ac_c_werror_flag"
11151 >         { ac_try='test -z "$ac_cxx_werror_flag"
11152                           || test ! -s conftest.err'
11153    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11154    (eval $ac_try) 2>&5
11155    ac_status=$?
11156    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11157    (exit $ac_status); }; } &&
11158 <         { ac_try='test -s conftest$ac_exeext'
11158 >         { ac_try='test -s conftest.$ac_objext'
11159    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11160    (eval $ac_try) 2>&5
11161    ac_status=$?
11162    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11163    (exit $ac_status); }; }; then
11164 <  eval "$as_ac_var=yes"
11164 >  ac_cv_cxx_have_std_iostream=yes
11165   else
11166    echo "$as_me: failed program was:" >&5
11167   sed 's/^/| /' conftest.$ac_ext >&5
11168  
7498 eval "$as_ac_var=no"
11169   fi
11170 < rm -f conftest.err conftest.$ac_objext \
11171 <      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
11170 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11171 >        cat >conftest.$ac_ext <<_ACEOF
11172   /* confdefs.h.  */
11173   _ACEOF
11174   cat confdefs.h >>conftest.$ac_ext
11175   cat >>conftest.$ac_ext <<_ACEOF
11176   /* end confdefs.h.  */
11177 < #include <sys/systemcfg.h>
11177 >
11178 > #define __USE_STD_IOSTREAM 1
11179 > #ifdef HAVE_IOSTREAM
11180 > #include <iostream>
11181 > #else
11182 > #include <iostream.h>
11183 > #endif
11184 >
11185 > #ifdef FC_DUMMY_MAIN
11186 > #ifndef FC_DUMMY_MAIN_EQ_F77
11187 > #  ifdef __cplusplus
11188 >     extern "C"
11189 > #  endif
11190 >   int FC_DUMMY_MAIN() { return 1; }
11191 > #endif
11192 > #endif
11193   int
11194   main ()
11195   {
11196 < double x = _system_configuration.physmem;
11196 > std::cout<<"Hello World"<<std::endl;return 0;
11197    ;
11198    return 0;
11199   }
# Line 7538 | Line 11207 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11207    cat conftest.err >&5
11208    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11209    (exit $ac_status); } &&
11210 <         { ac_try='test -z "$ac_c_werror_flag"
11210 >         { ac_try='test -z "$ac_cxx_werror_flag"
11211                           || test ! -s conftest.err'
11212    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11213    (eval $ac_try) 2>&5
# Line 7551 | Line 11220 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11220    ac_status=$?
11221    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11222    (exit $ac_status); }; }; then
11223 <  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 <
11223 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11224   else
11225    echo "$as_me: failed program was:" >&5
11226   sed 's/^/| /' conftest.$ac_ext >&5
11227  
7565 echo "$as_me:$LINENO: result: no" >&5
7566 echo "${ECHO_T}no" >&6
11228   fi
11229   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11230 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11231 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
11232 < if test "${ac_cv_header_time+set}" = set; then
11230 >        ac_ext=cc
11231 > ac_cpp='$CXXCPP $CPPFLAGS'
11232 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11233 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11234 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11235 >
11236 >      fi
11237 >
11238 > fi
11239 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11240 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11241 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11242 >
11243 > cat >>confdefs.h <<\_ACEOF
11244 > #define HAVE_STD_IOSTREAM 1
11245 > _ACEOF
11246 >
11247 >  fi
11248 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11249 >
11250 > cat >>confdefs.h <<\_ACEOF
11251 > #define __USE_STD_IOSTREAM 1
11252 > _ACEOF
11253 >
11254 >  fi
11255 >
11256 >
11257 >
11258 >
11259 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11260 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11261 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11262    echo $ECHO_N "(cached) $ECHO_C" >&6
11263   else
11264 <  cat >conftest.$ac_ext <<_ACEOF
11264 >
11265 >      ac_cv_cxx_have_std_stl=no
11266 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11267 >
11268 >
11269 >        ac_ext=cc
11270 > ac_cpp='$CXXCPP $CPPFLAGS'
11271 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11272 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11273 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11274 >
11275 >        cat >conftest.$ac_ext <<_ACEOF
11276   /* confdefs.h.  */
11277   _ACEOF
11278   cat confdefs.h >>conftest.$ac_ext
11279   cat >>conftest.$ac_ext <<_ACEOF
11280   /* end confdefs.h.  */
11281 < #include <sys/types.h>
7581 < #include <sys/time.h>
7582 < #include <time.h>
11281 > #include <list>
11282  
11283 + #ifdef FC_DUMMY_MAIN
11284 + #ifndef FC_DUMMY_MAIN_EQ_F77
11285 + #  ifdef __cplusplus
11286 +     extern "C"
11287 + #  endif
11288 +   int FC_DUMMY_MAIN() { return 1; }
11289 + #endif
11290 + #endif
11291   int
11292   main ()
11293   {
11294 < if ((struct tm *) 0)
7588 < return 0;
11294 > std::list<int> foo;return 0;
11295    ;
11296    return 0;
11297   }
# Line 7599 | Line 11305 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11305    cat conftest.err >&5
11306    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11307    (exit $ac_status); } &&
11308 <         { ac_try='test -z "$ac_c_werror_flag"
11308 >         { ac_try='test -z "$ac_cxx_werror_flag"
11309                           || test ! -s conftest.err'
11310    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11311    (eval $ac_try) 2>&5
# Line 7612 | Line 11318 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11318    ac_status=$?
11319    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11320    (exit $ac_status); }; }; then
11321 <  ac_cv_header_time=yes
11321 >  ac_cv_cxx_have_std_stl=yes
11322   else
11323    echo "$as_me: failed program was:" >&5
11324   sed 's/^/| /' conftest.$ac_ext >&5
11325  
7620 ac_cv_header_time=no
11326   fi
11327   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11328 +        ac_ext=cc
11329 + ac_cpp='$CXXCPP $CPPFLAGS'
11330 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11331 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11332 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11333 +
11334 +      fi
11335 +
11336   fi
11337 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11338 < echo "${ECHO_T}$ac_cv_header_time" >&6
11339 < if test $ac_cv_header_time = yes; then
11337 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11338 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11339 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11340  
11341   cat >>confdefs.h <<\_ACEOF
11342 < #define TIME_WITH_SYS_TIME 1
11342 > #define HAVE_STD_STL 1
11343   _ACEOF
11344  
11345 < fi
11345 >  fi
11346  
11347  
11348 < echo "$as_me:$LINENO: checking for clock_t" >&5
11349 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11350 < if test "${ac_cv_type_clock_t+set}" = set; then
11348 >
11349 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11350 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11351 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11352    echo $ECHO_N "(cached) $ECHO_C" >&6
11353   else
11354 <  cat >conftest.$ac_ext <<_ACEOF
11354 >
11355 >    ac_cv_cxx_have_fstream_attach=no
11356 >
11357 >
11358 >    ac_ext=cc
11359 > ac_cpp='$CXXCPP $CPPFLAGS'
11360 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11361 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11362 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11363 >
11364 >    cat >conftest.$ac_ext <<_ACEOF
11365   /* confdefs.h.  */
11366 < _ACEOF
11367 < cat confdefs.h >>conftest.$ac_ext
11368 < cat >>conftest.$ac_ext <<_ACEOF
11369 < /* end confdefs.h.  */
11370 < $ac_includes_default
11366 > _ACEOF
11367 > cat confdefs.h >>conftest.$ac_ext
11368 > cat >>conftest.$ac_ext <<_ACEOF
11369 > /* end confdefs.h.  */
11370 >
11371 > #ifdef HAVE_IOSTREAM
11372 > #include <fstream>
11373 > #else
11374 > #include <fstream.h>
11375 > #endif
11376 > #ifdef HAVE_STD_IOSTREAM
11377 > using namespace std;
11378 > #endif
11379 >
11380 > #ifdef FC_DUMMY_MAIN
11381 > #ifndef FC_DUMMY_MAIN_EQ_F77
11382 > #  ifdef __cplusplus
11383 >     extern "C"
11384 > #  endif
11385 >   int FC_DUMMY_MAIN() { return 1; }
11386 > #endif
11387 > #endif
11388   int
11389   main ()
11390   {
11391 < if ((clock_t *) 0)
7651 <  return 0;
7652 < if (sizeof (clock_t))
7653 <  return 0;
11391 > int fd=0;ofstream s;s.attach(fd);
11392    ;
11393    return 0;
11394   }
# Line 7664 | Line 11402 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11402    cat conftest.err >&5
11403    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11404    (exit $ac_status); } &&
11405 <         { ac_try='test -z "$ac_c_werror_flag"
11405 >         { ac_try='test -z "$ac_cxx_werror_flag"
11406                           || test ! -s conftest.err'
11407    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11408    (eval $ac_try) 2>&5
# Line 7677 | Line 11415 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11415    ac_status=$?
11416    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11417    (exit $ac_status); }; }; then
11418 <  ac_cv_type_clock_t=yes
11418 >  ac_cv_cxx_have_fstream_attach=yes
11419   else
11420    echo "$as_me: failed program was:" >&5
11421   sed 's/^/| /' conftest.$ac_ext >&5
11422  
7685 ac_cv_type_clock_t=no
11423   fi
11424   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11425 +    ac_ext=cc
11426 + ac_cpp='$CXXCPP $CPPFLAGS'
11427 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11428 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11429 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11430 +
11431 +
11432   fi
11433 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11434 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11435 < if test $ac_cv_type_clock_t = yes; then
11433 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11434 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11435 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11436  
11437 < cat >>confdefs.h <<_ACEOF
11438 < #define HAVE_CLOCK_T 1
11437 > cat >>confdefs.h <<\_ACEOF
11438 > #define HAVE_FSTREAM_ATTACH 1
11439   _ACEOF
11440  
11441 +  fi
11442  
7698 fi
11443  
11444 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11445 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11446 < if test "${ac_cv_c_const+set}" = set; then
11444 >
11445 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11446 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11447 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11448    echo $ECHO_N "(cached) $ECHO_C" >&6
11449   else
11450 <  cat >conftest.$ac_ext <<_ACEOF
11450 >
11451 >    ac_cv_cxx_have_fstream_open=no
11452 >    ac_cv_cxx_fstream_open_prot=no
11453 >
11454 >
11455 >    ac_ext=cc
11456 > ac_cpp='$CXXCPP $CPPFLAGS'
11457 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11458 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11459 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11460 >
11461 >    # Try with 2 parameters
11462 >    cat >conftest.$ac_ext <<_ACEOF
11463   /* confdefs.h.  */
11464   _ACEOF
11465   cat confdefs.h >>conftest.$ac_ext
11466   cat >>conftest.$ac_ext <<_ACEOF
11467   /* end confdefs.h.  */
11468  
11469 + #ifdef HAVE_IOSTREAM
11470 + #include <fstream>
11471 + #else
11472 + #include <fstream.h>
11473 + #endif
11474 + #ifdef HAVE_STD_IOSTREAM
11475 + using namespace std;
11476 + #endif
11477 +
11478 + #ifdef FC_DUMMY_MAIN
11479 + #ifndef FC_DUMMY_MAIN_EQ_F77
11480 + #  ifdef __cplusplus
11481 +     extern "C"
11482 + #  endif
11483 +   int FC_DUMMY_MAIN() { return 1; }
11484 + #endif
11485 + #endif
11486   int
11487   main ()
11488   {
11489 < /* 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 <
11489 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11490    ;
11491    return 0;
11492   }
# Line 7772 | Line 11500 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11500    cat conftest.err >&5
11501    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11502    (exit $ac_status); } &&
11503 <         { ac_try='test -z "$ac_c_werror_flag"
11503 >         { ac_try='test -z "$ac_cxx_werror_flag"
11504                           || test ! -s conftest.err'
11505    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11506    (eval $ac_try) 2>&5
# Line 7785 | Line 11513 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11513    ac_status=$?
11514    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11515    (exit $ac_status); }; }; then
11516 <  ac_cv_c_const=yes
11516 >  ac_cv_cxx_have_fstream_open=yes
11517   else
11518    echo "$as_me: failed program was:" >&5
11519   sed 's/^/| /' conftest.$ac_ext >&5
11520  
7793 ac_cv_c_const=no
11521   fi
11522   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11523 < fi
11524 < 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
11523 >    # Try with mode parameter
11524 >    cat >conftest.$ac_ext <<_ACEOF
11525   /* confdefs.h.  */
11526   _ACEOF
11527   cat confdefs.h >>conftest.$ac_ext
11528   cat >>conftest.$ac_ext <<_ACEOF
11529   /* end confdefs.h.  */
11530 < #ifndef __cplusplus
11531 < typedef int foo_t;
11532 < static $ac_kw foo_t static_foo () {return 0; }
11533 < $ac_kw foo_t foo () {return 0; }
11530 >
11531 > #ifdef HAVE_IOSTREAM
11532 > #include <fstream>
11533 > #else
11534 > #include <fstream.h>
11535   #endif
11536 + #ifdef HAVE_STD_IOSTREAM
11537 + using namespace std;
11538 + #endif
11539  
11540 + #ifdef FC_DUMMY_MAIN
11541 + #ifndef FC_DUMMY_MAIN_EQ_F77
11542 + #  ifdef __cplusplus
11543 +     extern "C"
11544 + #  endif
11545 +   int FC_DUMMY_MAIN() { return 1; }
11546 + #endif
11547 + #endif
11548 + int
11549 + main ()
11550 + {
11551 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11552 +  ;
11553 +  return 0;
11554 + }
11555   _ACEOF
11556   rm -f conftest.$ac_objext
11557   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7833 | Line 11562 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11562    cat conftest.err >&5
11563    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11564    (exit $ac_status); } &&
11565 <         { ac_try='test -z "$ac_c_werror_flag"
11565 >         { ac_try='test -z "$ac_cxx_werror_flag"
11566                           || test ! -s conftest.err'
11567    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11568    (eval $ac_try) 2>&5
# Line 7846 | Line 11575 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11575    ac_status=$?
11576    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11577    (exit $ac_status); }; }; then
11578 <  ac_cv_c_inline=$ac_kw; break
11578 >  ac_cv_cxx_fstream_open_prot=yes
11579   else
11580    echo "$as_me: failed program was:" >&5
11581   sed 's/^/| /' conftest.$ac_ext >&5
11582  
11583   fi
11584   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11585 < done
11585 >    ac_ext=cc
11586 > ac_cpp='$CXXCPP $CPPFLAGS'
11587 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11588 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11589 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11590  
11591 +
11592   fi
11593 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
11594 < echo "${ECHO_T}$ac_cv_c_inline" >&6
11593 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11594 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11595 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11596  
11597 + cat >>confdefs.h <<\_ACEOF
11598 + #define HAVE_FSTREAM_OPEN 1
11599 + _ACEOF
11600  
11601 < case $ac_cv_c_inline in
11602 <  inline | yes) ;;
11603 <  *)
11604 <    case $ac_cv_c_inline in
11605 <      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
11601 >  fi
11602 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11603 >
11604 > cat >>confdefs.h <<\_ACEOF
11605 > #define FSTREAM_OPEN_PROT 1
11606   _ACEOF
7875    ;;
7876 esac
11607  
11608 +  fi
11609  
11610  
7880  # clean out junk possibly left behind by a previous configuration
7881  rm -f src/getopt.h
7882  # Check for getopt_long support
11611  
11612 < for ac_header in getopt.h
11612 >
11613 >
11614 >
11615 >
11616 > for ac_header in ctype.h iostream fstream sstream strstream
11617   do
11618   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11619   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7914 | Line 11646 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11646    cat conftest.err >&5
11647    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648    (exit $ac_status); } &&
11649 <         { ac_try='test -z "$ac_c_werror_flag"
11649 >         { ac_try='test -z "$ac_cxx_werror_flag"
11650                           || test ! -s conftest.err'
11651    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11652    (eval $ac_try) 2>&5
# Line 7958 | Line 11690 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11690    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11691    (exit $ac_status); } >/dev/null; then
11692    if test -s conftest.err; then
11693 <    ac_cpp_err=$ac_c_preproc_warn_flag
11694 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11693 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11694 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11695    else
11696      ac_cpp_err=
11697    fi
# Line 7979 | Line 11711 | echo "${ECHO_T}$ac_header_preproc" >&6
11711   echo "${ECHO_T}$ac_header_preproc" >&6
11712  
11713   # So?  What about this header?
11714 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11714 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11715    yes:no: )
11716      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11717   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 8030 | Line 11762 | done
11762  
11763   done
11764  
11765 + # AC_CPP_FUNC
11766 + # ------------------ #
11767 + # Checks to see if ANSI C99 CPP variable __func__ works.
11768 + # If not, perhaps __FUNCTION__ works instead.
11769 + # If not, we'll just define __func__ to "".
11770 + # AC_CPP_FUNC
11771  
11772 < for ac_func in getopt_long
11773 < do
11774 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11775 < 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
11772 >
11773 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11774 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11775 > if test "${ac_cv_cpp_func+set}" = set; then
11776    echo $ECHO_N "(cached) $ECHO_C" >&6
11777   else
11778    cat >conftest.$ac_ext <<_ACEOF
# Line 8045 | Line 11781 | cat >>conftest.$ac_ext <<_ACEOF
11781   cat confdefs.h >>conftest.$ac_ext
11782   cat >>conftest.$ac_ext <<_ACEOF
11783   /* 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
11784  
11785 < /* System header to define __stub macros and hopefully few prototypes,
11786 <    which can conflict with char $ac_func (); below.
11787 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11788 <    <limits.h> exists even on freestanding compilers.  */
11789 <
11790 < #ifdef __STDC__
8058 < # include <limits.h>
8059 < #else
8060 < # include <assert.h>
11785 > #ifdef FC_DUMMY_MAIN
11786 > #ifndef FC_DUMMY_MAIN_EQ_F77
11787 > #  ifdef __cplusplus
11788 >     extern "C"
11789 > #  endif
11790 >   int FC_DUMMY_MAIN() { return 1; }
11791   #endif
8062
8063 #undef $ac_func
8064
8065 /* Override any gcc2 internal prototype to avoid an error.  */
8066 #ifdef __cplusplus
8067 extern "C"
8068 {
11792   #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;
8080 #endif
8081 #ifdef __cplusplus
8082 }
8083 #endif
8084
11793   int
11794   main ()
11795   {
11796 < return f != $ac_func;
11796 > const char *foo = __func__;
11797    ;
11798    return 0;
11799   }
11800   _ACEOF
11801 < rm -f conftest.$ac_objext conftest$ac_exeext
11802 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11803 <  (eval $ac_link) 2>conftest.er1
11801 > rm -f conftest.$ac_objext
11802 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11803 >  (eval $ac_compile) 2>conftest.er1
11804    ac_status=$?
11805    grep -v '^ *+' conftest.er1 >conftest.err
11806    rm -f conftest.er1
11807    cat conftest.err >&5
11808    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11809    (exit $ac_status); } &&
11810 <         { ac_try='test -z "$ac_c_werror_flag"
11810 >         { ac_try='test -z "$ac_cxx_werror_flag"
11811                           || test ! -s conftest.err'
11812    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11813    (eval $ac_try) 2>&5
11814    ac_status=$?
11815    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11816    (exit $ac_status); }; } &&
11817 <         { ac_try='test -s conftest$ac_exeext'
11817 >         { ac_try='test -s conftest.$ac_objext'
11818    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11819    (eval $ac_try) 2>&5
11820    ac_status=$?
11821    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11822    (exit $ac_status); }; }; then
11823 <  eval "$as_ac_var=yes"
11823 >  ac_cv_cpp_func=yes
11824   else
11825    echo "$as_me: failed program was:" >&5
11826   sed 's/^/| /' conftest.$ac_ext >&5
11827  
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"
11828   cat >conftest.$ac_ext <<_ACEOF
11829   /* confdefs.h.  */
11830   _ACEOF
# Line 8145 | Line 11832 | cat >>conftest.$ac_ext <<_ACEOF
11832   cat >>conftest.$ac_ext <<_ACEOF
11833   /* end confdefs.h.  */
11834  
11835 < /* Override any gcc2 internal prototype to avoid an error.  */
11836 < #ifdef __cplusplus
11837 < extern "C"
11835 > #ifdef FC_DUMMY_MAIN
11836 > #ifndef FC_DUMMY_MAIN_EQ_F77
11837 > #  ifdef __cplusplus
11838 >     extern "C"
11839 > #  endif
11840 >   int FC_DUMMY_MAIN() { return 1; }
11841   #endif
11842 < /* We use char because int might match the return type of a gcc2
8153 <   builtin and then its argument prototype would still apply.  */
8154 < char getopt_long ();
11842 > #endif
11843   int
11844   main ()
11845   {
11846 < getopt_long ();
11846 > const char *foo = __FUNCTION__;
11847    ;
11848    return 0;
11849   }
11850   _ACEOF
11851 < rm -f conftest.$ac_objext conftest$ac_exeext
11852 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11853 <  (eval $ac_link) 2>conftest.er1
11851 > rm -f conftest.$ac_objext
11852 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11853 >  (eval $ac_compile) 2>conftest.er1
11854    ac_status=$?
11855    grep -v '^ *+' conftest.er1 >conftest.err
11856    rm -f conftest.er1
11857    cat conftest.err >&5
11858    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11859    (exit $ac_status); } &&
11860 <         { ac_try='test -z "$ac_c_werror_flag"
11860 >         { ac_try='test -z "$ac_cxx_werror_flag"
11861                           || test ! -s conftest.err'
11862    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11863    (eval $ac_try) 2>&5
11864    ac_status=$?
11865    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11866    (exit $ac_status); }; } &&
11867 <         { ac_try='test -s conftest$ac_exeext'
11867 >         { ac_try='test -s conftest.$ac_objext'
11868    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11869    (eval $ac_try) 2>&5
11870    ac_status=$?
11871    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11872    (exit $ac_status); }; }; then
11873 <  ac_cv_lib_gnugetopt_getopt_long=yes
11873 >  ac_cv_cpp_func=__FUNCTION__
11874   else
11875    echo "$as_me: failed program was:" >&5
11876   sed 's/^/| /' conftest.$ac_ext >&5
11877  
11878 < ac_cv_lib_gnugetopt_getopt_long=no
11878 > ac_cv_cpp_func=no
11879   fi
11880 < rm -f conftest.err conftest.$ac_objext \
8193 <      conftest$ac_exeext conftest.$ac_ext
8194 < LIBS=$ac_check_lib_save_LIBS
11880 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11881   fi
11882 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11883 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11884 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11885 <  cat >>confdefs.h <<\_ACEOF
11886 < #define HAVE_GETOPT_LONG 1
11882 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11883 > fi
11884 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11885 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11886 > if test $ac_cv_cpp_func = __FUNCTION__; then
11887 >
11888 > cat >>confdefs.h <<\_ACEOF
11889 > #define __func__ __FUNCTION__
11890   _ACEOF
11891  
11892 < else
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
11892 > elif test $ac_cv_cpp_func = no; then
11893  
11894 <      case $LIBOBJS in
11895 <    "getopt1.$ac_objext"   | \
11896 <  *" getopt1.$ac_objext"   | \
8216 <    "getopt1.$ac_objext "* | \
8217 <  *" getopt1.$ac_objext "* ) ;;
8218 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
8219 < esac
11894 > cat >>confdefs.h <<\_ACEOF
11895 > #define __func__ ""
11896 > _ACEOF
11897  
8221                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
8222
11898   fi
11899  
8225 fi
8226 done
11900  
11901  
11902  
11903 +
11904   case $debug in
11905    1)
11906       ;;
# Line 8235 | Line 11909 | case $debug in
11909  
11910  
11911  
11912 + # Try to determine "good" native compiler flags if none specified on command
11913 + # line
11914  
11915 + if test "$ac_test_FFLAGS" != "set"; then
11916 +  FCFLAGS=""
11917 +  case "${host_cpu}-${host_os}" in
11918  
11919 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11920 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11921 +                fi;;
11922 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11923 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11924 +                fi;;
11925 +   powerpc*-aix*)
11926 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11927 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11928 +                echo "*******************************************************"
11929 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11930 +                echo "*  recommended that you use                           *"
11931 +                echo "*                                                     *"
11932 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11933 +                echo "*                                 ^^^                 *"
11934 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11935 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11936 +                echo "*******************************************************"
11937 +        fi;;
11938 +   *darwin*)
11939 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11940 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11941 +        fi
11942 +        if test "$FC" = ifort; then
11943 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11944 +        fi;;
11945 +  esac
11946 +
11947 +  if test -n "$CPU_FLAGS"; then
11948 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11949 +  fi
11950 +
11951 +  if test -z "$FCFLAGS"; then
11952 +        echo ""
11953 +        echo "*********************************************************"
11954 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11955 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11956 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11957 +        echo "*********************************************************"
11958 +        echo ""
11959 +        FCFLAGS="-O3"
11960 +  fi
11961 +
11962 +
11963 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11964 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11965 + if test "${ac_guessed_f90flags+set}" = set; then
11966 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11967 + else
11968 +
11969 +
11970 +
11971 + ac_ext=${FC_SRCEXT-f}
11972 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11973 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11974 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11975 +
11976 + echo 'program main' > conftest.$ac_ext
11977 + echo 'end program main' >> conftest.$ac_ext
11978 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11979 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11980 +  (eval $ac_compile) 2>&5
11981 +  ac_status=$?
11982 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11983 +  (exit $ac_status); }; then
11984 +        ac_guessed_f90flags=yes
11985 + else
11986 +        ac_guessed_f90flags=no
11987 + fi
11988 + rm -f conftest*
11989 + ac_ext=cc
11990 + ac_cpp='$CXXCPP $CPPFLAGS'
11991 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11992 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11993 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11994 +
11995 +
11996 + fi
11997 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
11998 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
11999 + if test "$ac_guessed_f90flags" = yes; then
12000 +        :
12001 +
12002 + else
12003 +        :
12004 +
12005 +        echo ""
12006 +        echo "**********************************************************"
12007 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12008 +        echo "* your compiler.                                        *"
12009 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12010 +        echo "*********************************************************"
12011 +        echo ""
12012 +        FCFLAGS=""
12013 +
12014 + fi
12015 +
12016 +
12017 + fi
12018 +
12019 +
12020 +
12021 +
12022 +
12023 +
12024 +
12025   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12026   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12027   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 8285 | Line 12070 | if test "$ac_test_CFLAGS" != "set"; then
12070                      CFLAGS="-O"
12071                  fi;;
12072    sparc-solaris2*) if test "$CC" = cc; then
12073 <                    CFLAGS="-native -fast -xO5 -dalign"
12073 >                    CFLAGS="-O -dalign"
12074                   fi;;
12075  
12076    alpha*-osf*)  if test "$CC" = cc; then
# Line 8315 | Line 12100 | if test "$ac_test_CFLAGS" != "set"; then
12100     *darwin*)
12101          if test "$CC" = xlc -o "$CC" = cc; then
12102                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12103 +        fi
12104 +        if test "$CC" = icc; then
12105 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12106          fi;;
12107    esac
12108  
# Line 8328 | Line 12116 | if test "$ac_test_CFLAGS" != "set"; then
12116      # -malign-double for x86 systems
12117  
12118  
12119 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12120 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12119 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12120 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12121   if test "${ac_align_double+set}" = set; then
12122    echo $ECHO_N "(cached) $ECHO_C" >&6
12123   else
12124    echo 'void f(){}' > conftest.c
12125 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12125 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12126          ac_align_double=yes
12127   else
12128          ac_align_double=no
# Line 8355 | Line 12143 | fi
12143      # -fstrict-aliasing for gcc-2.95+
12144  
12145  
12146 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12147 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12146 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12147 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12148   if test "${ac_fstrict_aliasing+set}" = set; then
12149    echo $ECHO_N "(cached) $ECHO_C" >&6
12150   else
12151    echo 'void f(){}' > conftest.c
12152 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12152 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12153          ac_fstrict_aliasing=yes
12154   else
12155          ac_fstrict_aliasing=no
# Line 8386 | Line 12174 | fi
12174                    case "${host_cpu}" in
12175            i586*)
12176  
12177 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12178 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12177 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12178 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12179   if test "${ac_cpu_pentium+set}" = set; then
12180    echo $ECHO_N "(cached) $ECHO_C" >&6
12181   else
12182    echo 'void f(){}' > conftest.c
12183 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12183 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12184          ac_cpu_pentium=yes
12185   else
12186          ac_cpu_pentium=no
# Line 8409 | Line 12197 | else
12197          :
12198  
12199  
12200 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12201 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12200 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12201 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12202   if test "${ac_pentium+set}" = set; then
12203    echo $ECHO_N "(cached) $ECHO_C" >&6
12204   else
12205    echo 'void f(){}' > conftest.c
12206 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12206 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12207          ac_pentium=yes
12208   else
12209          ac_pentium=no
# Line 8438 | Line 12226 | fi
12226                    ;;
12227            i686*)
12228  
12229 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12230 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12229 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12230 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12231   if test "${ac_cpu_pentiumpro+set}" = set; then
12232    echo $ECHO_N "(cached) $ECHO_C" >&6
12233   else
12234    echo 'void f(){}' > conftest.c
12235 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12235 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12236          ac_cpu_pentiumpro=yes
12237   else
12238          ac_cpu_pentiumpro=no
# Line 8461 | Line 12249 | else
12249          :
12250  
12251  
12252 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12253 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12252 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12253 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12254   if test "${ac_pentiumpro+set}" = set; then
12255    echo $ECHO_N "(cached) $ECHO_C" >&6
12256   else
12257    echo 'void f(){}' > conftest.c
12258 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12258 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12259          ac_pentiumpro=yes
12260   else
12261          ac_pentiumpro=no
# Line 8494 | Line 12282 | fi
12282                  if test -n "$is60x"; then
12283  
12284  
12285 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12286 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12285 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12286 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12287   if test "${ac_m_cpu_60x+set}" = set; then
12288    echo $ECHO_N "(cached) $ECHO_C" >&6
12289   else
12290    echo 'void f(){}' > conftest.c
12291 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12291 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12292          ac_m_cpu_60x=yes
12293   else
12294          ac_m_cpu_60x=no
# Line 8552 | Line 12340 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12340          :
12341  
12342  
12343 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12344 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12343 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12344 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12345   if test "${ac_m_cpu_750+set}" = set; then
12346    echo $ECHO_N "(cached) $ECHO_C" >&6
12347   else
12348    echo 'void f(){}' > conftest.c
12349 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12349 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12350          ac_m_cpu_750=yes
12351   else
12352          ac_m_cpu_750=no
# Line 8585 | Line 12373 | fi
12373                  if test -z "$CPU_FLAGS"; then
12374  
12375  
12376 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12377 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12376 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12377 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12378   if test "${ac_m_cpu_powerpc+set}" = set; then
12379    echo $ECHO_N "(cached) $ECHO_C" >&6
12380   else
12381    echo 'void f(){}' > conftest.c
12382 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12382 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12383          ac_m_cpu_powerpc=yes
12384   else
12385          ac_m_cpu_powerpc=no
# Line 8613 | Line 12401 | fi
12401                  if test -z "$CPU_FLAGS"; then
12402  
12403  
12404 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12405 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12404 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12405 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12406   if test "${ac_m_powerpc+set}" = set; then
12407    echo $ECHO_N "(cached) $ECHO_C" >&6
12408   else
12409    echo 'void f(){}' > conftest.c
12410 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12410 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12411          ac_m_powerpc=yes
12412   else
12413          ac_m_powerpc=no
# Line 8658 | Line 12446 | fi
12446  
12447  
12448  
12449 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12450 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12449 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12450 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12451   if test "${ac_guessed_cflags+set}" = set; then
12452    echo $ECHO_N "(cached) $ECHO_C" >&6
12453   else
12454    echo 'void f(){}' > conftest.c
12455 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12455 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12456          ac_guessed_cflags=yes
12457   else
12458          ac_guessed_cflags=no
# Line 8748 | Line 12536 | if test "$ac_test_CXXFLAGS" != "set"; then
12536                      CXXFLAGS="-O"
12537                  fi;;
12538    sparc-solaris2*) if test "$CXX" = CC; then
12539 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12539 >                    CXXFLAGS="-features=extensions -O -dalign"
12540                   fi;;
12541     rs6000*-aix*)  if test "$CXX" = xlC; then
12542                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8769 | Line 12557 | if test "$ac_test_CXXFLAGS" != "set"; then
12557     *darwin*)
12558          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12559                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12560 +        fi
12561 +        if test "$CXX" = icpc; then
12562 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12563          fi;;
12564    esac
12565  
# Line 8782 | Line 12573 | if test "$ac_test_CXXFLAGS" != "set"; then
12573      # -malign-double for x86 systems
12574  
12575  
12576 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12577 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12576 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12577 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12578   if test "${ac_align_double+set}" = set; then
12579    echo $ECHO_N "(cached) $ECHO_C" >&6
12580   else
12581    echo 'void f(){}' > conftest.cpp
12582 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12582 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12583          ac_align_double=yes
12584   else
12585          ac_align_double=no
# Line 8809 | Line 12600 | fi
12600      # -fstrict-aliasing for gcc-2.95+
12601  
12602  
12603 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12604 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12603 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12604 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12605   if test "${ac_fstrict_aliasing+set}" = set; then
12606    echo $ECHO_N "(cached) $ECHO_C" >&6
12607   else
12608    echo 'void f(){}' > conftest.cpp
12609 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12609 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12610          ac_fstrict_aliasing=yes
12611   else
12612          ac_fstrict_aliasing=no
# Line 8840 | Line 12631 | fi
12631                    case "${host_cpu}" in
12632            i586*)
12633  
12634 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12635 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12634 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12635 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12636   if test "${ac_cpu_pentium+set}" = set; then
12637    echo $ECHO_N "(cached) $ECHO_C" >&6
12638   else
12639    echo 'void f(){}' > conftest.cpp
12640 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12640 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12641          ac_cpu_pentium=yes
12642   else
12643          ac_cpu_pentium=no
# Line 8863 | Line 12654 | else
12654          :
12655  
12656  
12657 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12658 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12657 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12658 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12659   if test "${ac_pentium+set}" = set; then
12660    echo $ECHO_N "(cached) $ECHO_C" >&6
12661   else
12662    echo 'void f(){}' > conftest.cpp
12663 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12663 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12664          ac_pentium=yes
12665   else
12666          ac_pentium=no
# Line 8892 | Line 12683 | fi
12683                    ;;
12684            i686*)
12685  
12686 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12687 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12686 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12687 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12688   if test "${ac_cpu_pentiumpro+set}" = set; then
12689    echo $ECHO_N "(cached) $ECHO_C" >&6
12690   else
12691    echo 'void f(){}' > conftest.cpp
12692 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12692 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12693          ac_cpu_pentiumpro=yes
12694   else
12695          ac_cpu_pentiumpro=no
# Line 8915 | Line 12706 | else
12706          :
12707  
12708  
12709 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12710 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12709 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12710 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12711   if test "${ac_pentiumpro+set}" = set; then
12712    echo $ECHO_N "(cached) $ECHO_C" >&6
12713   else
12714    echo 'void f(){}' > conftest.cpp
12715 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12715 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12716          ac_pentiumpro=yes
12717   else
12718          ac_pentiumpro=no
# Line 8948 | Line 12739 | fi
12739                  if test -n "$is60x"; then
12740  
12741  
12742 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12743 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12742 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12743 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12744   if test "${ac_m_cpu_60x+set}" = set; then
12745    echo $ECHO_N "(cached) $ECHO_C" >&6
12746   else
12747    echo 'void f(){}' > conftest.cpp
12748 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12748 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12749          ac_m_cpu_60x=yes
12750   else
12751          ac_m_cpu_60x=no
# Line 8964 | Line 12755 | echo "${ECHO_T}$ac_m_cpu_60x" >&6
12755   fi
12756   echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
12757   echo "${ECHO_T}$ac_m_cpu_60x" >&6
12758 < if test "$ac_m_cpu_60x" = yes; then
12759 <        :
12760 <        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
12758 > if test "$ac_m_cpu_60x" = yes; then
12759 >        :
12760 >        CPU_FLAGS=-mcpu=$cputype
12761   else
12762 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
12763 < echo "${ECHO_T}no, using $LN_S" >&6
12762 >        :
12763 >
12764   fi
12765  
12766 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
12767 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
12768 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
12769 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
12766 >                elif test "$cputype" = 750; then
12767 >
12768 >
12769 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
12770 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
12771 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
12772    echo $ECHO_N "(cached) $ECHO_C" >&6
12773   else
12774 <  cat >conftest.make <<\_ACEOF
12775 < all:
12776 <        @echo 'ac_maketemp="$(MAKE)"'
12777 < _ACEOF
12778 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
12779 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
12780 < if test -n "$ac_maketemp"; then
12781 <  eval ac_cv_prog_make_${ac_make}_set=yes
12774 >
12775 > cat > conftest.cpp <<EOF
12776 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12777 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12778 >     yes;
12779 > #  endif
12780 > #endif
12781 > EOF
12782 > if { ac_try='${CXX-c++} -E conftest.cpp'
12783 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12784 >  (eval $ac_try) 2>&5
12785 >  ac_status=$?
12786 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12787 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12788 >  ac_cv_prog_gxx_2_95=yes
12789   else
12790 <  eval ac_cv_prog_make_${ac_make}_set=no
12790 >  ac_cv_prog_gxx_2_95=no
12791   fi
12792 < rm -f conftest.make
12792 >
12793   fi
12794 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
12795 <  echo "$as_me:$LINENO: result: yes" >&5
12796 < echo "${ECHO_T}yes" >&6
12797 <  SET_MAKE=
9375 < else
9376 <  echo "$as_me:$LINENO: result: no" >&5
9377 < echo "${ECHO_T}no" >&6
9378 <  SET_MAKE="MAKE=${MAKE-make}"
9379 < fi
12794 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12795 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12796 > if test "$ac_cv_prog_gxx_2_95" = yes; then
12797 >        :
12798  
12799 < if test -n "$ac_tool_prefix"; then
12800 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
12801 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
12802 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9385 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9386 < if test "${ac_cv_prog_RANLIB+set}" = set; then
12799 >
12800 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12801 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12802 > if test "${ac_m_cpu_750+set}" = set; then
12803    echo $ECHO_N "(cached) $ECHO_C" >&6
12804   else
12805 <  if test -n "$RANLIB"; then
12806 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
12805 >  echo 'void f(){}' > conftest.cpp
12806 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12807 >        ac_m_cpu_750=yes
12808   else
12809 < 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
9405 <
12809 >        ac_m_cpu_750=no
12810   fi
12811 < fi
9408 < RANLIB=$ac_cv_prog_RANLIB
9409 < if test -n "$RANLIB"; then
9410 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
9411 < echo "${ECHO_T}$RANLIB" >&6
9412 < else
9413 <  echo "$as_me:$LINENO: result: no" >&5
9414 < echo "${ECHO_T}no" >&6
9415 < fi
12811 > rm -f conftest*
12812  
12813   fi
12814 < if test -z "$ac_cv_prog_RANLIB"; then
12815 <  ac_ct_RANLIB=$RANLIB
12816 <  # Extract the first word of "ranlib", so it can be a program name with args.
12817 < set dummy ranlib; ac_word=$2
12818 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9423 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9424 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
9425 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12814 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12815 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12816 > if test "$ac_m_cpu_750" = yes; then
12817 >        :
12818 >        CPU_FLAGS=-mcpu=750
12819   else
12820 <  if test -n "$ac_ct_RANLIB"; then
9428 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
9429 < else
9430 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9431 < for as_dir in $PATH
9432 < 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
12820 >        :
12821  
9444  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
12822   fi
9446 fi
9447 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
9448 if test -n "$ac_ct_RANLIB"; then
9449  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
9450 echo "${ECHO_T}$ac_ct_RANLIB" >&6
9451 else
9452  echo "$as_me:$LINENO: result: no" >&5
9453 echo "${ECHO_T}no" >&6
9454 fi
12823  
9456  RANLIB=$ac_ct_RANLIB
12824   else
12825 <  RANLIB="$ac_cv_prog_RANLIB"
12825 >        :
12826 >
12827   fi
12828  
12829 < for ac_prog in 'bison -y' byacc
12830 < do
12831 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12832 < set dummy $ac_prog; ac_word=$2
12833 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12834 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12835 < if test "${ac_cv_prog_YACC+set}" = set; then
12829 >                fi
12830 >                if test -z "$CPU_FLAGS"; then
12831 >
12832 >
12833 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12834 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12835 > if test "${ac_m_cpu_powerpc+set}" = set; then
12836    echo $ECHO_N "(cached) $ECHO_C" >&6
12837   else
12838 <  if test -n "$YACC"; then
12839 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
12838 >  echo 'void f(){}' > conftest.cpp
12839 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12840 >        ac_m_cpu_powerpc=yes
12841   else
12842 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12843 < for as_dir in $PATH
12844 < 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
12842 >        ac_m_cpu_powerpc=no
12843 > fi
12844 > rm -f conftest*
12845  
12846   fi
12847 < fi
12848 < YACC=$ac_cv_prog_YACC
12849 < if test -n "$YACC"; then
12850 <  echo "$as_me:$LINENO: result: $YACC" >&5
12851 < echo "${ECHO_T}$YACC" >&6
12847 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12848 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12849 > if test "$ac_m_cpu_powerpc" = yes; then
12850 >        :
12851 >        CPU_FLAGS=-mcpu=powerpc
12852   else
12853 <  echo "$as_me:$LINENO: result: no" >&5
12854 < echo "${ECHO_T}no" >&6
12853 >        :
12854 >
12855   fi
12856  
12857 <  test -n "$YACC" && break
12858 < done
9500 < test -n "$YACC" || YACC="yacc"
12857 >                fi
12858 >                if test -z "$CPU_FLAGS"; then
12859  
12860 < for ac_prog in flex lex
12861 < do
12862 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12863 < 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
12860 >
12861 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12862 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12863 > if test "${ac_m_powerpc+set}" = set; then
12864    echo $ECHO_N "(cached) $ECHO_C" >&6
12865   else
12866 <  if test -n "$LEX"; then
12867 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12866 >  echo 'void f(){}' > conftest.cpp
12867 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12868 >        ac_m_powerpc=yes
12869   else
12870 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12871 < for as_dir in $PATH
12872 < 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
12870 >        ac_m_powerpc=no
12871 > fi
12872 > rm -f conftest*
12873  
12874   fi
12875 < fi
12876 < LEX=$ac_cv_prog_LEX
12877 < if test -n "$LEX"; then
12878 <  echo "$as_me:$LINENO: result: $LEX" >&5
12879 < echo "${ECHO_T}$LEX" >&6
12875 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12876 > echo "${ECHO_T}$ac_m_powerpc" >&6
12877 > if test "$ac_m_powerpc" = yes; then
12878 >        :
12879 >        CPU_FLAGS=-mpowerpc
12880   else
12881 <  echo "$as_me:$LINENO: result: no" >&5
12882 < echo "${ECHO_T}no" >&6
12881 >        :
12882 >
12883   fi
12884  
12885 <  test -n "$LEX" && break
12886 < done
12887 < test -n "$LEX" || LEX=":"
12885 >                fi
12886 >          esac
12887 >  fi
12888  
12889 < if test -z "$LEXLIB"
12890 < then
12891 <  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.  */
12889 >  if test -n "$CPU_FLAGS"; then
12890 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12891 >  fi
12892  
12893 < /* Override any gcc2 internal prototype to avoid an error.  */
12894 < #ifdef __cplusplus
12895 < extern "C"
12896 < #endif
12897 < /* We use char because int might match the return type of a gcc2
12898 <   builtin and then its argument prototype would still apply.  */
12899 < char yywrap ();
12900 < int
12901 < main ()
12902 < {
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
12893 >  if test -z "$CXXFLAGS"; then
12894 >        echo ""
12895 >        echo "**********************************************************"
12896 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12897 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12898 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12899 >        echo "**********************************************************"
12900 >        echo ""
12901 >        CXXFLAGS="-O3"
12902 >  fi
12903  
9601 ac_cv_lib_fl_yywrap=no
9602 fi
9603 rm -f conftest.err conftest.$ac_objext \
9604      conftest$ac_exeext conftest.$ac_ext
9605 LIBS=$ac_check_lib_save_LIBS
9606 fi
9607 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
9608 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
9609 if test $ac_cv_lib_fl_yywrap = yes; then
9610  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.  */
12904  
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
12905  
12906 < ac_cv_lib_l_yywrap=no
12907 < fi
12908 < 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
9679 <
9680 < fi
9681 <
9682 < 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
12906 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12907 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12908 > if test "${ac_guessed_cxxflags+set}" = set; then
12909    echo $ECHO_N "(cached) $ECHO_C" >&6
12910   else
12911 <  # The minimal lex program is just a single line: %%.  But some broken lexes
12912 < # (Solaris, I think it was) want two %% lines, so accommodate them.
12913 < 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
12911 >  echo 'void f(){}' > conftest.cpp
12912 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12913 >        ac_guessed_cxxflags=yes
12914   else
12915 <  { { 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; }; }
12915 >        ac_guessed_cxxflags=no
12916   fi
12917 + rm -f conftest*
12918 +
12919   fi
12920 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
12921 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
12922 < rm -f conftest.l
12923 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12920 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12921 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12922 > if test "$ac_guessed_cxxflags" = yes; then
12923 >        :
12924  
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
12925   else
12926 <  # 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
12926 >        :
12927  
12928 < fi
12929 < rm -f conftest.err conftest.$ac_objext \
12930 <      conftest$ac_exeext conftest.$ac_ext
12931 < LIBS=$ac_save_LIBS
12932 < rm -f "${LEX_OUTPUT_ROOT}.c"
12933 <
12934 < fi
12935 < 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
9772 <
9773 < fi
9774 <
9775 < fi
9776 <
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
12928 >        echo ""
12929 >        echo "**********************************************************"
12930 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12931 >        echo "* your compiler.                                         *"
12932 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12933 >        echo "**********************************************************"
12934 >        echo ""
12935 >        CXXFLAGS=""
12936  
9803  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9804  ;;
9805 esac
12937   fi
9807 PERLINTERP=$ac_cv_path_PERLINTERP
12938  
9809 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
12939  
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
12940   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;}
12941  
12942 < # 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 <  ;;
12942 >     ;;
12943   esac
10020 fi
10021 PS=$ac_cv_path_PS
12944  
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
12945  
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
12946   cat >>confdefs.h <<\_ACEOF
12947   #define OBAPI
12948   _ACEOF
12949  
12950  
12951  
10075 if test "$ac_cv_prog_ps_syntax" = BSD; then
12952  
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
12953   # Check whether --with-mpi or --without-mpi was given.
12954   if test "${with_mpi+set}" = set; then
12955    withval="$with_mpi"
# Line 10148 | Line 13005 | rm -f conftest*
13005   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13006   have_mpif_h=0
13007   rm -f conftest*
13008 < cat >conftest.f90 <<EOF
13008 > cat >conftest.$ac_ext <<EOF
13009   program main
13010     include 'mpif.h'
13011   end
13012   EOF
13013 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13013 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13014          echo "$as_me:$LINENO: result: yes" >&5
13015   echo "${ECHO_T}yes" >&6
13016          MPI_F90_INC="$MPI_INC_DIR"
# Line 10207 | Line 13064 | char MPI_Init ();
13064   /* We use char because int might match the return type of a gcc2
13065     builtin and then its argument prototype would still apply.  */
13066   char MPI_Init ();
13067 + #ifdef FC_DUMMY_MAIN
13068 + #ifndef FC_DUMMY_MAIN_EQ_F77
13069 + #  ifdef __cplusplus
13070 +     extern "C"
13071 + #  endif
13072 +   int FC_DUMMY_MAIN() { return 1; }
13073 + #endif
13074 + #endif
13075   int
13076   main ()
13077   {
# Line 10277 | Line 13142 | char MPI_Init ();
13142   /* We use char because int might match the return type of a gcc2
13143     builtin and then its argument prototype would still apply.  */
13144   char MPI_Init ();
13145 + #ifdef FC_DUMMY_MAIN
13146 + #ifndef FC_DUMMY_MAIN_EQ_F77
13147 + #  ifdef __cplusplus
13148 +     extern "C"
13149 + #  endif
13150 +   int FC_DUMMY_MAIN() { return 1; }
13151 + #endif
13152 + #endif
13153   int
13154   main ()
13155   {
# Line 10348 | Line 13221 | char MPI_Init ();
13221   /* We use char because int might match the return type of a gcc2
13222     builtin and then its argument prototype would still apply.  */
13223   char MPI_Init ();
13224 + #ifdef FC_DUMMY_MAIN
13225 + #ifndef FC_DUMMY_MAIN_EQ_F77
13226 + #  ifdef __cplusplus
13227 +     extern "C"
13228 + #  endif
13229 +   int FC_DUMMY_MAIN() { return 1; }
13230 + #endif
13231 + #endif
13232   int
13233   main ()
13234   {
# Line 10419 | Line 13300 | char MPI_Init ();
13300   /* We use char because int might match the return type of a gcc2
13301     builtin and then its argument prototype would still apply.  */
13302   char MPI_Init ();
13303 + #ifdef FC_DUMMY_MAIN
13304 + #ifndef FC_DUMMY_MAIN_EQ_F77
13305 + #  ifdef __cplusplus
13306 +     extern "C"
13307 + #  endif
13308 +   int FC_DUMMY_MAIN() { return 1; }
13309 + #endif
13310 + #endif
13311   int
13312   main ()
13313   {
# Line 10463 | Line 13352 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
13352   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13353   echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13354   if test $ac_cv_lib_mpich_MPI_Init = yes; then
13355 <  MPI_LIB="-lmpich -lpmpich"
13355 >  MPI_LIB="-lpmpich -lmpich"
13356   fi
13357  
13358   fi
# Line 10491 | Line 13380 | char MPI_Init ();
13380   /* We use char because int might match the return type of a gcc2
13381     builtin and then its argument prototype would still apply.  */
13382   char MPI_Init ();
13383 + #ifdef FC_DUMMY_MAIN
13384 + #ifndef FC_DUMMY_MAIN_EQ_F77
13385 + #  ifdef __cplusplus
13386 +     extern "C"
13387 + #  endif
13388 +   int FC_DUMMY_MAIN() { return 1; }
13389 + #endif
13390 + #endif
13391   int
13392   main ()
13393   {
# Line 10567 | Line 13464 | fi
13464  
13465  
13466  
10570
13467   USE_CGAL=no
13468   cgal_makefile=auto
13469  
# Line 10909 | Line 13805 | cat >>conftest.$ac_ext <<_ACEOF
13805   cat >>conftest.$ac_ext <<_ACEOF
13806   /* end confdefs.h.  */
13807   #include <CGAL/Cartesian.h>
13808 + #ifdef FC_DUMMY_MAIN
13809 + #ifndef FC_DUMMY_MAIN_EQ_F77
13810 + #  ifdef __cplusplus
13811 +     extern "C"
13812 + #  endif
13813 +   int FC_DUMMY_MAIN() { return 1; }
13814 + #endif
13815 + #endif
13816   int
13817   main ()
13818   {
# Line 11014 | Line 13918 | CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13918  
13919  
13920  
11017
13921   # Check whether --enable-doxygen or --disable-doxygen was given.
13922   if test "${enable_doxygen+set}" = set; then
13923    enableval="$enable_doxygen"
# Line 11156 | Line 14059 | fi
14059  
14060  
14061  
11159 OBJEXT=".$OBJEXT"
14062  
11161 OOPSE=oopse
14063  
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;
14064  
11175 case "x$INSTALL" in
11176   x/*) ;;
11177   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
11178 esac
14065  
11180 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14066  
11182 CFLAGS=${CFLAGS-""}
11183 CXXFLAGS=${CXXFLAGS-""}
11184 CPPFLAGS=${CPPFLAGS-""}
11185 FFLAGS=${FFLAGS-""}
11186 F90FLAGS=${F90FLAGS-""}
11187 LDFLAGS=${LDFLAGS-""}
11188 DEBUG=${DEBUG-"-g"}
14067  
11190 case $debug in
11191  1)
11192     FFLAGS="$DEBUG $FFLAGS"
11193     F90FLAGS="$DEBUG $F90FLAGS"
11194     ;;
11195  *)
11196     ;;
11197 esac
14068  
14069  
14070  
14071  
14072  
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11214
11215
11216          ac_config_headers="$ac_config_headers src/config.h"
14073  
14074                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14075  
# Line 11580 | Line 14436 | cat >&5 <<_CSEOF
14436   } >&5
14437   cat >&5 <<_CSEOF
14438  
14439 < This file was extended by OOPSE $as_me 2.0, which was
14439 > This file was extended by OOPSE $as_me 3.0, which was
14440   generated by GNU Autoconf 2.59.  Invocation command line was
14441  
14442    CONFIG_FILES    = $CONFIG_FILES
# Line 11643 | Line 14499 | ac_cs_version="\\
14499  
14500   cat >>$CONFIG_STATUS <<_ACEOF
14501   ac_cs_version="\\
14502 < OOPSE config.status 2.0
14502 > OOPSE config.status 3.0
14503   configured by $0, generated by GNU Autoconf 2.59,
14504    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14505  
# Line 11837 | Line 14693 | s,@LIBS@,$LIBS,;t t
14693   s,@ECHO_N@,$ECHO_N,;t t
14694   s,@ECHO_T@,$ECHO_T,;t t
14695   s,@LIBS@,$LIBS,;t t
11840 s,@PROGNAME@,$PROGNAME,;t t
11841 s,@debug@,$debug,;t t
14696   s,@build@,$build,;t t
14697   s,@build_cpu@,$build_cpu,;t t
14698   s,@build_vendor@,$build_vendor,;t t
# Line 11847 | Line 14701 | s,@host_os@,$host_os,;t t
14701   s,@host_cpu@,$host_cpu,;t t
14702   s,@host_vendor@,$host_vendor,;t t
14703   s,@host_os@,$host_os,;t t
14704 < s,@CC@,$CC,;t t
14705 < s,@CFLAGS@,$CFLAGS,;t t
14704 > s,@PROGNAME@,$PROGNAME,;t t
14705 > s,@debug@,$debug,;t t
14706 > s,@CXX@,$CXX,;t t
14707 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14708   s,@LDFLAGS@,$LDFLAGS,;t t
14709   s,@CPPFLAGS@,$CPPFLAGS,;t t
14710 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14710 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14711   s,@EXEEXT@,$EXEEXT,;t t
14712   s,@OBJEXT@,$OBJEXT,;t t
14713 < s,@CXX@,$CXX,;t t
14714 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14715 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14713 > s,@CC@,$CC,;t t
14714 > s,@CFLAGS@,$CFLAGS,;t t
14715 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14716 > s,@FC@,$FC,;t t
14717 > s,@FCFLAGS@,$FCFLAGS,;t t
14718 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14719   s,@CPP@,$CPP,;t t
14720   s,@EGREP@,$EGREP,;t t
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
14721   s,@LN_S@,$LN_S,;t t
14722   s,@SET_MAKE@,$SET_MAKE,;t t
14723   s,@RANLIB@,$RANLIB,;t t
14724   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
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
14725   s,@PERLINTERP@,$PERLINTERP,;t t
14726   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14727 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14728 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14729 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14730   s,@AR@,$AR,;t t
14731   s,@PS@,$PS,;t t
14732 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14733 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14734 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14735 + s,@FCLIBS@,$FCLIBS,;t t
14736 + s,@FC_FUNC@,$FC_FUNC,;t t
14737 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14738 + s,@MOD@,$MOD,;t t
14739 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14740 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14741 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14742 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14743 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14744 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14745 + s,@ZLIB@,$ZLIB,;t t
14746 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14747 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14748 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14749 + s,@LIBOBJS@,$LIBOBJS,;t t
14750 + s,@POW_LIB@,$POW_LIB,;t t
14751 + s,@CXXCPP@,$CXXCPP,;t t
14752 + s,@__func__@,$__func__,;t t
14753   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14754   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14755   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11915 | Line 14774 | s,@SUBDIRS@,$SUBDIRS,;t t
14774   s,@OOPSE@,$OOPSE,;t t
14775   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14776   s,@SUBDIRS@,$SUBDIRS,;t t
11918 s,@FFLAGS@,$FFLAGS,;t t
14777   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14778   CEOF
14779  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines