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

Comparing trunk/OOPSE-3.0/configure (file contents):
Revision 2518 by tim, Fri Dec 16 21:52:50 2005 UTC vs.
Revision 2567 by gezelter, Mon Jan 16 15:26:55 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_VERSION='2.0'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX CPP EGREP OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CXXCPP LIBOBJS __func__ INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
764 ac_env_LDFLAGS_set=${LDFLAGS+set}
765 ac_env_LDFLAGS_value=$LDFLAGS
766 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 ac_cv_env_LDFLAGS_value=$LDFLAGS
768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 ac_env_CPPFLAGS_value=$CPPFLAGS
770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_env_CPP_set=${CPP+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}
767 + ac_cv_env_LDFLAGS_value=$LDFLAGS
768 + ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 + ac_env_CPPFLAGS_value=$CPPFLAGS
770 + ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 + ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 + ac_env_CC_set=${CC+set}
773 + ac_env_CC_value=$CC
774 + ac_cv_env_CC_set=${CC+set}
775 + ac_cv_env_CC_value=$CC
776 + ac_env_CFLAGS_set=${CFLAGS+set}
777 + ac_env_CFLAGS_value=$CFLAGS
778 + ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 + ac_cv_env_CFLAGS_value=$CFLAGS
780 + ac_env_FC_set=${FC+set}
781 + ac_env_FC_value=$FC
782 + ac_cv_env_FC_set=${FC+set}
783 + ac_cv_env_FC_value=$FC
784 + ac_env_FCFLAGS_set=${FCFLAGS+set}
785 + ac_env_FCFLAGS_value=$FCFLAGS
786 + ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 + ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 ac_env_F90_set=${F90+set}
785 ac_env_F90_value=$F90
786 ac_cv_env_F90_set=${F90+set}
787 ac_cv_env_F90_value=$F90
788 ac_env_F90FLAGS_set=${F90FLAGS+set}
789 ac_env_F90FLAGS_value=$F90FLAGS
790 ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884    --with-zlib=DIR root directory path of zlib installation defaults to
885                      /usr/local or /usr if not found in /usr/local
886    --without-zlib to disable zlib usage completely
885  --with-perl-shebang     override what perl thinks is the way for the kernel
886                          to start it (seldom needed)
887    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
888    --with-cgal-makefile=FILE  CGAL makefile that should be used
889  
890   Some influential environment variables:
891 <  CC          C compiler command
892 <  CFLAGS      C compiler flags
891 >  CXX         C++ compiler command
892 >  CXXFLAGS    C++ compiler flags
893    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
894                nonstandard directory <lib dir>
895    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
896                headers in a nonstandard directory <include dir>
897 <  CXX         C++ compiler command
898 <  CXXFLAGS    C++ compiler flags
897 >  CC          C compiler command
898 >  CFLAGS      C compiler flags
899 >  FC          Fortran compiler command
900 >  FCFLAGS     Fortran compiler flags
901    CPP         C preprocessor
900  F90         Fortran 90 compiler command
901  F90FLAGS    Fortran 90 compiler flags
902    CXXCPP      C++ preprocessor
903  
904   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1000 | OOPSE configure 2.0
1000   test -n "$ac_init_help" && exit 0
1001   if $ac_init_version; then
1002    cat <<\_ACEOF
1003 < OOPSE configure 2.0
1003 > OOPSE configure 3.0
1004   generated by GNU Autoconf 2.59
1005  
1006   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1014 | It was created by OOPSE $as_me 2.0, which was
1014   This file contains any messages produced by compilers while
1015   running configure, to aid debugging if configure makes a mistake.
1016  
1017 < It was created by OOPSE $as_me 2.0, which was
1017 > It was created by OOPSE $as_me 3.0, which was
1018   generated by GNU Autoconf 2.59.  Invocation command line was
1019  
1020    $ $0 $@
# Line 1374 | Line 1374 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1374   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1375   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1376   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1377
1378
1379 # This file is part of Autoconf.                       -*- Autoconf -*-
1380 # Programming languages support.
1381 # Copyright 2000, 2001
1382 # Free Software Foundation, Inc.
1383 #
1384 # This program is free software; you can redistribute it and/or modify
1385 # it under the terms of the GNU General Public License as published by
1386 # the Free Software Foundation; either version 2, or (at your option)
1387 # any later version.
1388 #
1389 # This program is distributed in the hope that it will be useful,
1390 # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 # GNU General Public License for more details.
1393 #
1394 # You should have received a copy of the GNU General Public License
1395 # along with this program; if not, write to the Free Software
1396 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 # 02111-1307, USA.
1398 #
1399 # As a special exception, the Free Software Foundation gives unlimited
1400 # permission to copy, distribute and modify the configure scripts that
1401 # are the output of Autoconf.  You need not follow the terms of the GNU
1402 # General Public License when using or distributing such scripts, even
1403 # though portions of the text of Autoconf appear in them.  The GNU
1404 # General Public License (GPL) does govern all other use of the material
1405 # that constitutes the Autoconf program.
1406 #
1407 # Certain portions of the Autoconf source text are designed to be copied
1408 # (in certain cases, depending on the input) into the output of
1409 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 # source text consists of comments plus executable code that decides which
1411 # of the data portions to output in any given case.  We call these
1412 # comments and executable code the "non-data" portions.  Autoconf never
1413 # copies any of the non-data portions into its output.
1414 #
1415 # This special exception to the GPL applies to versions of Autoconf
1416 # released by the Free Software Foundation.  When you make and
1417 # distribute a modified version of Autoconf, you may extend this special
1418 # exception to the GPL to apply to your modified version as well, *unless*
1419 # your modified version has the potential to copy into its output some
1420 # of the text that was the non-data portion of the version that you started
1421 # with.  (In other words, unless your change moves or copies text from
1422 # the non-data portions to the data portions.)  If your modification has
1423 # such potential, you must delete any notice of this special exception
1424 # to the GPL from your modified version.
1425 #
1426 # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 # many others).
1428
1429
1430 # Table of Contents:
1431 #
1432 # 1. Language selection
1433 #    and routines to produce programs in a given language.
1434 #  a. Fortran 77 (to be moved from aclang.m4)
1435 #  b. Fortran 90
1436 #  c. Fortran 95
1437 #
1438 # 2. Producing programs in a given language.
1439 #  a. Fortran 77 (to be moved from aclang.m4)
1440 #  b. Fortran 90
1441 #  c. Fortran 95
1442 #
1443 # 3. Looking for a compiler
1444 #    And possibly the associated preprocessor.
1445 #  a. Fortran 77 (to be moved from aclang.m4)
1446 #  b. Fortran 90
1447 #  c. Fortran 95
1448 #
1449 # 4. Compilers' characteristics.
1450 #  a. Fortran 77 (to be moved from aclang.m4)
1451 #  b. Fortran 90
1452 #  c. Fortran 95
1453
1454 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 # ---------------------------------------------------------------------------
1456 #
1457 # Processing the elements of a list is tedious in shell programming,
1458 # as lists tend to be implemented as space delimited strings.
1459 #
1460 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 # if ELEMENT is a member of LIST, otherwise it executes
1462 # ACTION-IF-NOT-FOUND.
1463 # _AC_LIST_MEMBER_IF
1464
1465
1466
1467 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 # -------------------------------------------------
1469 #
1470 # Specifying options to the compiler (whether it be the C, C++ or
1471 # Fortran 77 compiler) that are meant for the linker is compiler
1472 # dependent.  This macro lets you give options to the compiler that
1473 # are meant for the linker in a portable, compiler-independent way.
1474 #
1475 # This macro take two arguments, a list of linker options that the
1476 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 # appended to the shell variable in a compiler-dependent way.
1479 #
1480 # For example, if the selected language is C, then this:
1481 #
1482 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 #
1484 # will expand into this if the selected C compiler is gcc:
1485 #
1486 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 #
1488 # otherwise, it will expand into this:
1489 #
1490 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 #
1492 # You are encouraged to add support for compilers that this macro
1493 # doesn't currently support.
1494 # FIXME: Get rid of this macro.
1495 # _AC_LINKER_OPTION
1496
1497
1498
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1502
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1506
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1509
1510
1511
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1514
1515
1516
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1520
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1523
1524
1525
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1528
1529
1530
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1534
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1538
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1541
1542
1543
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1546
1547
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1550
1551
1552
1553 # ------------------------ #
1554 # 2c. Fortran 95 sources.  #
1555 # ------------------------ #
1556
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1377  
1378  
1379 < # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 < # -----------------------------------------------
1379 >          ac_config_headers="$ac_config_headers src/config.h"
1380  
1381  
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1382  
1383  
1384  
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1385  
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1386  
1387  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1388  
1389  
1390  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1391  
1392  
1393  
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
1394  
1395  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1396  
1397  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1398  
1399  
1400  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1401  
1402  
1403  
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
1404  
1405  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1406  
1407  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1408  
1409  
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
1410  
1411  
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
1412  
1413  
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
1414  
1415  
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
1416  
1717 # The replacement is empty.
1417  
1418  
1419  
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
1420  
1421  
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 # --------------
1422   #
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 # ----------------------
1423   #
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.
1424   #
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
1425  
1426  
1792 # _AC_F95_NAME_MANGLING
1793 # ---------------------
1794 # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 #
1796 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 # by commas:
1798 #
1799 # lower case / upper case:
1800 #    case translation of the Fortan 95 symbols
1801 # underscore / no underscore:
1802 #    whether the compiler appends "_" to symbol names
1803 # extra underscore / no extra underscore:
1804 #    whether the compiler appends an extra "_" to symbol names already
1805 #    containing at least one underscore
1806 #
1807 # _AC_F95_NAME_MANGLING
1808
1809 # The replacement is empty.
1810
1811
1812
1813 # AC_F95_WRAPPERS
1814 # ---------------
1815 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816 # properly mangle the names of C identifiers, and C identifiers with
1817 # underscores, respectively, so that they match the name mangling
1818 # scheme used by the Fortran 95 compiler.
1819 # AC_F95_WRAPPERS
1820
1821
1822 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823 # ------------------------------------
1824 # For a Fortran subroutine of given NAME, define a shell variable
1825 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826 # argument is not supplied, it defaults to NAME.
1827 # AC_F95_FUNC
1828
1427   # AC_F90_MODULE_NAMES
1428   # -------------------
1429   #
# Line 1868 | Line 1466 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1466  
1467  
1468  
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888 #
1889 #
1890 #
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933 # set program name
1934 PROGNAME="oopse"
1935
1936
1937 # there are two ways to do debugging.  One with the --enable-debug flag
1938 # and one using the DEBUG environment variable
1939
1940 debug=0
1941 # Check whether --enable-debug or --disable-debug was given.
1942 if test "${enable_debug+set}" = set; then
1943  enableval="$enable_debug"
1944  debug=1
1945 fi;
1946 if test "${DEBUG}"; then
1947
1948 cat >>confdefs.h <<\_ACEOF
1949 #define debug 1
1950 _ACEOF
1951
1952  msg="$msg, debug mode"
1953 fi
1954
1955
1469   # who am i
1470   # Make sure we can run config.sub.
1471   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 2011 | Line 1524 | ac_ext=c
1524  
1525  
1526  
1527 < ac_ext=c
1528 < ac_cpp='$CPP $CPPFLAGS'
1529 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1530 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1531 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1527 > # set program name
1528 > PROGNAME="oopse"
1529 >
1530 >
1531 >
1532 >
1533 > OBJEXT=".$OBJEXT"
1534 >
1535 > OOPSE=oopse
1536 >
1537 > if test "x${prefix}" = "xNONE"
1538 > then
1539 >  OOPSE_HOME=${ac_default_prefix}/oopse
1540 > else
1541 >  OOPSE_HOME=${prefix}/oopse
1542 > fi
1543 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1544 > if test "${enable_oopse_home+set}" = set; then
1545 >  enableval="$enable_oopse_home"
1546 >  OOPSE_HOME="${enableval}"
1547 > fi;
1548 >
1549 > # there are two ways to do debugging.  One with the --enable-debug flag
1550 > # and one using the DEBUG environment variable
1551 >
1552 > debug=0
1553 > # Check whether --enable-debug or --disable-debug was given.
1554 > if test "${enable_debug+set}" = set; then
1555 >  enableval="$enable_debug"
1556 >  debug=1
1557 > fi;
1558 > if test "${DEBUG}"; then
1559 >
1560 > cat >>confdefs.h <<\_ACEOF
1561 > #define debug 1
1562 > _ACEOF
1563 >
1564 >  msg="$msg, debug mode"
1565 > fi
1566 >
1567 >
1568 > # Checks for programs.
1569 > ac_ext=cc
1570 > ac_cpp='$CXXCPP $CPPFLAGS'
1571 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1572 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1573 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1574   if test -n "$ac_tool_prefix"; then
1575 <  for ac_prog in pathcc icc xlc gcc cc
1575 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1576    do
1577      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1578   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1579   echo "$as_me:$LINENO: checking for $ac_word" >&5
1580   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1581 < if test "${ac_cv_prog_CC+set}" = set; then
1581 > if test "${ac_cv_prog_CXX+set}" = set; then
1582    echo $ECHO_N "(cached) $ECHO_C" >&6
1583   else
1584 <  if test -n "$CC"; then
1585 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1584 >  if test -n "$CXX"; then
1585 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1586   else
1587   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1588   for as_dir in $PATH
# Line 2036 | Line 1591 | do
1591    test -z "$as_dir" && as_dir=.
1592    for ac_exec_ext in '' $ac_executable_extensions; do
1593    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1594 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1594 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1595      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1596      break 2
1597    fi
# Line 2045 | Line 1600 | CC=$ac_cv_prog_CC
1600  
1601   fi
1602   fi
1603 < CC=$ac_cv_prog_CC
1604 < if test -n "$CC"; then
1605 <  echo "$as_me:$LINENO: result: $CC" >&5
1606 < echo "${ECHO_T}$CC" >&6
1603 > CXX=$ac_cv_prog_CXX
1604 > if test -n "$CXX"; then
1605 >  echo "$as_me:$LINENO: result: $CXX" >&5
1606 > echo "${ECHO_T}$CXX" >&6
1607   else
1608    echo "$as_me:$LINENO: result: no" >&5
1609   echo "${ECHO_T}no" >&6
1610   fi
1611  
1612 <    test -n "$CC" && break
1612 >    test -n "$CXX" && break
1613    done
1614   fi
1615 < if test -z "$CC"; then
1616 <  ac_ct_CC=$CC
1617 <  for ac_prog in pathcc icc xlc gcc cc
1615 > if test -z "$CXX"; then
1616 >  ac_ct_CXX=$CXX
1617 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1618   do
1619    # Extract the first word of "$ac_prog", so it can be a program name with args.
1620   set dummy $ac_prog; ac_word=$2
1621   echo "$as_me:$LINENO: checking for $ac_word" >&5
1622   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1623 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1623 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1624    echo $ECHO_N "(cached) $ECHO_C" >&6
1625   else
1626 <  if test -n "$ac_ct_CC"; then
1627 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1626 >  if test -n "$ac_ct_CXX"; then
1627 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1628   else
1629   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1630   for as_dir in $PATH
# Line 2078 | Line 1633 | do
1633    test -z "$as_dir" && as_dir=.
1634    for ac_exec_ext in '' $ac_executable_extensions; do
1635    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1636 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1636 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1637      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1638      break 2
1639    fi
# Line 2087 | Line 1642 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1642  
1643   fi
1644   fi
1645 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1646 < if test -n "$ac_ct_CC"; then
1647 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1648 < echo "${ECHO_T}$ac_ct_CC" >&6
1645 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1646 > if test -n "$ac_ct_CXX"; then
1647 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1648 > echo "${ECHO_T}$ac_ct_CXX" >&6
1649   else
1650    echo "$as_me:$LINENO: result: no" >&5
1651   echo "${ECHO_T}no" >&6
1652   fi
1653  
1654 <  test -n "$ac_ct_CC" && break
1654 >  test -n "$ac_ct_CXX" && break
1655   done
1656 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1657  
1658 <  CC=$ac_ct_CC
1658 >  CXX=$ac_ct_CXX
1659   fi
1660  
1661  
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
1662   # Provide some information about the compiler.
1663   echo "$as_me:$LINENO:" \
1664 <     "checking for C compiler version" >&5
1664 >     "checking for C++ compiler version" >&5
1665   ac_compiler=`set X $ac_compile; echo $2`
1666   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1667    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2149 | Line 1699 | echo "$as_me:$LINENO: checking for C compiler default
1699   # Try to create an executable without -o first, disregard a.out.
1700   # It will help us diagnose broken compilers, and finding out an intuition
1701   # of exeext.
1702 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1703 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1702 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1703 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1704   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1705   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1706    (eval $ac_link_default) 2>&5
# Line 2193 | Line 1743 | sed 's/^/| /' conftest.$ac_ext >&5
1743    echo "$as_me: failed program was:" >&5
1744   sed 's/^/| /' conftest.$ac_ext >&5
1745  
1746 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1746 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1747   See \`config.log' for more details." >&5
1748 < echo "$as_me: error: C compiler cannot create executables
1748 > echo "$as_me: error: C++ compiler cannot create executables
1749   See \`config.log' for more details." >&2;}
1750     { (exit 77); exit 77; }; }
1751   fi
# Line 2206 | Line 1756 | echo "$as_me:$LINENO: checking whether the C compiler
1756  
1757   # Check the compiler produces executables we can run.  If not, either
1758   # the compiler is broken, or we cross compile.
1759 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1760 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1759 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1760 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1761   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1762   # If not cross compiling, check that we can run a simple program.
1763   if test "$cross_compiling" != yes; then
# Line 2222 | Line 1772 | if test "$cross_compiling" != yes; then
1772      if test "$cross_compiling" = maybe; then
1773          cross_compiling=yes
1774      else
1775 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1775 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1776   If you meant to cross compile, use \`--host'.
1777   See \`config.log' for more details." >&5
1778 < echo "$as_me: error: cannot run C compiled programs.
1778 > echo "$as_me: error: cannot run C++ compiled programs.
1779   If you meant to cross compile, use \`--host'.
1780   See \`config.log' for more details." >&2;}
1781     { (exit 1); exit 1; }; }
# Line 2330 | Line 1880 | echo "$as_me:$LINENO: checking whether we are using th
1880   echo "${ECHO_T}$ac_cv_objext" >&6
1881   OBJEXT=$ac_cv_objext
1882   ac_objext=$OBJEXT
1883 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1884 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1885 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1883 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1884 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1885 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1886    echo $ECHO_N "(cached) $ECHO_C" >&6
1887   else
1888    cat >conftest.$ac_ext <<_ACEOF
# Line 2362 | Line 1912 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1912    cat conftest.err >&5
1913    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1914    (exit $ac_status); } &&
1915 <         { ac_try='test -z "$ac_c_werror_flag"
1915 >         { ac_try='test -z "$ac_cxx_werror_flag"
1916                           || test ! -s conftest.err'
1917    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1918    (eval $ac_try) 2>&5
# Line 2383 | Line 1933 | ac_cv_c_compiler_gnu=$ac_compiler_gnu
1933   ac_compiler_gnu=no
1934   fi
1935   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1936 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
1936 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1937  
1938   fi
1939 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1940 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1941 < GCC=`test $ac_compiler_gnu = yes && echo yes`
1942 < ac_test_CFLAGS=${CFLAGS+set}
1943 < ac_save_CFLAGS=$CFLAGS
1944 < CFLAGS="-g"
1945 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1946 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1947 < if test "${ac_cv_prog_cc_g+set}" = set; then
1939 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1940 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1941 > GXX=`test $ac_compiler_gnu = yes && echo yes`
1942 > ac_test_CXXFLAGS=${CXXFLAGS+set}
1943 > ac_save_CXXFLAGS=$CXXFLAGS
1944 > CXXFLAGS="-g"
1945 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1946 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1947 > if test "${ac_cv_prog_cxx_g+set}" = set; then
1948    echo $ECHO_N "(cached) $ECHO_C" >&6
1949   else
1950    cat >conftest.$ac_ext <<_ACEOF
# Line 2421 | Line 1971 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1971    cat conftest.err >&5
1972    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973    (exit $ac_status); } &&
1974 <         { ac_try='test -z "$ac_c_werror_flag"
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
# Line 2434 | Line 1984 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1984    ac_status=$?
1985    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986    (exit $ac_status); }; }; then
1987 <  ac_cv_prog_cc_g=yes
1987 >  ac_cv_prog_cxx_g=yes
1988   else
1989    echo "$as_me: failed program was:" >&5
1990   sed 's/^/| /' conftest.$ac_ext >&5
1991  
1992 < ac_cv_prog_cc_g=no
1992 > ac_cv_prog_cxx_g=no
1993   fi
1994   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995   fi
1996 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
1997 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
1998 < if test "$ac_test_CFLAGS" = set; then
1999 <  CFLAGS=$ac_save_CFLAGS
2000 < elif test $ac_cv_prog_cc_g = yes; then
2001 <  if test "$GCC" = yes; then
2002 <    CFLAGS="-g -O2"
1996 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
1997 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
1998 > if test "$ac_test_CXXFLAGS" = set; then
1999 >  CXXFLAGS=$ac_save_CXXFLAGS
2000 > elif test $ac_cv_prog_cxx_g = yes; then
2001 >  if test "$GXX" = yes; then
2002 >    CXXFLAGS="-g -O2"
2003    else
2004 <    CFLAGS="-g"
2004 >    CXXFLAGS="-g"
2005    fi
2006   else
2007 <  if test "$GCC" = yes; then
2008 <    CFLAGS="-O2"
2007 >  if test "$GXX" = yes; then
2008 >    CXXFLAGS="-O2"
2009    else
2010 <    CFLAGS=
2010 >    CXXFLAGS=
2011    fi
2012   fi
2013 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2464 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2465 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2466 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2467 < else
2468 <  ac_cv_prog_cc_stdc=no
2469 < ac_save_CC=$CC
2470 < cat >conftest.$ac_ext <<_ACEOF
2471 < /* confdefs.h.  */
2472 < _ACEOF
2473 < cat confdefs.h >>conftest.$ac_ext
2474 < cat >>conftest.$ac_ext <<_ACEOF
2475 < /* end confdefs.h.  */
2476 < #include <stdarg.h>
2477 < #include <stdio.h>
2478 < #include <sys/types.h>
2479 < #include <sys/stat.h>
2480 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2481 < struct buf { int x; };
2482 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2483 < static char *e (p, i)
2484 <     char **p;
2485 <     int i;
2486 < {
2487 <  return p[i];
2488 < }
2489 < static char *f (char * (*g) (char **, int), char **p, ...)
2490 < {
2491 <  char *s;
2492 <  va_list v;
2493 <  va_start (v,p);
2494 <  s = g (p, va_arg (v,int));
2495 <  va_end (v);
2496 <  return s;
2497 < }
2498 <
2499 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2500 <   function prototypes and stuff, but not '\xHH' hex character constants.
2501 <   These don't provoke an error unfortunately, instead are silently treated
2502 <   as 'x'.  The following induces an error, until -std1 is added to get
2503 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2504 <   array size at least.  It's necessary to write '\x00'==0 to get something
2505 <   that's true only with -std1.  */
2506 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2507 <
2508 < int test (int i, double x);
2509 < struct s1 {int (*f) (int a);};
2510 < struct s2 {int (*f) (double a);};
2511 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2512 < int argc;
2513 < char **argv;
2514 < int
2515 < main ()
2516 < {
2517 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2518 <  ;
2519 <  return 0;
2520 < }
2521 < _ACEOF
2522 < # Don't try gcc -ansi; that turns off useful extensions and
2523 < # breaks some systems' header files.
2524 < # AIX                   -qlanglvl=ansi
2525 < # Ultrix and OSF/1      -std1
2526 < # HP-UX 10.20 and later -Ae
2527 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2528 < # SVR4                  -Xc -D__EXTENSIONS__
2529 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2530 < do
2531 <  CC="$ac_save_CC $ac_arg"
2532 <  rm -f conftest.$ac_objext
2533 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2534 <  (eval $ac_compile) 2>conftest.er1
2535 <  ac_status=$?
2536 <  grep -v '^ *+' conftest.er1 >conftest.err
2537 <  rm -f conftest.er1
2538 <  cat conftest.err >&5
2539 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2540 <  (exit $ac_status); } &&
2541 <         { ac_try='test -z "$ac_c_werror_flag"
2542 <                         || test ! -s conftest.err'
2543 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2544 <  (eval $ac_try) 2>&5
2545 <  ac_status=$?
2546 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547 <  (exit $ac_status); }; } &&
2548 <         { ac_try='test -s conftest.$ac_objext'
2549 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2550 <  (eval $ac_try) 2>&5
2551 <  ac_status=$?
2552 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2553 <  (exit $ac_status); }; }; then
2554 <  ac_cv_prog_cc_stdc=$ac_arg
2555 < break
2556 < else
2557 <  echo "$as_me: failed program was:" >&5
2558 < sed 's/^/| /' conftest.$ac_ext >&5
2559 <
2560 < fi
2561 < rm -f conftest.err conftest.$ac_objext
2562 < done
2563 < rm -f conftest.$ac_ext conftest.$ac_objext
2564 < CC=$ac_save_CC
2565 <
2566 < fi
2567 <
2568 < case "x$ac_cv_prog_cc_stdc" in
2569 <  x|xno)
2570 <    echo "$as_me:$LINENO: result: none needed" >&5
2571 < echo "${ECHO_T}none needed" >&6 ;;
2572 <  *)
2573 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2574 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2575 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2576 < esac
2577 <
2578 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2579 < # in C++ we need to declare it.  In case someone uses the same compiler
2580 < # for both compiling C and C++ we need to have the C++ compiler decide
2581 < # the declaration of exit, since it's the most demanding environment.
2582 < cat >conftest.$ac_ext <<_ACEOF
2583 < #ifndef __cplusplus
2584 <  choke me
2585 < #endif
2586 < _ACEOF
2587 < rm -f conftest.$ac_objext
2588 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2589 <  (eval $ac_compile) 2>conftest.er1
2590 <  ac_status=$?
2591 <  grep -v '^ *+' conftest.er1 >conftest.err
2592 <  rm -f conftest.er1
2593 <  cat conftest.err >&5
2594 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2595 <  (exit $ac_status); } &&
2596 <         { ac_try='test -z "$ac_c_werror_flag"
2597 <                         || test ! -s conftest.err'
2598 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2599 <  (eval $ac_try) 2>&5
2600 <  ac_status=$?
2601 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2602 <  (exit $ac_status); }; } &&
2603 <         { ac_try='test -s conftest.$ac_objext'
2604 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2605 <  (eval $ac_try) 2>&5
2606 <  ac_status=$?
2607 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2608 <  (exit $ac_status); }; }; then
2609 <  for ac_declaration in \
2013 > for ac_declaration in \
2014     '' \
2015     'extern "C" void std::exit (int) throw (); using std::exit;' \
2016     'extern "C" void std::exit (int); using std::exit;' \
# Line 2639 | Line 2043 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2043    cat conftest.err >&5
2044    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045    (exit $ac_status); } &&
2046 <         { ac_try='test -z "$ac_c_werror_flag"
2046 >         { ac_try='test -z "$ac_cxx_werror_flag"
2047                           || test ! -s conftest.err'
2048    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2049    (eval $ac_try) 2>&5
# Line 2684 | Line 2088 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2088    cat conftest.err >&5
2089    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2090    (exit $ac_status); } &&
2091 <         { ac_try='test -z "$ac_c_werror_flag"
2091 >         { ac_try='test -z "$ac_cxx_werror_flag"
2092                           || test ! -s conftest.err'
2093    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2094    (eval $ac_try) 2>&5
# Line 2712 | Line 2116 | else
2116    echo '#endif'             >>confdefs.h
2117   fi
2118  
2715 else
2716  echo "$as_me: failed program was:" >&5
2717 sed 's/^/| /' conftest.$ac_ext >&5
2718
2719 fi
2720 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2119   ac_ext=c
2120   ac_cpp='$CPP $CPPFLAGS'
2121   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2122   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2123   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2124  
2125 <
2126 < ac_ext=cc
2127 < ac_cpp='$CXXCPP $CPPFLAGS'
2128 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2129 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2732 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2125 > ac_ext=c
2126 > ac_cpp='$CPP $CPPFLAGS'
2127 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2128 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2129 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2130   if test -n "$ac_tool_prefix"; then
2131 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2131 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2132    do
2133      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2134   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2135   echo "$as_me:$LINENO: checking for $ac_word" >&5
2136   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2137 < if test "${ac_cv_prog_CXX+set}" = set; then
2137 > if test "${ac_cv_prog_CC+set}" = set; then
2138    echo $ECHO_N "(cached) $ECHO_C" >&6
2139   else
2140 <  if test -n "$CXX"; then
2141 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2140 >  if test -n "$CC"; then
2141 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2142   else
2143   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2144   for as_dir in $PATH
# Line 2750 | Line 2147 | do
2147    test -z "$as_dir" && as_dir=.
2148    for ac_exec_ext in '' $ac_executable_extensions; do
2149    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2150 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2150 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2151      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2152      break 2
2153    fi
# Line 2759 | Line 2156 | CXX=$ac_cv_prog_CXX
2156  
2157   fi
2158   fi
2159 < CXX=$ac_cv_prog_CXX
2160 < if test -n "$CXX"; then
2161 <  echo "$as_me:$LINENO: result: $CXX" >&5
2162 < echo "${ECHO_T}$CXX" >&6
2159 > CC=$ac_cv_prog_CC
2160 > if test -n "$CC"; then
2161 >  echo "$as_me:$LINENO: result: $CC" >&5
2162 > echo "${ECHO_T}$CC" >&6
2163   else
2164    echo "$as_me:$LINENO: result: no" >&5
2165   echo "${ECHO_T}no" >&6
2166   fi
2167  
2168 <    test -n "$CXX" && break
2168 >    test -n "$CC" && break
2169    done
2170   fi
2171 < if test -z "$CXX"; then
2172 <  ac_ct_CXX=$CXX
2173 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2171 > if test -z "$CC"; then
2172 >  ac_ct_CC=$CC
2173 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2174   do
2175    # Extract the first word of "$ac_prog", so it can be a program name with args.
2176   set dummy $ac_prog; ac_word=$2
2177   echo "$as_me:$LINENO: checking for $ac_word" >&5
2178   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2179 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2179 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2180    echo $ECHO_N "(cached) $ECHO_C" >&6
2181   else
2182 <  if test -n "$ac_ct_CXX"; then
2183 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2182 >  if test -n "$ac_ct_CC"; then
2183 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2184   else
2185   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2186   for as_dir in $PATH
# Line 2792 | Line 2189 | do
2189    test -z "$as_dir" && as_dir=.
2190    for ac_exec_ext in '' $ac_executable_extensions; do
2191    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2192 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2192 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2193      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2194      break 2
2195    fi
# Line 2801 | Line 2198 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2198  
2199   fi
2200   fi
2201 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2202 < if test -n "$ac_ct_CXX"; then
2203 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2204 < echo "${ECHO_T}$ac_ct_CXX" >&6
2201 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2202 > if test -n "$ac_ct_CC"; then
2203 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2204 > echo "${ECHO_T}$ac_ct_CC" >&6
2205   else
2206    echo "$as_me:$LINENO: result: no" >&5
2207   echo "${ECHO_T}no" >&6
2208   fi
2209  
2210 <  test -n "$ac_ct_CXX" && break
2210 >  test -n "$ac_ct_CC" && break
2211   done
2815 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2212  
2213 <  CXX=$ac_ct_CXX
2213 >  CC=$ac_ct_CC
2214   fi
2215  
2216  
2217 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2218 + See \`config.log' for more details." >&5
2219 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2220 + See \`config.log' for more details." >&2;}
2221 +   { (exit 1); exit 1; }; }
2222 +
2223   # Provide some information about the compiler.
2224   echo "$as_me:$LINENO:" \
2225 <     "checking for C++ compiler version" >&5
2225 >     "checking for C compiler version" >&5
2226   ac_compiler=`set X $ac_compile; echo $2`
2227   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2228    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2838 | Line 2240 | echo "$as_me:$LINENO: checking whether we are using th
2240    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2241    (exit $ac_status); }
2242  
2243 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2244 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2245 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2243 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2244 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2245 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2246    echo $ECHO_N "(cached) $ECHO_C" >&6
2247   else
2248    cat >conftest.$ac_ext <<_ACEOF
# Line 2870 | Line 2272 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2272    cat conftest.err >&5
2273    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2274    (exit $ac_status); } &&
2275 <         { ac_try='test -z "$ac_cxx_werror_flag"
2275 >         { ac_try='test -z "$ac_c_werror_flag"
2276                           || test ! -s conftest.err'
2277    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2278    (eval $ac_try) 2>&5
# Line 2891 | Line 2293 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2293   ac_compiler_gnu=no
2294   fi
2295   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2296 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2296 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2297  
2298   fi
2299 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2300 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2301 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2302 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2303 < ac_save_CXXFLAGS=$CXXFLAGS
2304 < CXXFLAGS="-g"
2305 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2306 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2307 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2299 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2300 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2301 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2302 > ac_test_CFLAGS=${CFLAGS+set}
2303 > ac_save_CFLAGS=$CFLAGS
2304 > CFLAGS="-g"
2305 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2306 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2307 > if test "${ac_cv_prog_cc_g+set}" = set; then
2308    echo $ECHO_N "(cached) $ECHO_C" >&6
2309   else
2310    cat >conftest.$ac_ext <<_ACEOF
# Line 2929 | Line 2331 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2331    cat conftest.err >&5
2332    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2333    (exit $ac_status); } &&
2334 <         { ac_try='test -z "$ac_cxx_werror_flag"
2334 >         { ac_try='test -z "$ac_c_werror_flag"
2335                           || test ! -s conftest.err'
2336    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2337    (eval $ac_try) 2>&5
# Line 2942 | Line 2344 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2344    ac_status=$?
2345    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2346    (exit $ac_status); }; }; then
2347 <  ac_cv_prog_cxx_g=yes
2347 >  ac_cv_prog_cc_g=yes
2348   else
2349    echo "$as_me: failed program was:" >&5
2350   sed 's/^/| /' conftest.$ac_ext >&5
2351  
2352 < ac_cv_prog_cxx_g=no
2352 > ac_cv_prog_cc_g=no
2353   fi
2354   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2355   fi
2356 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2357 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2358 < if test "$ac_test_CXXFLAGS" = set; then
2359 <  CXXFLAGS=$ac_save_CXXFLAGS
2360 < elif test $ac_cv_prog_cxx_g = yes; then
2361 <  if test "$GXX" = yes; then
2362 <    CXXFLAGS="-g -O2"
2356 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2357 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2358 > if test "$ac_test_CFLAGS" = set; then
2359 >  CFLAGS=$ac_save_CFLAGS
2360 > elif test $ac_cv_prog_cc_g = yes; then
2361 >  if test "$GCC" = yes; then
2362 >    CFLAGS="-g -O2"
2363    else
2364 <    CXXFLAGS="-g"
2364 >    CFLAGS="-g"
2365    fi
2366   else
2367 <  if test "$GXX" = yes; then
2368 <    CXXFLAGS="-O2"
2367 >  if test "$GCC" = yes; then
2368 >    CFLAGS="-O2"
2369    else
2370 <    CXXFLAGS=
2370 >    CFLAGS=
2371    fi
2372   fi
2373 < for ac_declaration in \
2373 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2374 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2375 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2376 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2377 > else
2378 >  ac_cv_prog_cc_stdc=no
2379 > ac_save_CC=$CC
2380 > cat >conftest.$ac_ext <<_ACEOF
2381 > /* confdefs.h.  */
2382 > _ACEOF
2383 > cat confdefs.h >>conftest.$ac_ext
2384 > cat >>conftest.$ac_ext <<_ACEOF
2385 > /* end confdefs.h.  */
2386 > #include <stdarg.h>
2387 > #include <stdio.h>
2388 > #include <sys/types.h>
2389 > #include <sys/stat.h>
2390 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2391 > struct buf { int x; };
2392 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2393 > static char *e (p, i)
2394 >     char **p;
2395 >     int i;
2396 > {
2397 >  return p[i];
2398 > }
2399 > static char *f (char * (*g) (char **, int), char **p, ...)
2400 > {
2401 >  char *s;
2402 >  va_list v;
2403 >  va_start (v,p);
2404 >  s = g (p, va_arg (v,int));
2405 >  va_end (v);
2406 >  return s;
2407 > }
2408 >
2409 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2410 >   function prototypes and stuff, but not '\xHH' hex character constants.
2411 >   These don't provoke an error unfortunately, instead are silently treated
2412 >   as 'x'.  The following induces an error, until -std1 is added to get
2413 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2414 >   array size at least.  It's necessary to write '\x00'==0 to get something
2415 >   that's true only with -std1.  */
2416 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2417 >
2418 > int test (int i, double x);
2419 > struct s1 {int (*f) (int a);};
2420 > struct s2 {int (*f) (double a);};
2421 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2422 > int argc;
2423 > char **argv;
2424 > int
2425 > main ()
2426 > {
2427 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2428 >  ;
2429 >  return 0;
2430 > }
2431 > _ACEOF
2432 > # Don't try gcc -ansi; that turns off useful extensions and
2433 > # breaks some systems' header files.
2434 > # AIX                   -qlanglvl=ansi
2435 > # Ultrix and OSF/1      -std1
2436 > # HP-UX 10.20 and later -Ae
2437 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2438 > # SVR4                  -Xc -D__EXTENSIONS__
2439 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2440 > do
2441 >  CC="$ac_save_CC $ac_arg"
2442 >  rm -f conftest.$ac_objext
2443 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2444 >  (eval $ac_compile) 2>conftest.er1
2445 >  ac_status=$?
2446 >  grep -v '^ *+' conftest.er1 >conftest.err
2447 >  rm -f conftest.er1
2448 >  cat conftest.err >&5
2449 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2450 >  (exit $ac_status); } &&
2451 >         { ac_try='test -z "$ac_c_werror_flag"
2452 >                         || test ! -s conftest.err'
2453 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2454 >  (eval $ac_try) 2>&5
2455 >  ac_status=$?
2456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2457 >  (exit $ac_status); }; } &&
2458 >         { ac_try='test -s conftest.$ac_objext'
2459 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2460 >  (eval $ac_try) 2>&5
2461 >  ac_status=$?
2462 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2463 >  (exit $ac_status); }; }; then
2464 >  ac_cv_prog_cc_stdc=$ac_arg
2465 > break
2466 > else
2467 >  echo "$as_me: failed program was:" >&5
2468 > sed 's/^/| /' conftest.$ac_ext >&5
2469 >
2470 > fi
2471 > rm -f conftest.err conftest.$ac_objext
2472 > done
2473 > rm -f conftest.$ac_ext conftest.$ac_objext
2474 > CC=$ac_save_CC
2475 >
2476 > fi
2477 >
2478 > case "x$ac_cv_prog_cc_stdc" in
2479 >  x|xno)
2480 >    echo "$as_me:$LINENO: result: none needed" >&5
2481 > echo "${ECHO_T}none needed" >&6 ;;
2482 >  *)
2483 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2484 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2485 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2486 > esac
2487 >
2488 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2489 > # in C++ we need to declare it.  In case someone uses the same compiler
2490 > # for both compiling C and C++ we need to have the C++ compiler decide
2491 > # the declaration of exit, since it's the most demanding environment.
2492 > cat >conftest.$ac_ext <<_ACEOF
2493 > #ifndef __cplusplus
2494 >  choke me
2495 > #endif
2496 > _ACEOF
2497 > rm -f conftest.$ac_objext
2498 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2499 >  (eval $ac_compile) 2>conftest.er1
2500 >  ac_status=$?
2501 >  grep -v '^ *+' conftest.er1 >conftest.err
2502 >  rm -f conftest.er1
2503 >  cat conftest.err >&5
2504 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2505 >  (exit $ac_status); } &&
2506 >         { ac_try='test -z "$ac_c_werror_flag"
2507 >                         || test ! -s conftest.err'
2508 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2509 >  (eval $ac_try) 2>&5
2510 >  ac_status=$?
2511 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2512 >  (exit $ac_status); }; } &&
2513 >         { ac_try='test -s conftest.$ac_objext'
2514 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2515 >  (eval $ac_try) 2>&5
2516 >  ac_status=$?
2517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2518 >  (exit $ac_status); }; }; then
2519 >  for ac_declaration in \
2520     '' \
2521     'extern "C" void std::exit (int) throw (); using std::exit;' \
2522     'extern "C" void std::exit (int); using std::exit;' \
# Line 3001 | Line 2549 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2549    cat conftest.err >&5
2550    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2551    (exit $ac_status); } &&
2552 <         { ac_try='test -z "$ac_cxx_werror_flag"
2552 >         { ac_try='test -z "$ac_c_werror_flag"
2553                           || test ! -s conftest.err'
2554    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2555    (eval $ac_try) 2>&5
# Line 3046 | Line 2594 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2594    cat conftest.err >&5
2595    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2596    (exit $ac_status); } &&
2597 <         { ac_try='test -z "$ac_cxx_werror_flag"
2597 >         { ac_try='test -z "$ac_c_werror_flag"
2598                           || test ! -s conftest.err'
2599    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2600    (eval $ac_try) 2>&5
# Line 3074 | Line 2622 | ac_ext=c
2622    echo '#endif'             >>confdefs.h
2623   fi
2624  
2625 + else
2626 +  echo "$as_me: failed program was:" >&5
2627 + sed 's/^/| /' conftest.$ac_ext >&5
2628 +
2629 + fi
2630 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2631   ac_ext=c
2632   ac_cpp='$CPP $CPPFLAGS'
2633   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2634   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2635   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2636  
2637 + ac_ext=${FC_SRCEXT-f}
2638 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2639 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2640 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2641 + if test -n "$ac_tool_prefix"; then
2642 +  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2643 +  do
2644 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2645 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2646 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2647 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2648 + if test "${ac_cv_prog_FC+set}" = set; then
2649 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2650 + else
2651 +  if test -n "$FC"; then
2652 +  ac_cv_prog_FC="$FC" # Let the user override the test.
2653 + else
2654 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2655 + for as_dir in $PATH
2656 + do
2657 +  IFS=$as_save_IFS
2658 +  test -z "$as_dir" && as_dir=.
2659 +  for ac_exec_ext in '' $ac_executable_extensions; do
2660 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2661 +    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2662 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2663 +    break 2
2664 +  fi
2665 + done
2666 + done
2667  
2668 + fi
2669 + fi
2670 + FC=$ac_cv_prog_FC
2671 + if test -n "$FC"; then
2672 +  echo "$as_me:$LINENO: result: $FC" >&5
2673 + echo "${ECHO_T}$FC" >&6
2674 + else
2675 +  echo "$as_me:$LINENO: result: no" >&5
2676 + echo "${ECHO_T}no" >&6
2677 + fi
2678 +
2679 +    test -n "$FC" && break
2680 +  done
2681 + fi
2682 + if test -z "$FC"; then
2683 +  ac_ct_FC=$FC
2684 +  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2685 + do
2686 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2687 + set dummy $ac_prog; ac_word=$2
2688 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2689 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2690 + if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2691 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2692 + else
2693 +  if test -n "$ac_ct_FC"; then
2694 +  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2695 + else
2696 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2697 + for as_dir in $PATH
2698 + do
2699 +  IFS=$as_save_IFS
2700 +  test -z "$as_dir" && as_dir=.
2701 +  for ac_exec_ext in '' $ac_executable_extensions; do
2702 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2703 +    ac_cv_prog_ac_ct_FC="$ac_prog"
2704 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2705 +    break 2
2706 +  fi
2707 + done
2708 + done
2709 +
2710 + fi
2711 + fi
2712 + ac_ct_FC=$ac_cv_prog_ac_ct_FC
2713 + if test -n "$ac_ct_FC"; then
2714 +  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2715 + echo "${ECHO_T}$ac_ct_FC" >&6
2716 + else
2717 +  echo "$as_me:$LINENO: result: no" >&5
2718 + echo "${ECHO_T}no" >&6
2719 + fi
2720 +
2721 +  test -n "$ac_ct_FC" && break
2722 + done
2723 +
2724 +  FC=$ac_ct_FC
2725 + fi
2726 +
2727 +
2728 + # Provide some information about the compiler.
2729 + echo "$as_me:2729:" \
2730 +     "checking for Fortran compiler version" >&5
2731 + ac_compiler=`set X $ac_compile; echo $2`
2732 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2733 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2734 +  ac_status=$?
2735 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2736 +  (exit $ac_status); }
2737 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2738 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2739 +  ac_status=$?
2740 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2741 +  (exit $ac_status); }
2742 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2743 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2744 +  ac_status=$?
2745 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2746 +  (exit $ac_status); }
2747 + rm -f a.out
2748 +
2749 + # If we don't use `.F' as extension, the preprocessor is not run on the
2750 + # input file.  (Note that this only needs to work for GNU compilers.)
2751 + ac_save_ext=$ac_ext
2752 + ac_ext=F
2753 + echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2754 + echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2755 + if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2756 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2757 + else
2758 +  cat >conftest.$ac_ext <<_ACEOF
2759 +      program main
2760 + #ifndef __GNUC__
2761 +       choke me
2762 + #endif
2763 +
2764 +      end
2765 + _ACEOF
2766 + rm -f conftest.$ac_objext
2767 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2768 +  (eval $ac_compile) 2>conftest.er1
2769 +  ac_status=$?
2770 +  grep -v '^ *+' conftest.er1 >conftest.err
2771 +  rm -f conftest.er1
2772 +  cat conftest.err >&5
2773 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2774 +  (exit $ac_status); } &&
2775 +         { ac_try='test -z "$ac_fc_werror_flag"
2776 +                         || test ! -s conftest.err'
2777 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2778 +  (eval $ac_try) 2>&5
2779 +  ac_status=$?
2780 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2781 +  (exit $ac_status); }; } &&
2782 +         { ac_try='test -s conftest.$ac_objext'
2783 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2784 +  (eval $ac_try) 2>&5
2785 +  ac_status=$?
2786 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2787 +  (exit $ac_status); }; }; then
2788 +  ac_compiler_gnu=yes
2789 + else
2790 +  echo "$as_me: failed program was:" >&5
2791 + sed 's/^/| /' conftest.$ac_ext >&5
2792 +
2793 + ac_compiler_gnu=no
2794 + fi
2795 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2796 + ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2797 +
2798 + fi
2799 + echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2800 + echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2801 + ac_ext=$ac_save_ext
2802 + ac_test_FFLAGS=${FCFLAGS+set}
2803 + ac_save_FFLAGS=$FCFLAGS
2804 + FCFLAGS=
2805 + echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2806 + echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2807 + if test "${ac_cv_prog_fc_g+set}" = set; then
2808 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2809 + else
2810 +  FCFLAGS=-g
2811 + cat >conftest.$ac_ext <<_ACEOF
2812 +      program main
2813 +
2814 +      end
2815 + _ACEOF
2816 + rm -f conftest.$ac_objext
2817 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2818 +  (eval $ac_compile) 2>conftest.er1
2819 +  ac_status=$?
2820 +  grep -v '^ *+' conftest.er1 >conftest.err
2821 +  rm -f conftest.er1
2822 +  cat conftest.err >&5
2823 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2824 +  (exit $ac_status); } &&
2825 +         { ac_try='test -z "$ac_fc_werror_flag"
2826 +                         || test ! -s conftest.err'
2827 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2828 +  (eval $ac_try) 2>&5
2829 +  ac_status=$?
2830 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2831 +  (exit $ac_status); }; } &&
2832 +         { ac_try='test -s conftest.$ac_objext'
2833 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2834 +  (eval $ac_try) 2>&5
2835 +  ac_status=$?
2836 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2837 +  (exit $ac_status); }; }; then
2838 +  ac_cv_prog_fc_g=yes
2839 + else
2840 +  echo "$as_me: failed program was:" >&5
2841 + sed 's/^/| /' conftest.$ac_ext >&5
2842 +
2843 + ac_cv_prog_fc_g=no
2844 + fi
2845 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2846 +
2847 + fi
2848 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2849 + echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2850 + if test "$ac_test_FFLAGS" = set; then
2851 +  FCFLAGS=$ac_save_FFLAGS
2852 + elif test $ac_cv_prog_fc_g = yes; then
2853 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2854 +    FCFLAGS="-g -O2"
2855 +  else
2856 +    FCFLAGS="-g"
2857 +  fi
2858 + else
2859 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2860 +    FCFLAGS="-O2"
2861 +  else
2862 +    FCFLAGS=
2863 +  fi
2864 + fi
2865 +
2866   ac_ext=c
2867   ac_cpp='$CPP $CPPFLAGS'
2868   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2869   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2870   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2871 +
2872 + ac_ext=c
2873 + ac_cpp='$CPP $CPPFLAGS'
2874 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2875 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2876 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2877   echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2878   echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2879   # On Suns, sometimes $CPP names a directory.
# Line 3315 | Line 3103 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3103   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3104   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3105  
3318
3106   echo "$as_me:$LINENO: checking for egrep" >&5
3107   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3108   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3331 | Line 3118 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3118   EGREP=$ac_cv_prog_egrep
3119  
3120  
3121 <
3122 < OOPSE_TEMPLATE_FLAGS=""
3123 < if test $ac_cv_cxx_compiler_gnu = no; then
3124 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3125 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3339 <  echo 'void f(){}' > conftest.cc
3340 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3341 <    echo "$as_me:$LINENO: result: yes" >&5
3121 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3122 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3123 > LN_S=$as_ln_s
3124 > if test "$LN_S" = "ln -s"; then
3125 >  echo "$as_me:$LINENO: result: yes" >&5
3126   echo "${ECHO_T}yes" >&6
3127 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3128 <  else
3129 <    echo "$as_me:$LINENO: result: no" >&5
3130 < echo "${ECHO_T}no" >&6
3131 <  fi
3132 <  rm -f conftest*
3133 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3134 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3135 <  echo 'void f(){}' > conftest.cc
3136 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3137 <    echo "$as_me:$LINENO: result: yes" >&5
3127 > else
3128 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3129 > echo "${ECHO_T}no, using $LN_S" >&6
3130 > fi
3131 >
3132 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3133 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3134 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3135 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3136 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3137 > else
3138 >  cat >conftest.make <<\_ACEOF
3139 > all:
3140 >        @echo 'ac_maketemp="$(MAKE)"'
3141 > _ACEOF
3142 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3143 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3144 > if test -n "$ac_maketemp"; then
3145 >  eval ac_cv_prog_make_${ac_make}_set=yes
3146 > else
3147 >  eval ac_cv_prog_make_${ac_make}_set=no
3148 > fi
3149 > rm -f conftest.make
3150 > fi
3151 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3152 >  echo "$as_me:$LINENO: result: yes" >&5
3153   echo "${ECHO_T}yes" >&6
3154 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3155 <  else
3156 <    echo "$as_me:$LINENO: result: no" >&5
3154 >  SET_MAKE=
3155 > else
3156 >  echo "$as_me:$LINENO: result: no" >&5
3157 > echo "${ECHO_T}no" >&6
3158 >  SET_MAKE="MAKE=${MAKE-make}"
3159 > fi
3160 >
3161 > if test -n "$ac_tool_prefix"; then
3162 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3163 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3164 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3165 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3166 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3167 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3168 > else
3169 >  if test -n "$RANLIB"; then
3170 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3171 > else
3172 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3173 > for as_dir in $PATH
3174 > do
3175 >  IFS=$as_save_IFS
3176 >  test -z "$as_dir" && as_dir=.
3177 >  for ac_exec_ext in '' $ac_executable_extensions; do
3178 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3179 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3180 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3181 >    break 2
3182 >  fi
3183 > done
3184 > done
3185 >
3186 > fi
3187 > fi
3188 > RANLIB=$ac_cv_prog_RANLIB
3189 > if test -n "$RANLIB"; then
3190 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3191 > echo "${ECHO_T}$RANLIB" >&6
3192 > else
3193 >  echo "$as_me:$LINENO: result: no" >&5
3194   echo "${ECHO_T}no" >&6
3195 + fi
3196 +
3197 + fi
3198 + if test -z "$ac_cv_prog_RANLIB"; then
3199 +  ac_ct_RANLIB=$RANLIB
3200 +  # Extract the first word of "ranlib", so it can be a program name with args.
3201 + set dummy ranlib; ac_word=$2
3202 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3203 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3204 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3205 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3206 + else
3207 +  if test -n "$ac_ct_RANLIB"; then
3208 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3209 + else
3210 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3211 + for as_dir in $PATH
3212 + do
3213 +  IFS=$as_save_IFS
3214 +  test -z "$as_dir" && as_dir=.
3215 +  for ac_exec_ext in '' $ac_executable_extensions; do
3216 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3217 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3218 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3219 +    break 2
3220    fi
3221 <  rm -f conftest*
3222 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3223 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3224 <  echo 'void f(){}' > conftest.cc
3225 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3226 <    echo "$as_me:$LINENO: result: yes" >&5
3227 < echo "${ECHO_T}yes" >&6
3228 <    OOPSE_TEMPLATE_FLAGS="-pto"
3229 <  else
3230 <    echo "$as_me:$LINENO: result: no" >&5
3221 > done
3222 > done
3223 >
3224 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3225 > fi
3226 > fi
3227 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3228 > if test -n "$ac_ct_RANLIB"; then
3229 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3230 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3231 > else
3232 >  echo "$as_me:$LINENO: result: no" >&5
3233   echo "${ECHO_T}no" >&6
3234 + fi
3235 +
3236 +  RANLIB=$ac_ct_RANLIB
3237 + else
3238 +  RANLIB="$ac_cv_prog_RANLIB"
3239 + fi
3240 +
3241 +
3242 +   # Extract the first word of "perl", so it can be a program name with args.
3243 + set dummy perl; ac_word=$2
3244 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3245 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3246 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3247 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3248 + else
3249 +  case $PERLINTERP in
3250 +  [\\/]* | ?:[\\/]*)
3251 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3252 +  ;;
3253 +  *)
3254 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3255 + for as_dir in $PATH
3256 + do
3257 +  IFS=$as_save_IFS
3258 +  test -z "$as_dir" && as_dir=.
3259 +  for ac_exec_ext in '' $ac_executable_extensions; do
3260 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3261 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3262 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3263 +    break 2
3264    fi
3265 <  rm -f conftest*
3266 <  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
3265 > done
3266 > done
3267  
3268 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3269 +  ;;
3270 + esac
3271 + fi
3272 + PERLINTERP=$ac_cv_path_PERLINTERP
3273  
3274 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3275 <  else
3276 <    echo "$as_me:$LINENO: result: no" >&5
3274 > if test -n "$PERLINTERP"; then
3275 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3276 > echo "${ECHO_T}$PERLINTERP" >&6
3277 > else
3278 >  echo "$as_me:$LINENO: result: no" >&5
3279   echo "${ECHO_T}no" >&6
3280 + fi
3281 +
3282 +   ac_cv_path_perlinterp="$PERLINTERP"
3283 +   _sHpB='#!'
3284 +
3285 +
3286 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3287 + if test "${with_perl_shebang+set}" = set; then
3288 +  withval="$with_perl_shebang"
3289 +  opt_perl_shebang="$withval"
3290 + else
3291 +                opt_perl_shebang="not_set"
3292 + fi;
3293 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3294 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3295 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3296 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3297 + else
3298 +   case "$opt_perl_shebang" in
3299 +                      not_set  ) ax_cv_opt_perl_shebang=''
3300 +                               ;;
3301 +                         *     )
3302 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3303 +                    esac
3304 +
3305 + fi
3306 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3307 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3308 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3309 +     then
3310 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3311 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3312 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3313 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3314 +
3315 + # Automatic detection of sharpbang formula starts here
3316 +     else
3317 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3318 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3319 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3320 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3321 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3322 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3323 + else
3324 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3325 +        if test "x$_somian_kspb_perl" == x
3326 +          then _somian_ksbp_warn_empty='durnit'
3327 +          else
3328 +          case "A$_somian_kspb_perl" in
3329 +                 A#!*perl* )
3330 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3331 +                        ;;
3332 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3333 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3334 +          esac
3335 +        fi
3336 +
3337 + fi
3338 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3339 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3340 + # The above prints Checking ... result message to user.
3341 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3342 +
3343 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3344 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3345 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3346 +    fi
3347 + # Inform user after printing result value
3348 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3349 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3350 + echo "$as_me: Maybe Not good -" >&6;}
3351 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3352 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3353 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3354 + echo "$as_me: OK Good result - " >&6;}
3355 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3356 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3357 +    fi
3358    fi
3359 +
3360 + # Find a good install program.  We prefer a C program (faster),
3361 + # so one script is as good as another.  But avoid the broken or
3362 + # incompatible versions:
3363 + # SysV /etc/install, /usr/sbin/install
3364 + # SunOS /usr/etc/install
3365 + # IRIX /sbin/install
3366 + # AIX /bin/install
3367 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3368 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3369 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3370 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3371 + # OS/2's system install, which has a completely different semantic
3372 + # ./install, which can be erroneously created by make from ./install.sh.
3373 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3374 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3375 + if test -z "$INSTALL"; then
3376 + if test "${ac_cv_path_install+set}" = set; then
3377 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3378 + else
3379 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3380 + for as_dir in $PATH
3381 + do
3382 +  IFS=$as_save_IFS
3383 +  test -z "$as_dir" && as_dir=.
3384 +  # Account for people who put trailing slashes in PATH elements.
3385 + case $as_dir/ in
3386 +  ./ | .// | /cC/* | \
3387 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3388 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3389 +  /usr/ucb/* ) ;;
3390 +  *)
3391 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3392 +    # Don't use installbsd from OSF since it installs stuff as root
3393 +    # by default.
3394 +    for ac_prog in ginstall scoinst install; do
3395 +      for ac_exec_ext in '' $ac_executable_extensions; do
3396 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3397 +          if test $ac_prog = install &&
3398 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3399 +            # AIX install.  It has an incompatible calling convention.
3400 +            :
3401 +          elif test $ac_prog = install &&
3402 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3403 +            # program-specific install script used by HP pwplus--don't use.
3404 +            :
3405 +          else
3406 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3407 +            break 3
3408 +          fi
3409 +        fi
3410 +      done
3411 +    done
3412 +    ;;
3413 + esac
3414 + done
3415 +
3416 +
3417   fi
3418 +  if test "${ac_cv_path_install+set}" = set; then
3419 +    INSTALL=$ac_cv_path_install
3420 +  else
3421 +    # As a last resort, use the slow shell script.  We don't cache a
3422 +    # path for INSTALL within a source directory, because that will
3423 +    # break other packages using the cache if that directory is
3424 +    # removed, or if the path is relative.
3425 +    INSTALL=$ac_install_sh
3426 +  fi
3427 + fi
3428 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3429 + echo "${ECHO_T}$INSTALL" >&6
3430  
3431 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3432 + # It thinks the first close brace ends the variable substitution.
3433 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3434  
3435 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3436  
3437 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3438  
3439 < ac_ext=f90
3440 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3441 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3442 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3443 < if test -n "$ac_tool_prefix"; then
3444 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3445 <  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
3439 > case "x$INSTALL" in
3440 >   x/*) ;;
3441 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3442 > esac
3443 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3444 > # Extract the first word of "ar", so it can be a program name with args.
3445 > set dummy ar; ac_word=$2
3446   echo "$as_me:$LINENO: checking for $ac_word" >&5
3447   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3448 < if test "${ac_cv_prog_F90+set}" = set; then
3448 > if test "${ac_cv_prog_AR+set}" = set; then
3449    echo $ECHO_N "(cached) $ECHO_C" >&6
3450   else
3451 <  if test -n "$F90"; then
3452 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3451 >  if test -n "$AR"; then
3452 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3453   else
3454   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3455   for as_dir in $PATH
# Line 3412 | Line 3458 | do
3458    test -z "$as_dir" && as_dir=.
3459    for ac_exec_ext in '' $ac_executable_extensions; do
3460    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3461 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3461 >    ac_cv_prog_AR="ar"
3462      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3463      break 2
3464    fi
3465   done
3466   done
3467  
3468 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3469   fi
3470   fi
3471 < F90=$ac_cv_prog_F90
3472 < if test -n "$F90"; then
3473 <  echo "$as_me:$LINENO: result: $F90" >&5
3474 < echo "${ECHO_T}$F90" >&6
3471 > AR=$ac_cv_prog_AR
3472 > if test -n "$AR"; then
3473 >  echo "$as_me:$LINENO: result: $AR" >&5
3474 > echo "${ECHO_T}$AR" >&6
3475   else
3476    echo "$as_me:$LINENO: result: no" >&5
3477   echo "${ECHO_T}no" >&6
3478   fi
3479  
3480 <    test -n "$F90" && break
3481 <  done
3480 > if test "$AR" = "NONE"; then
3481 >  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3482 > echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3483 >   { (exit 1); exit 1; }; }
3484 >  cat >confcache <<\_ACEOF
3485 > # This file is a shell script that caches the results of configure
3486 > # tests run on this system so they can be shared between configure
3487 > # scripts and configure runs, see configure's option --config-cache.
3488 > # It is not useful on other systems.  If it contains results you don't
3489 > # want to keep, you may remove or edit it.
3490 > #
3491 > # config.status only pays attention to the cache file if you give it
3492 > # the --recheck option to rerun configure.
3493 > #
3494 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3495 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3496 > # following values.
3497 >
3498 > _ACEOF
3499 >
3500 > # The following way of writing the cache mishandles newlines in values,
3501 > # but we know of no workaround that is simple, portable, and efficient.
3502 > # So, don't put newlines in cache variables' values.
3503 > # Ultrix sh set writes to stderr and can't be redirected directly,
3504 > # and sets the high bit in the cache file unless we assign to the vars.
3505 > {
3506 >  (set) 2>&1 |
3507 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3508 >    *ac_space=\ *)
3509 >      # `set' does not quote correctly, so add quotes (double-quote
3510 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3511 >      sed -n \
3512 >        "s/'/'\\\\''/g;
3513 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3514 >      ;;
3515 >    *)
3516 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3517 >      sed -n \
3518 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3519 >      ;;
3520 >    esac;
3521 > } |
3522 >  sed '
3523 >     t clear
3524 >     : clear
3525 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3526 >     t end
3527 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3528 >     : end' >>confcache
3529 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3530 >  if test -w $cache_file; then
3531 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3532 >    cat confcache >$cache_file
3533 >  else
3534 >    echo "not updating unwritable cache $cache_file"
3535 >  fi
3536   fi
3537 < if test -z "$F90"; then
3538 <  ac_ct_F90=$F90
3539 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3540 < do
3541 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3441 < set dummy $ac_prog; ac_word=$2
3537 > rm -f confcache
3538 >  exit 1
3539 > fi
3540 > # Extract the first word of "ps", so it can be a program name with args.
3541 > set dummy ps; ac_word=$2
3542   echo "$as_me:$LINENO: checking for $ac_word" >&5
3543   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3544 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3544 > if test "${ac_cv_path_PS+set}" = set; then
3545    echo $ECHO_N "(cached) $ECHO_C" >&6
3546   else
3547 <  if test -n "$ac_ct_F90"; then
3548 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3549 < else
3550 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3547 >  case $PS in
3548 >  [\\/]* | ?:[\\/]*)
3549 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3550 >  ;;
3551 >  *)
3552 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3553   for as_dir in $PATH
3554   do
3555    IFS=$as_save_IFS
3556    test -z "$as_dir" && as_dir=.
3557    for ac_exec_ext in '' $ac_executable_extensions; do
3558    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3559 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3559 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3560      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3561      break 2
3562    fi
3563   done
3564   done
3565  
3566 +  ;;
3567 + esac
3568   fi
3569 < fi
3570 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3571 < if test -n "$ac_ct_F90"; then
3572 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3573 < echo "${ECHO_T}$ac_ct_F90" >&6
3569 > PS=$ac_cv_path_PS
3570 >
3571 > if test -n "$PS"; then
3572 >  echo "$as_me:$LINENO: result: $PS" >&5
3573 > echo "${ECHO_T}$PS" >&6
3574   else
3575    echo "$as_me:$LINENO: result: no" >&5
3576   echo "${ECHO_T}no" >&6
3577   fi
3578  
3579 <  test -n "$ac_ct_F90" && break
3580 < done
3579 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3580 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3581 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3582 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3583 > else
3584  
3585 <  F90=$ac_ct_F90
3585 >        if $PS ax -o rss > /dev/null 2>&1; then
3586 >                ac_cv_prog_ps_ax=yes
3587 >        else
3588 >                ac_cv_prog_ps_ax=no
3589 >        fi
3590 >        if $PS -ef -o rss > /dev/null 2>&1; then
3591 >                ac_cv_prog_ps_ef=yes
3592 >        else
3593 >                ac_cv_prog_ps_ef=no
3594 >        fi
3595 >        if test "$ac_cv_prog_ps_ax" = yes; then
3596 >                ac_cv_prog_ps_syntax=BSD
3597 >        else
3598 >                if test "$ac_cv_prog_ps_ef" = yes; then
3599 >                        ac_cv_prog_ps_syntax=POSIX
3600 >                else
3601 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3602 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3603 >   { (exit 1); exit 1; }; }
3604 >                fi
3605 >        fi
3606 >
3607   fi
3608 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3609 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3610  
3611 + cat >>confdefs.h <<_ACEOF
3612 + #define PSCOMMAND $PS
3613 + _ACEOF
3614  
3615 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3616 < # input file.
3617 < ac_save_ext=$ac_ext
3618 < ac_ext=F90
3619 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3620 < 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
3615 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3616 >
3617 > cat >>confdefs.h <<\_ACEOF
3618 > #define PSTYPE_IS_BSD 1
3619 > _ACEOF
3620 >
3621   else
3622 <  cat >conftest.$ac_ext <<_ACEOF
3622 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3623  
3624 < program main
3624 > cat >>confdefs.h <<\_ACEOF
3625 > #define PSTYPE_IS_POSIX 1
3626 > _ACEOF
3627  
3628 < #ifndef __GNUC__
3629 <       choke me
3630 < #endif
3628 >   else
3629 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3630 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3631 >   { (exit 1); exit 1; }; }
3632 >   fi
3633 > fi
3634  
3635 < end program main
3635 > ac_ext=${FC_SRCEXT-f}
3636 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3637 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3638 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3639  
3640 +
3641 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3642 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3643 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3644 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3645 + else
3646 +  ac_ext=F90
3647 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3648 + FCFLAGS_SRCEXT=""
3649 + ac_cv_fc_srcext_F90=unknown
3650 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3651 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3652 +  cat >conftest.$ac_ext <<_ACEOF
3653 +      program main
3654 +
3655 +      end
3656   _ACEOF
3657   rm -f conftest.$ac_objext
3658   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3508 | Line 3663 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3663    cat conftest.err >&5
3664    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3665    (exit $ac_status); } &&
3666 <         { ac_try='test -z "$ac_f90_werror_flag"
3666 >         { ac_try='test -z "$ac_fc_werror_flag"
3667                           || test ! -s conftest.err'
3668    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3669    (eval $ac_try) 2>&5
# Line 3521 | Line 3676 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3676    ac_status=$?
3677    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3678    (exit $ac_status); }; }; then
3679 <  ac_compiler_gnu=yes
3679 >  ac_cv_fc_srcext_F90=$ac_flag; break
3680   else
3681    echo "$as_me: failed program was:" >&5
3682   sed 's/^/| /' conftest.$ac_ext >&5
3683  
3529 ac_compiler_gnu=no
3684   fi
3685   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3686 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3686 > done
3687 > rm -f conftest.$ac_objext conftest.F90
3688 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3689  
3690   fi
3691 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3692 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3693 < ac_ext=$ac_save_ext
3694 < G95=`test $ac_compiler_gnu = yes && echo yes`
3695 < ac_ext=c
3696 < ac_cpp='$CPP $CPPFLAGS'
3697 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3698 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3699 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3691 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3692 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3693 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3694 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3695 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3696 >   { (exit 1); exit 1; }; }
3697 > else
3698 >  FC_SRCEXT=F90
3699 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3700 >    FCFLAGS_SRCEXT=""
3701 >    FCFLAGS_F90=""
3702 >  else
3703 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3704 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3705 >  fi
3706  
3707  
3708 + fi
3709  
3710  
3711  
3712 +
3713 +
3714   # Try to determine native compiler flags that allow us to use F90 suffix
3715   # for preprocessed f90 source.
3716  
# Line 3553 | Line 3718 | if test "$ac_test_PREPFLAG" != "set"; then
3718    PREPFLAG=""
3719    case "${host_cpu}-${host_os}" in
3720  
3721 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3721 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3722                      PREPFLAG="-fpp1 "
3723                  fi;;
3724 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3724 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3725                      PREPFLAG="-qsuffix=cpp=F90 "
3726                  fi;;
3727    *darwin*)
3728 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3728 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3729                  PREPFLAG="-qsuffix=cpp=F90 "
3730          fi;;
3731    esac
# Line 3575 | Line 3740 | echo $ECHO_N "checking to make sure F90 preprocessor f
3740   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3741  
3742  
3743 <  ac_ext=f90
3744 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3745 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3746 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3743 >  ac_ext=${FC_SRCEXT-f}
3744 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3745 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3746 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3747  
3748    ac_save_ext=$ac_ext
3749    ac_ext=F90
3750 <  ac_save_F90FLAGS=$F90FLAGS
3750 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3751  
3752    if test "$PREPFLAG"; then
3753 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3753 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3754   fi
3755  
3756      cat >conftest.$ac_ext <<_ACEOF
3757  
3758  
3759 < program main
3595 <
3759 > program conftest
3760    integer :: i
3761    i = 1
3762 + end program conftest
3763  
3599
3600 end program main
3601
3764   _ACEOF
3765   rm -f conftest.$ac_objext
3766   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3609 | Line 3771 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3771    cat conftest.err >&5
3772    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3773    (exit $ac_status); } &&
3774 <         { ac_try='test -z "$ac_f90_werror_flag"
3774 >         { ac_try='test -z "$ac_fc_werror_flag"
3775                           || test ! -s conftest.err'
3776    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3777    (eval $ac_try) 2>&5
# Line 3631 | Line 3793 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3793   fi
3794   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3795  
3796 <  F90FLAGS=$ac_save_F90FLAGS
3796 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3797    ac_ext=$ac_save_ext
3798 <  ac_ext=c
3799 < ac_cpp='$CPP $CPPFLAGS'
3800 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3801 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3802 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3803 <
3804 <
3643 <  if test "$prepflagworks" = 1; then
3798 >  ac_ext=${FC_SRCEXT-f}
3799 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3800 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3801 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3802 >
3803 >
3804 >  if test "$prepflagworks" = 1; then
3805      echo "$as_me:$LINENO: result: yes" >&5
3806   echo "${ECHO_T}yes" >&6
3807 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3808  
3809    else
3810      echo "$as_me:$LINENO: result: no" >&5
# Line 3664 | Line 3826 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3826    PREPDEFFLAG=""
3827    case "${host_cpu}-${host_os}" in
3828  
3829 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3829 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3830                      PREPDEFFLAG=" "
3831                  fi;;
3832 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3832 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3833                      PREPDEFFLAG="-WF,"
3834                  fi;;
3835    *darwin*)
3836 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3836 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3837                  PREPDEFFLAG="-WF,"
3838          fi;;
3839    esac
# Line 3686 | Line 3848 | echo $ECHO_N "checking to make sure F90 preprocessor d
3848   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3849  
3850  
3851 <  ac_ext=f90
3852 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3853 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3854 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3851 >  ac_ext=${FC_SRCEXT-f}
3852 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3853 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3854 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3855  
3856    ac_save_ext=$ac_ext
3857    ac_ext=F90
3858 <  ac_save_F90FLAGS=$F90FLAGS
3858 >  ac_save_FCFLAGS=$FCFLAGS
3859  
3860    if test "$PREPDEFFLAG"; then
3861 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3861 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3862   fi
3863  
3864      cat >conftest.$ac_ext <<_ACEOF
3865  
3866  
3867 < program main
3706 <
3867 > program conftest
3868    integer :: i
3869   #ifdef TEST
3870    i = 1
3871   #else
3872    choke me
3873   #endif
3874 + end program conftest
3875  
3714
3715 end program main
3716
3876   _ACEOF
3877   rm -f conftest.$ac_objext
3878   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3724 | Line 3883 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3883    cat conftest.err >&5
3884    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3885    (exit $ac_status); } &&
3886 <         { ac_try='test -z "$ac_f90_werror_flag"
3886 >         { ac_try='test -z "$ac_fc_werror_flag"
3887                           || test ! -s conftest.err'
3888    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3889    (eval $ac_try) 2>&5
# Line 3746 | Line 3905 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3905   fi
3906   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3907  
3908 <  F90FLAGS=$ac_save_F90FLAGS
3908 >  FCFLAGS=$ac_save_FCFLAGS
3909    ac_ext=$ac_save_ext
3910 <  ac_ext=c
3911 < ac_cpp='$CPP $CPPFLAGS'
3912 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3913 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3910 >  ac_ext=${FC_SRCEXT-f}
3911 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3912 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3913 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3914  
3915  
3758
3916    if test "$prepdefflagworks" = 1; then
3917      echo "$as_me:$LINENO: result: yes" >&5
3918   echo "${ECHO_T}yes" >&6
# Line 3769 | Line 3926 | ac_ext=f90
3926    fi
3927   fi
3928  
3929 < ac_ext=f90
3930 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3931 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3932 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3933 <
3934 <
3935 <
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
3929 > ac_ext=${FC_SRCEXT-f}
3930 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3931 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3932 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3933 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3934 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3935 > if test "${ac_cv_prog_fc_v+set}" = set; then
3936    echo $ECHO_N "(cached) $ECHO_C" >&6
3937   else
3938 +  cat >conftest.$ac_ext <<_ACEOF
3939 +      program main
3940  
3941 < cat >conftest.$ac_ext <<_ACEOF
3790 <
3791 < program main
3792 <
3793 <
3794 < end program main
3795 <
3941 >      end
3942   _ACEOF
3943   rm -f conftest.$ac_objext
3944   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3803 | Line 3949 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3949    cat conftest.err >&5
3950    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3951    (exit $ac_status); } &&
3952 <         { ac_try='test -z "$ac_f90_werror_flag"
3952 >         { ac_try='test -z "$ac_fc_werror_flag"
3953                           || test ! -s conftest.err'
3954    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3955    (eval $ac_try) 2>&5
# Line 3816 | Line 3962 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3962    ac_status=$?
3963    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3964    (exit $ac_status); }; }; then
3965 <  ac_cv_prog_f90_v=
3965 >  ac_cv_prog_fc_v=
3966   # Try some options frequently used verbose output
3967   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3968 <  ac_ext=f90
3969 < 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
3968 >  cat >conftest.$ac_ext <<_ACEOF
3969 >      program main
3970  
3971 < cat >conftest.$ac_ext <<_ACEOF
3828 <
3829 < program main
3830 <
3831 <
3832 < end program main
3833 <
3971 >      end
3972   _ACEOF
3973  
3974   # Compile and link our simple test program by passing a flag (argument
3975 < # 1 to this macro) to the Fortran 90 compiler in order to get
3976 < # "verbose" output that we can then parse for the Fortran 90 linker
3975 > # 1 to this macro) to the Fortran compiler in order to get
3976 > # "verbose" output that we can then parse for the Fortran linker
3977   # flags.
3978 < ac_save_F90FLAGS=$F90FLAGS
3979 < F90FLAGS="$F90FLAGS $ac_verb"
3978 > ac_save_FFLAGS=$FCFLAGS
3979 > FCFLAGS="$FCFLAGS $ac_verb"
3980 > (eval echo $as_me:3980: \"$ac_link\") >&5
3981 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3982 > echo "$ac_fc_v_output" >&5
3983 > FCFLAGS=$ac_save_FFLAGS
3984  
3985 < (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
3985 > rm -f conftest*
3986  
3987 < rm -f conftest.*
3988 < ac_ext=f90
3989 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3990 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3991 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3987 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
3988 > # /foo, /bar, and /baz are search directories for the Fortran linker.
3989 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
3990 > ac_fc_v_output="`echo $ac_fc_v_output |
3991 >        grep 'LPATH is:' |
3992 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
3993  
3994 < # If we are using xlf then replace all the commas with spaces.
3995 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3996 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3997 < fi
3994 > case $ac_fc_v_output in
3995 >  # If we are using xlf then replace all the commas with spaces.
3996 >  *xlfentry*)
3997 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
3998  
3999 < # If we are using Cray Fortran then delete quotes.
4000 < # Use "\"" instead of '"' for font-lock-mode.
4001 < # FIXME: a more general fix for quoted arguments with spaces?
4002 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4003 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4004 < fi
3999 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4000 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4001 >  *mGLOB_options_string*)
4002 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4003 >
4004 >  # If we are using Cray Fortran then delete quotes.
4005 >  # Use "\"" instead of '"' for font-lock-mode.
4006 >  # FIXME: a more general fix for quoted arguments with spaces?
4007 >  *cft90*)
4008 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4009 > esac
4010 >
4011 >
4012    # look for -l* and *.a constructs in the output
4013 <  for ac_arg in $ac_f90_v_output; do
4013 >  for ac_arg in $ac_fc_v_output; do
4014       case $ac_arg in
4015          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4016 <          ac_cv_prog_f90_v=$ac_verb
4016 >          ac_cv_prog_fc_v=$ac_verb
4017            break 2 ;;
4018       esac
4019    done
4020   done
4021 < if test -z "$ac_cv_prog_f90_v"; then
4022 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4023 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4021 > if test -z "$ac_cv_prog_fc_v"; then
4022 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4023 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4024   fi
4025   else
4026    echo "$as_me: failed program was:" >&5
# Line 3885 | Line 4032 | echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4032   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4033  
4034   fi
4035 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4036 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4037 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4038 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4039 < if test "${ac_cv_flibs+set}" = set; then
4035 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4036 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4037 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4038 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4039 > if test "${ac_cv_fc_libs+set}" = set; then
4040    echo $ECHO_N "(cached) $ECHO_C" >&6
4041   else
4042 <  if test "x$F90LIBS" != "x"; then
4043 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4042 >  if test "x$FCLIBS" != "x"; then
4043 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4044   else
4045  
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
4046   cat >conftest.$ac_ext <<_ACEOF
4047 +      program main
4048  
4049 < program main
3907 <
3908 <
3909 < end program main
3910 <
4049 >      end
4050   _ACEOF
4051  
4052   # Compile and link our simple test program by passing a flag (argument
4053 < # 1 to this macro) to the Fortran 90 compiler in order to get
4054 < # "verbose" output that we can then parse for the Fortran 90 linker
4053 > # 1 to this macro) to the Fortran compiler in order to get
4054 > # "verbose" output that we can then parse for the Fortran linker
4055   # flags.
4056 < ac_save_F90FLAGS=$F90FLAGS
4057 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4056 > ac_save_FFLAGS=$FCFLAGS
4057 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4058 > (eval echo $as_me:4058: \"$ac_link\") >&5
4059 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4060 > echo "$ac_fc_v_output" >&5
4061 > FCFLAGS=$ac_save_FFLAGS
4062  
4063 < (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
4063 > rm -f conftest*
4064  
4065 < rm -f conftest.*
4066 < ac_ext=f90
4067 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4068 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4069 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4065 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4066 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4067 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4068 > ac_fc_v_output="`echo $ac_fc_v_output |
4069 >        grep 'LPATH is:' |
4070 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4071  
4072 < # If we are using xlf then replace all the commas with spaces.
4073 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4074 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4075 < fi
4072 > case $ac_fc_v_output in
4073 >  # If we are using xlf then replace all the commas with spaces.
4074 >  *xlfentry*)
4075 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4076  
4077 < # If we are using Cray Fortran then delete quotes.
4078 < # Use "\"" instead of '"' for font-lock-mode.
4079 < # FIXME: a more general fix for quoted arguments with spaces?
4080 < 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
4077 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4078 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4079 >  *mGLOB_options_string*)
4080 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4081  
4082 < ac_cv_f90libs=
4082 >  # If we are using Cray Fortran then delete quotes.
4083 >  # Use "\"" instead of '"' for font-lock-mode.
4084 >  # FIXME: a more general fix for quoted arguments with spaces?
4085 >  *cft90*)
4086 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4087 > esac
4088  
4089 +
4090 +
4091 + ac_cv_fc_libs=
4092 +
4093   # Save positional arguments (if any)
4094   ac_save_positional="$@"
4095  
4096 < set X $ac_f90_v_output
4096 > set X $ac_fc_v_output
4097   while test $# != 1; do
4098    shift
4099    ac_arg=$1
4100    case $ac_arg in
4101          [\\/]*.a | ?:[\\/]*.a)
4102              ac_exists=false
4103 <  for ac_i in $ac_cv_f90libs; do
4103 >  for ac_i in $ac_cv_fc_libs; do
4104      if test x"$ac_arg" = x"$ac_i"; then
4105        ac_exists=true
4106        break
# Line 3962 | Line 4110 | else
4110    if test x"$ac_exists" = xtrue; then
4111    :
4112   else
4113 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4113 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4114   fi
4115  
4116            ;;
4117          -bI:*)
4118              ac_exists=false
4119 <  for ac_i in $ac_cv_f90libs; do
4119 >  for ac_i in $ac_cv_fc_libs; do
4120      if test x"$ac_arg" = x"$ac_i"; then
4121        ac_exists=true
4122        break
# Line 3980 | Line 4128 | else
4128   else
4129    if test "$ac_compiler_gnu" = yes; then
4130    for ac_link_opt in $ac_arg; do
4131 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4131 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4132    done
4133   else
4134 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4134 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4135   fi
4136   fi
4137  
4138            ;;
4139            # Ignore these flags.
4140 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4140 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4141            ;;
4142          -lkernel32)
4143 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4143 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4144            ;;
4145          -[LRuY])
4146            # These flags, when seen by themselves, take an argument.
4147            # We remove the space between option and argument and re-iterate
4148            # unless we find an empty arg or a new option (starting with -)
4149            case $2 in
4150 <             "" | -*);;
4151 <             *)
4150 >             "" | -*);;
4151 >             *)
4152                  ac_arg="$ac_arg$2"
4005
4153                  shift; shift
4154                  set X $ac_arg "$@"
4155                  ;;
# Line 4011 | Line 4158 | fi
4158          -YP,*)
4159            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4160                ac_exists=false
4161 <  for ac_i in $ac_cv_f90libs; do
4161 >  for ac_i in $ac_cv_fc_libs; do
4162      if test x"$ac_j" = x"$ac_i"; then
4163        ac_exists=true
4164        break
# Line 4022 | Line 4169 | else
4169    :
4170   else
4171    ac_arg="$ac_arg $ac_j"
4172 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4172 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4173   fi
4174  
4175            done
4176            ;;
4177          -[lLR]*)
4178              ac_exists=false
4179 <  for ac_i in $ac_cv_f90libs; do
4179 >  for ac_i in $ac_cv_fc_libs; do
4180      if test x"$ac_arg" = x"$ac_i"; then
4181        ac_exists=true
4182        break
# Line 4039 | Line 4186 | else
4186    if test x"$ac_exists" = xtrue; then
4187    :
4188   else
4189 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4189 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4190   fi
4191  
4192            ;;
# Line 4054 | Line 4201 | case `(uname -sr) 2>/dev/null` in
4201   # must begin with a "/").
4202   case `(uname -sr) 2>/dev/null` in
4203     "SunOS 5"*)
4204 <      ac_ld_run_path=`echo $ac_f90_v_output |
4204 >      ac_ld_run_path=`echo $ac_fc_v_output |
4205                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4206        test "x$ac_ld_run_path" != x &&
4060
4207          if test "$ac_compiler_gnu" = yes; then
4208    for ac_link_opt in $ac_ld_run_path; do
4209 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4209 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4210    done
4211   else
4212 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4212 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4213   fi
4214        ;;
4215   esac
4216 < fi # test "x$F90LIBS" = "x"
4216 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4217  
4218   fi
4219 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4220 < echo "${ECHO_T}$ac_cv_flibs" >&6
4221 < F90LIBS="$ac_cv_f90libs"
4219 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4220 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4221 > FCLIBS="$ac_cv_fc_libs"
4222  
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
4223  
4224 + ac_ext=${FC_SRCEXT-f}
4225 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4226 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4227 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4228  
4229 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4230 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4231 < if test "${ac_cv_f90_mangling+set}" = set; then
4229 >
4230 > ac_ext=${FC_SRCEXT-f}
4231 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4232 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4233 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4234 >
4235 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4236 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4237 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4238    echo $ECHO_N "(cached) $ECHO_C" >&6
4239   else
4240 <  ac_ext=f90
4241 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4242 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4243 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4244 < cat >conftest.$ac_ext <<_ACEOF
4245 < subroutine foobar()
4246 < return
4247 < end
4248 < subroutine foo_bar()
4249 < return
4250 < end
4240 >  ac_fc_dm_save_LIBS=$LIBS
4241 > LIBS="$LIBS $FCLIBS"
4242 > ac_fortran_dm_var=FC_DUMMY_MAIN
4243 > ac_ext=c
4244 > ac_cpp='$CPP $CPPFLAGS'
4245 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4246 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4247 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4248 >
4249 > # First, try linking without a dummy main:
4250 > cat >conftest.$ac_ext <<_ACEOF
4251 > /* confdefs.h.  */
4252   _ACEOF
4253 + cat confdefs.h >>conftest.$ac_ext
4254 + cat >>conftest.$ac_ext <<_ACEOF
4255 + /* end confdefs.h.  */
4256 +
4257 + #ifdef FC_DUMMY_MAIN
4258 + #ifndef FC_DUMMY_MAIN_EQ_F77
4259 + #  ifdef __cplusplus
4260 +     extern "C"
4261 + #  endif
4262 +   int FC_DUMMY_MAIN() { return 1; }
4263 + #endif
4264 + #endif
4265 + int
4266 + main ()
4267 + {
4268 +
4269 +  ;
4270 +  return 0;
4271 + }
4272 + _ACEOF
4273 + rm -f conftest.$ac_objext conftest$ac_exeext
4274 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4275 +  (eval $ac_link) 2>conftest.er1
4276 +  ac_status=$?
4277 +  grep -v '^ *+' conftest.er1 >conftest.err
4278 +  rm -f conftest.er1
4279 +  cat conftest.err >&5
4280 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4281 +  (exit $ac_status); } &&
4282 +         { ac_try='test -z "$ac_c_werror_flag"
4283 +                         || test ! -s conftest.err'
4284 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4285 +  (eval $ac_try) 2>&5
4286 +  ac_status=$?
4287 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4288 +  (exit $ac_status); }; } &&
4289 +         { ac_try='test -s conftest$ac_exeext'
4290 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4291 +  (eval $ac_try) 2>&5
4292 +  ac_status=$?
4293 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4294 +  (exit $ac_status); }; }; then
4295 +  ac_cv_fortran_dummy_main=none
4296 + else
4297 +  echo "$as_me: failed program was:" >&5
4298 + sed 's/^/| /' conftest.$ac_ext >&5
4299 +
4300 + ac_cv_fortran_dummy_main=unknown
4301 + fi
4302 + rm -f conftest.err conftest.$ac_objext \
4303 +      conftest$ac_exeext conftest.$ac_ext
4304 +
4305 + if test $ac_cv_fortran_dummy_main = unknown; then
4306 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4307 +     cat >conftest.$ac_ext <<_ACEOF
4308 + /* confdefs.h.  */
4309 + _ACEOF
4310 + cat confdefs.h >>conftest.$ac_ext
4311 + cat >>conftest.$ac_ext <<_ACEOF
4312 + /* end confdefs.h.  */
4313 + #define $ac_fortran_dm_var $ac_func
4314 + #ifdef FC_DUMMY_MAIN
4315 + #ifndef FC_DUMMY_MAIN_EQ_F77
4316 + #  ifdef __cplusplus
4317 +     extern "C"
4318 + #  endif
4319 +   int FC_DUMMY_MAIN() { return 1; }
4320 + #endif
4321 + #endif
4322 + int
4323 + main ()
4324 + {
4325 +
4326 +  ;
4327 +  return 0;
4328 + }
4329 + _ACEOF
4330 + rm -f conftest.$ac_objext conftest$ac_exeext
4331 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4332 +  (eval $ac_link) 2>conftest.er1
4333 +  ac_status=$?
4334 +  grep -v '^ *+' conftest.er1 >conftest.err
4335 +  rm -f conftest.er1
4336 +  cat conftest.err >&5
4337 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4338 +  (exit $ac_status); } &&
4339 +         { ac_try='test -z "$ac_c_werror_flag"
4340 +                         || test ! -s conftest.err'
4341 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4342 +  (eval $ac_try) 2>&5
4343 +  ac_status=$?
4344 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4345 +  (exit $ac_status); }; } &&
4346 +         { ac_try='test -s conftest$ac_exeext'
4347 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4348 +  (eval $ac_try) 2>&5
4349 +  ac_status=$?
4350 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4351 +  (exit $ac_status); }; }; then
4352 +  ac_cv_fortran_dummy_main=$ac_func; break
4353 + else
4354 +  echo "$as_me: failed program was:" >&5
4355 + sed 's/^/| /' conftest.$ac_ext >&5
4356 +
4357 + fi
4358 + rm -f conftest.err conftest.$ac_objext \
4359 +      conftest$ac_exeext conftest.$ac_ext
4360 +   done
4361 + fi
4362 + ac_ext=${FC_SRCEXT-f}
4363 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4364 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4365 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4366 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4367 + rm -f conftest*
4368 + LIBS=$ac_fc_dm_save_LIBS
4369 +
4370 + fi
4371 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4372 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4373 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4374 + if test "$FC_DUMMY_MAIN" != unknown; then
4375 +  if test $FC_DUMMY_MAIN != none; then
4376 +
4377 + cat >>confdefs.h <<_ACEOF
4378 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4379 + _ACEOF
4380 +
4381 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4382 +
4383 + cat >>confdefs.h <<\_ACEOF
4384 + #define FC_DUMMY_MAIN_EQ_F77 1
4385 + _ACEOF
4386 +
4387 +  fi
4388 + fi
4389 + else
4390 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4391 + See \`config.log' for more details." >&5
4392 + echo "$as_me: error: linking to Fortran libraries from C fails
4393 + See \`config.log' for more details." >&2;}
4394 +   { (exit 1); exit 1; }; }
4395 + fi
4396 +
4397 +
4398 + ac_ext=${FC_SRCEXT-f}
4399 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4400 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4401 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4402 +
4403 + ac_ext=${FC_SRCEXT-f}
4404 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4405 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4406 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4407 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4408 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4409 + if test "${ac_cv_fc_mangling+set}" = set; then
4410 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4411 + else
4412 +  cat >conftest.$ac_ext <<_ACEOF
4413 +      subroutine foobar()
4414 +      return
4415 +      end
4416 +      subroutine foo_bar()
4417 +      return
4418 +      end
4419 + _ACEOF
4420   rm -f conftest.$ac_objext
4421   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4422    (eval $ac_compile) 2>conftest.er1
# Line 4106 | Line 4426 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4426    cat conftest.err >&5
4427    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4428    (exit $ac_status); } &&
4429 <         { ac_try='test -z "$ac_f90_werror_flag"
4429 >         { ac_try='test -z "$ac_fc_werror_flag"
4430                           || test ! -s conftest.err'
4431    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4432    (eval $ac_try) 2>&5
# Line 4119 | Line 4439 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4439    ac_status=$?
4440    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4441    (exit $ac_status); }; }; then
4442 <  mv conftest.$ac_objext cf90_test.$ac_objext
4442 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4443  
4444 +  ac_save_LIBS=$LIBS
4445 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4446 +
4447    ac_ext=c
4448   ac_cpp='$CPP $CPPFLAGS'
4449   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4450   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4451   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4129
4130  ac_save_LIBS=$LIBS
4131  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4132
4452    ac_success=no
4453    for ac_foobar in foobar FOOBAR; do
4454      for ac_underscore in "" "_"; do
# Line 4148 | Line 4467 | int
4467   /* We use char because int might match the return type of a gcc2
4468     builtin and then its argument prototype would still apply.  */
4469   char $ac_func ();
4470 + #ifdef FC_DUMMY_MAIN
4471 + #ifndef FC_DUMMY_MAIN_EQ_F77
4472 + #  ifdef __cplusplus
4473 +     extern "C"
4474 + #  endif
4475 +   int FC_DUMMY_MAIN() { return 1; }
4476 + #endif
4477 + #endif
4478   int
4479   main ()
4480   {
# Line 4188 | Line 4515 | rm -f conftest.err conftest.$ac_objext \
4515        conftest$ac_exeext conftest.$ac_ext
4516      done
4517    done
4518 +  ac_ext=${FC_SRCEXT-f}
4519 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4520 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4521 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4522  
4523    if test "$ac_success" = "yes"; then
4524       case $ac_foobar in
4525 <        foobar)
4526 <           ac_case=lower
4527 <           ac_foo_bar=foo_bar
4528 <           ;;
4529 <        FOOBAR)
4530 <           ac_case=upper
4531 <           ac_foo_bar=FOO_BAR
4532 <           ;;
4525 >        foobar)
4526 >           ac_case=lower
4527 >           ac_foo_bar=foo_bar
4528 >           ;;
4529 >        FOOBAR)
4530 >           ac_case=upper
4531 >           ac_foo_bar=FOO_BAR
4532 >           ;;
4533       esac
4534  
4535 +     ac_ext=c
4536 + ac_cpp='$CPP $CPPFLAGS'
4537 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4538 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4539 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4540       ac_success_extra=no
4541       for ac_extra in "" "_"; do
4542 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4543 <
4208 <        cat >conftest.$ac_ext <<_ACEOF
4542 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4543 >        cat >conftest.$ac_ext <<_ACEOF
4544   /* confdefs.h.  */
4545   _ACEOF
4546   cat confdefs.h >>conftest.$ac_ext
# Line 4219 | Line 4554 | int
4554   /* We use char because int might match the return type of a gcc2
4555     builtin and then its argument prototype would still apply.  */
4556   char $ac_func ();
4557 + #ifdef FC_DUMMY_MAIN
4558 + #ifndef FC_DUMMY_MAIN_EQ_F77
4559 + #  ifdef __cplusplus
4560 +     extern "C"
4561 + #  endif
4562 +   int FC_DUMMY_MAIN() { return 1; }
4563 + #endif
4564 + #endif
4565   int
4566   main ()
4567   {
# Line 4258 | Line 4601 | rm -f conftest.err conftest.$ac_objext \
4601   rm -f conftest.err conftest.$ac_objext \
4602        conftest$ac_exeext conftest.$ac_ext
4603       done
4604 +     ac_ext=${FC_SRCEXT-f}
4605 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4606 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4607 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4608  
4609       if test "$ac_success_extra" = "yes"; then
4610 <        ac_cv_f90_mangling="$ac_case case"
4610 >        ac_cv_fc_mangling="$ac_case case"
4611          if test -z "$ac_underscore"; then
4612 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4612 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4613          else
4614 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4268 <
4614 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4615          fi
4616          if test -z "$ac_extra"; then
4617 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4617 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4618          else
4619 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4619 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4620          fi
4621        else
4622 <        ac_cv_f90_mangling="unknown"
4622 >        ac_cv_fc_mangling="unknown"
4623        fi
4624    else
4625 <     ac_cv_f90_mangling="unknown"
4280 <
4625 >     ac_cv_fc_mangling="unknown"
4626    fi
4627  
4628    LIBS=$ac_save_LIBS
4629 <  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*
4629 >  rm -f cfortran_test* conftest*
4630   else
4631    echo "$as_me: failed program was:" >&5
4632   sed 's/^/| /' conftest.$ac_ext >&5
4633  
4634 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4635 + See \`config.log' for more details." >&5
4636 + echo "$as_me: error: cannot compile a simple Fortran program
4637 + See \`config.log' for more details." >&2;}
4638 +   { (exit 1); exit 1; }; }
4639   fi
4640   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
4641  
4642   fi
4643 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4644 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4643 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4644 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4645  
4646 + ac_ext=${FC_SRCEXT-f}
4647 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4648 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4649 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4650  
4651 + ac_ext=${FC_SRCEXT-f}
4652 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4653 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4654 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4655  
4656 < case $ac_cv_f90_mangling in
4656 >
4657 > case $ac_cv_fc_mangling in
4658    "lower case, no underscore, no extra underscore")
4659            cat >>confdefs.h <<\_ACEOF
4660 < #define F90_FUNC(name,NAME) name
4660 > #define FC_FUNC(name,NAME) name
4661   _ACEOF
4662  
4663            cat >>confdefs.h <<\_ACEOF
4664 < #define F90_FUNC_(name,NAME) name
4664 > #define FC_FUNC_(name,NAME) name
4665   _ACEOF
4666   ;;
4667    "lower case, no underscore, extra underscore")
4668            cat >>confdefs.h <<\_ACEOF
4669 < #define F90_FUNC(name,NAME) name
4669 > #define FC_FUNC(name,NAME) name
4670   _ACEOF
4671  
4672            cat >>confdefs.h <<\_ACEOF
4673 < #define F90_FUNC_(name,NAME) name ## _
4673 > #define FC_FUNC_(name,NAME) name ## _
4674   _ACEOF
4675   ;;
4676    "lower case, underscore, no extra underscore")
4677            cat >>confdefs.h <<\_ACEOF
4678 < #define F90_FUNC(name,NAME) name ## _
4678 > #define FC_FUNC(name,NAME) name ## _
4679   _ACEOF
4680  
4681            cat >>confdefs.h <<\_ACEOF
4682 < #define F90_FUNC_(name,NAME) name ## _
4682 > #define FC_FUNC_(name,NAME) name ## _
4683   _ACEOF
4684   ;;
4685    "lower case, underscore, extra underscore")
4686            cat >>confdefs.h <<\_ACEOF
4687 < #define F90_FUNC(name,NAME) name ## _
4687 > #define FC_FUNC(name,NAME) name ## _
4688   _ACEOF
4689  
4690            cat >>confdefs.h <<\_ACEOF
4691 < #define F90_FUNC_(name,NAME) name ## __
4691 > #define FC_FUNC_(name,NAME) name ## __
4692   _ACEOF
4693   ;;
4694    "upper case, no underscore, no extra underscore")
4695            cat >>confdefs.h <<\_ACEOF
4696 < #define F90_FUNC(name,NAME) NAME
4696 > #define FC_FUNC(name,NAME) NAME
4697   _ACEOF
4698  
4699            cat >>confdefs.h <<\_ACEOF
4700 < #define F90_FUNC_(name,NAME) NAME
4700 > #define FC_FUNC_(name,NAME) NAME
4701   _ACEOF
4702   ;;
4703    "upper case, no underscore, extra underscore")
4704            cat >>confdefs.h <<\_ACEOF
4705 < #define F90_FUNC(name,NAME) NAME
4705 > #define FC_FUNC(name,NAME) NAME
4706   _ACEOF
4707  
4708            cat >>confdefs.h <<\_ACEOF
4709 < #define F90_FUNC_(name,NAME) NAME ## _
4709 > #define FC_FUNC_(name,NAME) NAME ## _
4710   _ACEOF
4711   ;;
4712    "upper case, underscore, no extra underscore")
4713            cat >>confdefs.h <<\_ACEOF
4714 < #define F90_FUNC(name,NAME) NAME ## _
4714 > #define FC_FUNC(name,NAME) NAME ## _
4715   _ACEOF
4716  
4717            cat >>confdefs.h <<\_ACEOF
4718 < #define F90_FUNC_(name,NAME) NAME ## _
4718 > #define FC_FUNC_(name,NAME) NAME ## _
4719   _ACEOF
4720   ;;
4721    "upper case, underscore, extra underscore")
4722            cat >>confdefs.h <<\_ACEOF
4723 < #define F90_FUNC(name,NAME) NAME ## _
4723 > #define FC_FUNC(name,NAME) NAME ## _
4724   _ACEOF
4725  
4726            cat >>confdefs.h <<\_ACEOF
4727 < #define F90_FUNC_(name,NAME) NAME ## __
4727 > #define FC_FUNC_(name,NAME) NAME ## __
4728   _ACEOF
4729   ;;
4730    *)
4731 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4732 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4731 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4732 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4733 >          ;;
4734 > esac
4735 >
4736 > ac_ext=${FC_SRCEXT-f}
4737 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4738 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4739 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4740 >
4741 >
4742 >
4743 > ac_ext=${FC_SRCEXT-f}
4744 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4745 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4746 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4747 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4748 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4749 > if test "${ac_cv_prog_fc_v+set}" = set; then
4750 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4751 > else
4752 >  cat >conftest.$ac_ext <<_ACEOF
4753 >      program main
4754 >
4755 >      end
4756 > _ACEOF
4757 > rm -f conftest.$ac_objext
4758 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4759 >  (eval $ac_compile) 2>conftest.er1
4760 >  ac_status=$?
4761 >  grep -v '^ *+' conftest.er1 >conftest.err
4762 >  rm -f conftest.er1
4763 >  cat conftest.err >&5
4764 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4765 >  (exit $ac_status); } &&
4766 >         { ac_try='test -z "$ac_fc_werror_flag"
4767 >                         || test ! -s conftest.err'
4768 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4769 >  (eval $ac_try) 2>&5
4770 >  ac_status=$?
4771 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4772 >  (exit $ac_status); }; } &&
4773 >         { ac_try='test -s conftest.$ac_objext'
4774 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4775 >  (eval $ac_try) 2>&5
4776 >  ac_status=$?
4777 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4778 >  (exit $ac_status); }; }; then
4779 >  ac_cv_prog_fc_v=
4780 > # Try some options frequently used verbose output
4781 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4782 >  cat >conftest.$ac_ext <<_ACEOF
4783 >      program main
4784 >
4785 >      end
4786 > _ACEOF
4787 >
4788 > # Compile and link our simple test program by passing a flag (argument
4789 > # 1 to this macro) to the Fortran compiler in order to get
4790 > # "verbose" output that we can then parse for the Fortran linker
4791 > # flags.
4792 > ac_save_FFLAGS=$FCFLAGS
4793 > FCFLAGS="$FCFLAGS $ac_verb"
4794 > (eval echo $as_me:4794: \"$ac_link\") >&5
4795 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4796 > echo "$ac_fc_v_output" >&5
4797 > FCFLAGS=$ac_save_FFLAGS
4798 >
4799 > rm -f conftest*
4800 >
4801 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4802 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4803 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4804 > ac_fc_v_output="`echo $ac_fc_v_output |
4805 >        grep 'LPATH is:' |
4806 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4807 >
4808 > case $ac_fc_v_output in
4809 >  # If we are using xlf then replace all the commas with spaces.
4810 >  *xlfentry*)
4811 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4812 >
4813 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4814 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4815 >  *mGLOB_options_string*)
4816 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4817 >
4818 >  # If we are using Cray Fortran then delete quotes.
4819 >  # Use "\"" instead of '"' for font-lock-mode.
4820 >  # FIXME: a more general fix for quoted arguments with spaces?
4821 >  *cft90*)
4822 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4823 > esac
4824 >
4825 >
4826 >  # look for -l* and *.a constructs in the output
4827 >  for ac_arg in $ac_fc_v_output; do
4828 >     case $ac_arg in
4829 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4830 >          ac_cv_prog_fc_v=$ac_verb
4831 >          break 2 ;;
4832 >     esac
4833 >  done
4834 > done
4835 > if test -z "$ac_cv_prog_fc_v"; then
4836 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4837 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4838 > fi
4839 > else
4840 >  echo "$as_me: failed program was:" >&5
4841 > sed 's/^/| /' conftest.$ac_ext >&5
4842 >
4843 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4844 > echo "$as_me: WARNING: compilation failed" >&2;}
4845 > fi
4846 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4847 >
4848 > fi
4849 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4850 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4851 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4852 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4853 > if test "${ac_cv_fc_libs+set}" = set; then
4854 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4855 > else
4856 >  if test "x$FCLIBS" != "x"; then
4857 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4858 > else
4859 >
4860 > cat >conftest.$ac_ext <<_ACEOF
4861 >      program main
4862 >
4863 >      end
4864 > _ACEOF
4865 >
4866 > # Compile and link our simple test program by passing a flag (argument
4867 > # 1 to this macro) to the Fortran compiler in order to get
4868 > # "verbose" output that we can then parse for the Fortran linker
4869 > # flags.
4870 > ac_save_FFLAGS=$FCFLAGS
4871 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4872 > (eval echo $as_me:4872: \"$ac_link\") >&5
4873 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4874 > echo "$ac_fc_v_output" >&5
4875 > FCFLAGS=$ac_save_FFLAGS
4876 >
4877 > rm -f conftest*
4878 >
4879 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4880 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4881 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4882 > ac_fc_v_output="`echo $ac_fc_v_output |
4883 >        grep 'LPATH is:' |
4884 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4885 >
4886 > case $ac_fc_v_output in
4887 >  # If we are using xlf then replace all the commas with spaces.
4888 >  *xlfentry*)
4889 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4890 >
4891 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4892 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4893 >  *mGLOB_options_string*)
4894 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4895 >
4896 >  # If we are using Cray Fortran then delete quotes.
4897 >  # Use "\"" instead of '"' for font-lock-mode.
4898 >  # FIXME: a more general fix for quoted arguments with spaces?
4899 >  *cft90*)
4900 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4901 > esac
4902 >
4903 >
4904 >
4905 > ac_cv_fc_libs=
4906 >
4907 > # Save positional arguments (if any)
4908 > ac_save_positional="$@"
4909 >
4910 > set X $ac_fc_v_output
4911 > while test $# != 1; do
4912 >  shift
4913 >  ac_arg=$1
4914 >  case $ac_arg in
4915 >        [\\/]*.a | ?:[\\/]*.a)
4916 >            ac_exists=false
4917 >  for ac_i in $ac_cv_fc_libs; do
4918 >    if test x"$ac_arg" = x"$ac_i"; then
4919 >      ac_exists=true
4920 >      break
4921 >    fi
4922 >  done
4923 >
4924 >  if test x"$ac_exists" = xtrue; then
4925 >  :
4926 > else
4927 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4928 > fi
4929 >
4930            ;;
4931 +        -bI:*)
4932 +            ac_exists=false
4933 +  for ac_i in $ac_cv_fc_libs; do
4934 +    if test x"$ac_arg" = x"$ac_i"; then
4935 +      ac_exists=true
4936 +      break
4937 +    fi
4938 +  done
4939 +
4940 +  if test x"$ac_exists" = xtrue; then
4941 +  :
4942 + else
4943 +  if test "$ac_compiler_gnu" = yes; then
4944 +  for ac_link_opt in $ac_arg; do
4945 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4946 +  done
4947 + else
4948 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4949 + fi
4950 + fi
4951 +
4952 +          ;;
4953 +          # Ignore these flags.
4954 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4955 +          ;;
4956 +        -lkernel32)
4957 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4958 +          ;;
4959 +        -[LRuY])
4960 +          # These flags, when seen by themselves, take an argument.
4961 +          # We remove the space between option and argument and re-iterate
4962 +          # unless we find an empty arg or a new option (starting with -)
4963 +          case $2 in
4964 +             "" | -*);;
4965 +             *)
4966 +                ac_arg="$ac_arg$2"
4967 +                shift; shift
4968 +                set X $ac_arg "$@"
4969 +                ;;
4970 +          esac
4971 +          ;;
4972 +        -YP,*)
4973 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4974 +              ac_exists=false
4975 +  for ac_i in $ac_cv_fc_libs; do
4976 +    if test x"$ac_j" = x"$ac_i"; then
4977 +      ac_exists=true
4978 +      break
4979 +    fi
4980 +  done
4981 +
4982 +  if test x"$ac_exists" = xtrue; then
4983 +  :
4984 + else
4985 +  ac_arg="$ac_arg $ac_j"
4986 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4987 + fi
4988 +
4989 +          done
4990 +          ;;
4991 +        -[lLR]*)
4992 +            ac_exists=false
4993 +  for ac_i in $ac_cv_fc_libs; do
4994 +    if test x"$ac_arg" = x"$ac_i"; then
4995 +      ac_exists=true
4996 +      break
4997 +    fi
4998 +  done
4999 +
5000 +  if test x"$ac_exists" = xtrue; then
5001 +  :
5002 + else
5003 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5004 + fi
5005 +
5006 +          ;;
5007 +          # Ignore everything else.
5008 +  esac
5009 + done
5010 + # restore positional arguments
5011 + set X $ac_save_positional; shift
5012 +
5013 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5014 + # then we insist that the "run path" must be an absolute path (i.e. it
5015 + # must begin with a "/").
5016 + case `(uname -sr) 2>/dev/null` in
5017 +   "SunOS 5"*)
5018 +      ac_ld_run_path=`echo $ac_fc_v_output |
5019 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5020 +      test "x$ac_ld_run_path" != x &&
5021 +        if test "$ac_compiler_gnu" = yes; then
5022 +  for ac_link_opt in $ac_ld_run_path; do
5023 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5024 +  done
5025 + else
5026 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5027 + fi
5028 +      ;;
5029   esac
5030 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5031  
5032 + fi
5033 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5034 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5035 + FCLIBS="$ac_cv_fc_libs"
5036  
5037  
5038 + ac_ext=${FC_SRCEXT-f}
5039 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5040 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5041 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5042  
5043  
5044 +
5045   echo "$as_me:$LINENO: checking for module suffix" >&5
5046   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5047   rm -f conftest*
5048   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5049   rm -f work*
5050 < cat >conftest.f90 <<EOF
5050 > cat >conftest.$ac_ext <<EOF
5051          module conftest
5052          integer n
5053          parameter (n=1)
# Line 4400 | Line 5056 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5056   # SGI and absoft compilers generates module name in upper case!
5057   testname="conftest"
5058   modcase="lower"
5059 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5060 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5059 > if (eval $ac_compile) 2>/dev/null ; then
5060 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5061      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5062      if test -z "$MOD" ; then
5063          MOD=`ls CONFTEST* 2>/dev/null \
5064 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5064 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5065          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5066          if test -n "$MOD" ; then
5067              testname="CONFTEST"
# Line 4445 | Line 5101 | cat >conftest.f90 <<EOF
5101   rm -f conftest*
5102   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5103   rm -f work*
5104 < cat >conftest.f90 <<EOF
5104 > cat >conftest.$ac_ext <<EOF
5105          module conftest
5106          integer n
5107          parameter (n=1)
# Line 4453 | Line 5109 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5109   EOF
5110   # SGI and absoft compilers generates module name in upper case!
5111   testname="conftest"
5112 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5113 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5112 > if (eval $ac_compile) 2>/dev/null ; then
5113 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5114     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5115     if test -n "$mod" ; then
5116        testname="CONFTEST"
# Line 4463 | Line 5119 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5119     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5120     cp $testname.$MOD conf
5121     rm -f conftest* CONFTEST*
5122 <   cat >conftest1.f90 <<EOF
5122 >   cat >conftest1.$ac_ext <<EOF
5123          program main
5124          use conftest
5125          print *, n
# Line 4471 | Line 5127 | EOF
5127   EOF
5128     F90_WORK_FILES_ARG=""
5129     F90MODINCSPEC=""
5130 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5130 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5131         MODDIRFLAG="-I"
5132         F90MODINCSPEC="-I<dir>"
5133         echo "$as_me:$LINENO: result: -I" >&5
5134   echo "${ECHO_T}-I" >&6
5135 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5135 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5136         MODDIRFLAG="-M"
5137         F90MODINCSPEC="-M<dir>"
5138         echo "$as_me:$LINENO: result: -M" >&5
5139   echo "${ECHO_T}-M" >&6
5140 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5140 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5141         MODDIRFLAG="-p"
5142         F90MODINCSPEC="-p<dir>"
5143         echo "$as_me:$LINENO: result: -p" >&5
# Line 4490 | Line 5146 | echo "${ECHO_T}-p" >&6
5146          cp work.pc conf/mpimod.pc
5147          echo "mpimod.pc" > conf/mpimod.pcl
5148          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5149 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5149 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5150              MODDIRFLAG='-cl,mpimod.pcl'
5151              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5152   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4520 | Line 5176 | else
5176   if test "${ac_cv_f90_module_names+set}" = set; then
5177    echo $ECHO_N "(cached) $ECHO_C" >&6
5178   else
5179 <  ac_ext=f90
5180 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5181 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5182 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5179 >  ac_ext=${FC_SRCEXT-f}
5180 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5181 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5182 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5183  
5184   # carry out the test in a new directory, so that we don't miss anything
5185   mkdir conftest
# Line 4541 | Line 5197 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5197    cat conftest.err >&5
5198    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5199    (exit $ac_status); } &&
5200 <         { ac_try='test -z "$ac_f90_werror_flag"
5200 >         { ac_try='test -z "$ac_fc_werror_flag"
5201                           || test ! -s conftest.err'
5202    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5203    (eval $ac_try) 2>&5
# Line 4657 | Line 5313 | ac_ext=f90
5313   cd ..
5314   # cleanup
5315   rm -rf conftest
5316 < ac_ext=f90
5317 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5318 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5319 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5316 > ac_ext=${FC_SRCEXT-f}
5317 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5318 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5319 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5320  
5321   fi
5322   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4749 | Line 5405 | ac_ext=cc
5405   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5406  
5407  
5408 < ac_ext=cc
5409 < ac_cpp='$CXXCPP $CPPFLAGS'
5410 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5411 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5412 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5408 > ac_ext=c
5409 > ac_cpp='$CPP $CPPFLAGS'
5410 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5411 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5412 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5413  
5414  
5415 < ac_ext=cc
5416 < ac_cpp='$CXXCPP $CPPFLAGS'
5417 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5418 < 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
5415 >
5416 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5417 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5418 > if test "${ac_cv_lib_m_asin+set}" = set; then
5419    echo $ECHO_N "(cached) $ECHO_C" >&6
5420   else
5421 <      # Double quotes because CXXCPP needs to be expanded
5422 <    for CXXCPP in "$CXX -E" "/lib/cpp"
5423 <    do
5424 <      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
4783 < /* confdefs.h.  */
5421 >  ac_check_lib_save_LIBS=$LIBS
5422 > LIBS="-lm  $LIBS"
5423 > cat >conftest.$ac_ext <<_ACEOF
5424 > /* confdefs.h.  */
5425   _ACEOF
5426   cat confdefs.h >>conftest.$ac_ext
5427   cat >>conftest.$ac_ext <<_ACEOF
5428   /* end confdefs.h.  */
5429 < #ifdef __STDC__
5430 < # include <limits.h>
5431 < #else
5432 < # include <assert.h>
5429 >
5430 > /* Override any gcc2 internal prototype to avoid an error.  */
5431 > #ifdef __cplusplus
5432 > extern "C"
5433   #endif
5434 <                     Syntax error
5434 > /* We use char because int might match the return type of a gcc2
5435 >   builtin and then its argument prototype would still apply.  */
5436 > char asin ();
5437 > #ifdef FC_DUMMY_MAIN
5438 > #ifndef FC_DUMMY_MAIN_EQ_F77
5439 > #  ifdef __cplusplus
5440 >     extern "C"
5441 > #  endif
5442 >   int FC_DUMMY_MAIN() { return 1; }
5443 > #endif
5444 > #endif
5445 > int
5446 > main ()
5447 > {
5448 > asin ();
5449 >  ;
5450 >  return 0;
5451 > }
5452   _ACEOF
5453 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5454 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5453 > rm -f conftest.$ac_objext conftest$ac_exeext
5454 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5455 >  (eval $ac_link) 2>conftest.er1
5456    ac_status=$?
5457    grep -v '^ *+' conftest.er1 >conftest.err
5458    rm -f conftest.er1
5459    cat conftest.err >&5
5460    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5461 <  (exit $ac_status); } >/dev/null; then
5462 <  if test -s conftest.err; then
5463 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5464 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5465 <  else
4807 <    ac_cpp_err=
4808 <  fi
4809 < else
4810 <  ac_cpp_err=yes
4811 < fi
4812 < if test -z "$ac_cpp_err"; then
4813 <  :
4814 < else
4815 <  echo "$as_me: failed program was:" >&5
4816 < sed 's/^/| /' conftest.$ac_ext >&5
4817 <
4818 <  # Broken: fails on valid input.
4819 < continue
4820 < fi
4821 < rm -f conftest.err conftest.$ac_ext
4822 <
4823 <  # OK, works on sane cases.  Now check whether non-existent headers
4824 <  # can be detected and how.
4825 <  cat >conftest.$ac_ext <<_ACEOF
4826 < /* confdefs.h.  */
4827 < _ACEOF
4828 < cat confdefs.h >>conftest.$ac_ext
4829 < cat >>conftest.$ac_ext <<_ACEOF
4830 < /* end confdefs.h.  */
4831 < #include <ac_nonexistent.h>
4832 < _ACEOF
4833 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4834 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5461 >  (exit $ac_status); } &&
5462 >         { ac_try='test -z "$ac_c_werror_flag"
5463 >                         || test ! -s conftest.err'
5464 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5465 >  (eval $ac_try) 2>&5
5466    ac_status=$?
4836  grep -v '^ *+' conftest.er1 >conftest.err
4837  rm -f conftest.er1
4838  cat conftest.err >&5
5467    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5468 <  (exit $ac_status); } >/dev/null; then
5469 <  if test -s conftest.err; then
5470 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5471 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5472 <  else
5473 <    ac_cpp_err=
5474 <  fi
5468 >  (exit $ac_status); }; } &&
5469 >         { ac_try='test -s conftest$ac_exeext'
5470 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5471 >  (eval $ac_try) 2>&5
5472 >  ac_status=$?
5473 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5474 >  (exit $ac_status); }; }; then
5475 >  ac_cv_lib_m_asin=yes
5476   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
5477    echo "$as_me: failed program was:" >&5
5478   sed 's/^/| /' conftest.$ac_ext >&5
5479  
5480 <  # Passes both tests.
4858 < ac_preproc_ok=:
4859 < break
5480 > ac_cv_lib_m_asin=no
5481   fi
5482 < rm -f conftest.err conftest.$ac_ext
5483 <
5484 < done
4864 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4865 < rm -f conftest.err conftest.$ac_ext
4866 < if $ac_preproc_ok; then
4867 <  break
5482 > rm -f conftest.err conftest.$ac_objext \
5483 >      conftest$ac_exeext conftest.$ac_ext
5484 > LIBS=$ac_check_lib_save_LIBS
5485   fi
5486 + echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5487 + echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5488 + if test $ac_cv_lib_m_asin = yes; then
5489 +  cat >>confdefs.h <<_ACEOF
5490 + #define HAVE_LIBM 1
5491 + _ACEOF
5492  
5493 <    done
4871 <    ac_cv_prog_CXXCPP=$CXXCPP
5493 >  LIBS="-lm $LIBS"
5494  
4873 fi
4874  CXXCPP=$ac_cv_prog_CXXCPP
5495   else
5496 <  ac_cv_prog_CXXCPP=$CXXCPP
4877 < fi
4878 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
4879 < echo "${ECHO_T}$CXXCPP" >&6
4880 < ac_preproc_ok=false
4881 < for ac_cxx_preproc_warn_flag in '' yes
4882 < do
4883 <  # Use a header file that comes with gcc, so configuring glibc
4884 <  # with a fresh cross-compiler works.
4885 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4886 <  # <limits.h> exists even on freestanding compilers.
4887 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4888 <  # not just through cpp. "Syntax error" is here to catch this case.
4889 <  cat >conftest.$ac_ext <<_ACEOF
4890 < /* confdefs.h.  */
4891 < _ACEOF
4892 < cat confdefs.h >>conftest.$ac_ext
4893 < cat >>conftest.$ac_ext <<_ACEOF
4894 < /* end confdefs.h.  */
4895 < #ifdef __STDC__
4896 < # include <limits.h>
4897 < #else
4898 < # include <assert.h>
4899 < #endif
4900 <                     Syntax error
4901 < _ACEOF
4902 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4903 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4904 <  ac_status=$?
4905 <  grep -v '^ *+' conftest.er1 >conftest.err
4906 <  rm -f conftest.er1
4907 <  cat conftest.err >&5
4908 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4909 <  (exit $ac_status); } >/dev/null; then
4910 <  if test -s conftest.err; then
4911 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
4912 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
4913 <  else
4914 <    ac_cpp_err=
4915 <  fi
4916 < else
4917 <  ac_cpp_err=yes
5496 >  exit
5497   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
5498  
4925  # Broken: fails on valid input.
4926 continue
4927 fi
4928 rm -f conftest.err conftest.$ac_ext
5499  
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
5500   echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5501   echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5502   if test "${ac_cv_header_stdc+set}" = set; then
# Line 5003 | Line 5513 | int
5513   #include <string.h>
5514   #include <float.h>
5515  
5516 + #ifdef FC_DUMMY_MAIN
5517 + #ifndef FC_DUMMY_MAIN_EQ_F77
5518 + #  ifdef __cplusplus
5519 +     extern "C"
5520 + #  endif
5521 +   int FC_DUMMY_MAIN() { return 1; }
5522 + #endif
5523 + #endif
5524   int
5525   main ()
5526   {
# Line 5020 | Line 5538 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5538    cat conftest.err >&5
5539    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5540    (exit $ac_status); } &&
5541 <         { ac_try='test -z "$ac_cxx_werror_flag"
5541 >         { ac_try='test -z "$ac_c_werror_flag"
5542                           || test ! -s conftest.err'
5543    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5544    (eval $ac_try) 2>&5
# Line 5149 | Line 5667 | _ACEOF
5667  
5668   cat >>confdefs.h <<\_ACEOF
5669   #define STDC_HEADERS 1
5152 _ACEOF
5153
5154 fi
5155
5156 echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
5157 echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
5158 if test "${ac_cv_cxx_namespaces+set}" = set; then
5159  echo $ECHO_N "(cached) $ECHO_C" >&6
5160 else
5161
5162
5163 ac_ext=cc
5164 ac_cpp='$CXXCPP $CPPFLAGS'
5165 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5166 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5167 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5168
5169 cat >conftest.$ac_ext <<_ACEOF
5170 /* confdefs.h.  */
5171 _ACEOF
5172 cat confdefs.h >>conftest.$ac_ext
5173 cat >>conftest.$ac_ext <<_ACEOF
5174 /* end confdefs.h.  */
5175 namespace Outer { namespace Inner { int i = 0; }}
5176 int
5177 main ()
5178 {
5179 using namespace Outer::Inner; return i;
5180  ;
5181  return 0;
5182 }
5183 _ACEOF
5184 rm -f conftest.$ac_objext
5185 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5186  (eval $ac_compile) 2>conftest.er1
5187  ac_status=$?
5188  grep -v '^ *+' conftest.er1 >conftest.err
5189  rm -f conftest.er1
5190  cat conftest.err >&5
5191  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5192  (exit $ac_status); } &&
5193         { ac_try='test -z "$ac_cxx_werror_flag"
5194                         || test ! -s conftest.err'
5195  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5196  (eval $ac_try) 2>&5
5197  ac_status=$?
5198  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5199  (exit $ac_status); }; } &&
5200         { ac_try='test -s conftest.$ac_objext'
5201  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5202  (eval $ac_try) 2>&5
5203  ac_status=$?
5204  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5205  (exit $ac_status); }; }; then
5206  ac_cv_cxx_namespaces=yes
5207 else
5208  echo "$as_me: failed program was:" >&5
5209 sed 's/^/| /' conftest.$ac_ext >&5
5210
5211 ac_cv_cxx_namespaces=no
5212 fi
5213 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5214 ac_ext=cc
5215 ac_cpp='$CXXCPP $CPPFLAGS'
5216 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5217 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5218 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5219
5220
5221 fi
5222 echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
5223 echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
5224 if test "$ac_cv_cxx_namespaces" = yes; then
5225
5226 cat >>confdefs.h <<\_ACEOF
5227 #define HAVE_NAMESPACES
5670   _ACEOF
5671  
5672   fi
# Line 5267 | Line 5709 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5709    cat conftest.err >&5
5710    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5711    (exit $ac_status); } &&
5712 <         { ac_try='test -z "$ac_cxx_werror_flag"
5712 >         { ac_try='test -z "$ac_c_werror_flag"
5713                           || test ! -s conftest.err'
5714    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5715    (eval $ac_try) 2>&5
# Line 5301 | Line 5743 | echo "$as_me:$LINENO: checking whether the compiler su
5743   done
5744  
5745  
5746 < echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
5747 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
5748 < if test "${ac_cv_cxx_have_stl+set}" = set; then
5749 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5746 > #
5747 > # Handle user hints
5748 > #
5749 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5750 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5751 >
5752 > # Check whether --with-zlib or --without-zlib was given.
5753 > if test "${with_zlib+set}" = set; then
5754 >  withval="$with_zlib"
5755 >  if test "$withval" != no ; then
5756 >  echo "$as_me:$LINENO: result: yes" >&5
5757 > echo "${ECHO_T}yes" >&6
5758 >  if test -d "$withval"
5759 >  then
5760 >    ZLIB_HOME="$withval"
5761 >  else
5762 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5763 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5764 >  fi
5765   else
5766 +  echo "$as_me:$LINENO: result: no" >&5
5767 + echo "${ECHO_T}no" >&6
5768 + fi
5769 + fi;
5770  
5771 + ZLIB_HOME=/usr/local
5772 + if test ! -f "${ZLIB_HOME}/include/zlib.h"
5773 + then
5774 +        ZLIB_HOME=/usr
5775 + fi
5776  
5777 + #
5778 + # Locate zlib, if wanted
5779 + #
5780 + if test -n "${ZLIB_HOME}"
5781 + then
5782 +        ZLIB_OLD_LDFLAGS=$LDFLAGS
5783 +        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5784 +        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5785 +        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5786  
5312 ac_ext=cc
5313 ac_cpp='$CXXCPP $CPPFLAGS'
5314 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5315 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5316 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5787  
5788 < cat >conftest.$ac_ext <<_ACEOF
5788 >        ac_ext=c
5789 > ac_cpp='$CPP $CPPFLAGS'
5790 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5791 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5792 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5793 >
5794 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5795 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5796 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5797 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5798 > else
5799 >  ac_check_lib_save_LIBS=$LIBS
5800 > LIBS="-lz  $LIBS"
5801 > cat >conftest.$ac_ext <<_ACEOF
5802   /* confdefs.h.  */
5803   _ACEOF
5804   cat confdefs.h >>conftest.$ac_ext
5805   cat >>conftest.$ac_ext <<_ACEOF
5806   /* end confdefs.h.  */
5807 < #include <list>
5808 < #include <deque>
5809 < #ifdef HAVE_NAMESPACES
5810 < using namespace std;
5807 >
5808 > /* Override any gcc2 internal prototype to avoid an error.  */
5809 > #ifdef __cplusplus
5810 > extern "C"
5811   #endif
5812 + /* We use char because int might match the return type of a gcc2
5813 +   builtin and then its argument prototype would still apply.  */
5814 + char inflateEnd ();
5815 + #ifdef FC_DUMMY_MAIN
5816 + #ifndef FC_DUMMY_MAIN_EQ_F77
5817 + #  ifdef __cplusplus
5818 +     extern "C"
5819 + #  endif
5820 +   int FC_DUMMY_MAIN() { return 1; }
5821 + #endif
5822 + #endif
5823   int
5824   main ()
5825   {
5826 < list<int> x; x.push_back(5);
5333 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
5826 > inflateEnd ();
5827    ;
5828    return 0;
5829   }
5830   _ACEOF
5831 < rm -f conftest.$ac_objext
5832 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5833 <  (eval $ac_compile) 2>conftest.er1
5831 > rm -f conftest.$ac_objext conftest$ac_exeext
5832 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5833 >  (eval $ac_link) 2>conftest.er1
5834    ac_status=$?
5835    grep -v '^ *+' conftest.er1 >conftest.err
5836    rm -f conftest.er1
5837    cat conftest.err >&5
5838    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5839    (exit $ac_status); } &&
5840 <         { ac_try='test -z "$ac_cxx_werror_flag"
5840 >         { ac_try='test -z "$ac_c_werror_flag"
5841                           || test ! -s conftest.err'
5842    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5843    (eval $ac_try) 2>&5
5844    ac_status=$?
5845    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5846    (exit $ac_status); }; } &&
5847 <         { ac_try='test -s conftest.$ac_objext'
5847 >         { ac_try='test -s conftest$ac_exeext'
5848    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5849    (eval $ac_try) 2>&5
5850    ac_status=$?
5851    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5852    (exit $ac_status); }; }; then
5853 <  ac_cv_cxx_have_stl=yes
5853 >  ac_cv_lib_z_inflateEnd=yes
5854   else
5855    echo "$as_me: failed program was:" >&5
5856   sed 's/^/| /' conftest.$ac_ext >&5
5857  
5858 < ac_cv_cxx_have_stl=no
5858 > ac_cv_lib_z_inflateEnd=no
5859   fi
5860 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5861 < ac_ext=cc
5862 < 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 <
5860 > rm -f conftest.err conftest.$ac_objext \
5861 >      conftest$ac_exeext conftest.$ac_ext
5862 > LIBS=$ac_check_lib_save_LIBS
5863   fi
5864 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
5865 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
5866 < if test "$ac_cv_cxx_have_stl" = yes; then
5867 <
5868 < cat >>confdefs.h <<\_ACEOF
5869 < #define HAVE_STL
5382 < _ACEOF
5383 <
5864 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5865 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5866 > if test $ac_cv_lib_z_inflateEnd = yes; then
5867 >  zlib_cv_libz=yes
5868 > else
5869 >  zlib_cv_libz=no
5870   fi
5871  
5872 <
5873 <
5874 <  if test "${ac_cv_header_iostream+set}" = set; then
5875 <  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
5872 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5873 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5874 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5875 > if test "${ac_cv_header_zlib_h+set}" = set; then
5876    echo $ECHO_N "(cached) $ECHO_C" >&6
5877   fi
5878 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
5879 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
5878 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5879 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5880   else
5881    # Is the header compilable?
5882 < echo "$as_me:$LINENO: checking iostream usability" >&5
5883 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
5882 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5883 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5884   cat >conftest.$ac_ext <<_ACEOF
5885   /* confdefs.h.  */
5886   _ACEOF
# Line 5404 | Line 5888 | $ac_includes_default
5888   cat >>conftest.$ac_ext <<_ACEOF
5889   /* end confdefs.h.  */
5890   $ac_includes_default
5891 < #include <iostream>
5891 > #include <zlib.h>
5892   _ACEOF
5893   rm -f conftest.$ac_objext
5894   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5415 | Line 5899 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5899    cat conftest.err >&5
5900    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5901    (exit $ac_status); } &&
5902 <         { ac_try='test -z "$ac_cxx_werror_flag"
5902 >         { ac_try='test -z "$ac_c_werror_flag"
5903                           || test ! -s conftest.err'
5904    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5905    (eval $ac_try) 2>&5
# Line 5440 | Line 5924 | echo "$as_me:$LINENO: checking iostream presence" >&5
5924   echo "${ECHO_T}$ac_header_compiler" >&6
5925  
5926   # Is the header present?
5927 < echo "$as_me:$LINENO: checking iostream presence" >&5
5928 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
5927 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5928 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5929   cat >conftest.$ac_ext <<_ACEOF
5930   /* confdefs.h.  */
5931   _ACEOF
5932   cat confdefs.h >>conftest.$ac_ext
5933   cat >>conftest.$ac_ext <<_ACEOF
5934   /* end confdefs.h.  */
5935 < #include <iostream>
5935 > #include <zlib.h>
5936   _ACEOF
5937   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5938    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5459 | Line 5943 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
5943    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5944    (exit $ac_status); } >/dev/null; then
5945    if test -s conftest.err; then
5946 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5947 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5946 >    ac_cpp_err=$ac_c_preproc_warn_flag
5947 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5948    else
5949      ac_cpp_err=
5950    fi
# Line 5480 | Line 5964 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
5964   echo "${ECHO_T}$ac_header_preproc" >&6
5965  
5966   # So?  What about this header?
5967 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
5967 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5968    yes:no: )
5969 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
5970 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
5971 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
5972 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
5969 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5970 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5971 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5972 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5973      ac_header_preproc=yes
5974      ;;
5975    no:yes:* )
5976 <    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
5977 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
5978 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
5979 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
5980 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
5981 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
5982 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
5983 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
5984 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
5985 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
5986 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
5987 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
5976 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5977 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5978 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5979 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5980 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5981 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5982 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5983 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5984 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5985 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
5986 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
5987 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5988      (
5989        cat <<\_ASBOX
5990   ## ------------------------------ ##
# Line 5511 | Line 5995 | echo "$as_me:$LINENO: checking for iostream" >&5
5995        sed "s/^/$as_me: WARNING:     /" >&2
5996      ;;
5997   esac
5998 < echo "$as_me:$LINENO: checking for iostream" >&5
5999 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
6000 < if test "${ac_cv_header_iostream+set}" = set; then
5998 > echo "$as_me:$LINENO: checking for zlib.h" >&5
5999 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6000 > if test "${ac_cv_header_zlib_h+set}" = set; then
6001    echo $ECHO_N "(cached) $ECHO_C" >&6
6002   else
6003 <  ac_cv_header_iostream=$ac_header_preproc
6003 >  ac_cv_header_zlib_h=$ac_header_preproc
6004   fi
6005 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6006 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
6005 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6006 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6007  
6008   fi
6009 < if test $ac_cv_header_iostream = yes; then
6009 > if test $ac_cv_header_zlib_h = yes; then
6010 >  zlib_cv_zlib_h=yes
6011 > else
6012 >  zlib_cv_zlib_h=no
6013 > fi
6014  
6015  
6016 < cat >>confdefs.h <<\_ACEOF
6017 < #define HAVE_IOSTREAM 1
6018 < _ACEOF
6016 >        ac_ext=c
6017 > ac_cpp='$CPP $CPPFLAGS'
6018 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6019 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6020 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6021  
6022 +        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6023 +        then
6024 +                #
6025 +                # If both library and header were found, use them
6026 +                #
6027  
6028 < else
6029 <
6030 <
5536 < for ac_header in iostream.h
5537 < do
5538 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5539 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5540 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5541 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5542 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6028 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6029 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6030 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6031    echo $ECHO_N "(cached) $ECHO_C" >&6
5544 fi
5545 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5546 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6032   else
6033 <  # Is the header compilable?
6034 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5550 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6033 >  ac_check_lib_save_LIBS=$LIBS
6034 > LIBS="-lz  $LIBS"
6035   cat >conftest.$ac_ext <<_ACEOF
6036   /* confdefs.h.  */
6037   _ACEOF
6038   cat confdefs.h >>conftest.$ac_ext
6039   cat >>conftest.$ac_ext <<_ACEOF
6040   /* end confdefs.h.  */
6041 < $ac_includes_default
6042 < #include <$ac_header>
6041 >
6042 > /* Override any gcc2 internal prototype to avoid an error.  */
6043 > #ifdef __cplusplus
6044 > extern "C"
6045 > #endif
6046 > /* We use char because int might match the return type of a gcc2
6047 >   builtin and then its argument prototype would still apply.  */
6048 > char inflateEnd ();
6049 > #ifdef FC_DUMMY_MAIN
6050 > #ifndef FC_DUMMY_MAIN_EQ_F77
6051 > #  ifdef __cplusplus
6052 >     extern "C"
6053 > #  endif
6054 >   int FC_DUMMY_MAIN() { return 1; }
6055 > #endif
6056 > #endif
6057 > int
6058 > main ()
6059 > {
6060 > inflateEnd ();
6061 >  ;
6062 >  return 0;
6063 > }
6064   _ACEOF
6065 < rm -f conftest.$ac_objext
6066 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6067 <  (eval $ac_compile) 2>conftest.er1
6065 > rm -f conftest.$ac_objext conftest$ac_exeext
6066 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6067 >  (eval $ac_link) 2>conftest.er1
6068    ac_status=$?
6069    grep -v '^ *+' conftest.er1 >conftest.err
6070    rm -f conftest.er1
6071    cat conftest.err >&5
6072    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6073    (exit $ac_status); } &&
6074 <         { ac_try='test -z "$ac_cxx_werror_flag"
6074 >         { ac_try='test -z "$ac_c_werror_flag"
6075                           || test ! -s conftest.err'
6076    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6077    (eval $ac_try) 2>&5
6078    ac_status=$?
6079    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6080    (exit $ac_status); }; } &&
6081 <         { ac_try='test -s conftest.$ac_objext'
6081 >         { ac_try='test -s conftest$ac_exeext'
6082    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6083    (eval $ac_try) 2>&5
6084    ac_status=$?
6085    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6086    (exit $ac_status); }; }; then
6087 <  ac_header_compiler=yes
6087 >  ac_cv_lib_z_inflateEnd=yes
6088   else
6089    echo "$as_me: failed program was:" >&5
6090   sed 's/^/| /' conftest.$ac_ext >&5
6091  
6092 < ac_header_compiler=no
6092 > ac_cv_lib_z_inflateEnd=no
6093   fi
6094 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6095 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6096 < echo "${ECHO_T}$ac_header_compiler" >&6
5592 <
5593 < # Is the header present?
5594 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
5595 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5596 < cat >conftest.$ac_ext <<_ACEOF
5597 < /* confdefs.h.  */
5598 < _ACEOF
5599 < cat confdefs.h >>conftest.$ac_ext
5600 < cat >>conftest.$ac_ext <<_ACEOF
5601 < /* end confdefs.h.  */
5602 < #include <$ac_header>
5603 < _ACEOF
5604 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5605 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5606 <  ac_status=$?
5607 <  grep -v '^ *+' conftest.er1 >conftest.err
5608 <  rm -f conftest.er1
5609 <  cat conftest.err >&5
5610 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5611 <  (exit $ac_status); } >/dev/null; then
5612 <  if test -s conftest.err; then
5613 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5614 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5615 <  else
5616 <    ac_cpp_err=
5617 <  fi
5618 < else
5619 <  ac_cpp_err=yes
6094 > rm -f conftest.err conftest.$ac_objext \
6095 >      conftest$ac_exeext conftest.$ac_ext
6096 > LIBS=$ac_check_lib_save_LIBS
6097   fi
6098 < if test -z "$ac_cpp_err"; then
6099 <  ac_header_preproc=yes
6100 < else
5624 <  echo "$as_me: failed program was:" >&5
5625 < sed 's/^/| /' conftest.$ac_ext >&5
5626 <
5627 <  ac_header_preproc=no
5628 < fi
5629 < rm -f conftest.err conftest.$ac_ext
5630 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5631 < echo "${ECHO_T}$ac_header_preproc" >&6
5632 <
5633 < # So?  What about this header?
5634 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
5635 <  yes:no: )
5636 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5637 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5638 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5639 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5640 <    ac_header_preproc=yes
5641 <    ;;
5642 <  no:yes:* )
5643 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5644 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5645 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5646 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5647 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5648 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5649 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5650 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5651 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5652 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5653 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5654 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5655 <    (
5656 <      cat <<\_ASBOX
5657 < ## ------------------------------ ##
5658 < ## Report this to gezelter@nd.edu ##
5659 < ## ------------------------------ ##
5660 < _ASBOX
5661 <    ) |
5662 <      sed "s/^/$as_me: WARNING:     /" >&2
5663 <    ;;
5664 < esac
5665 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5666 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5667 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5668 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5669 < else
5670 <  eval "$as_ac_Header=\$ac_header_preproc"
5671 < fi
5672 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5673 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5674 <
5675 < fi
5676 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6098 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6099 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6100 > if test $ac_cv_lib_z_inflateEnd = yes; then
6101    cat >>confdefs.h <<_ACEOF
6102 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6102 > #define HAVE_LIBZ 1
6103   _ACEOF
6104  
6105 +  LIBS="-lz $LIBS"
6106 +
6107   fi
6108  
6109 < done
6110 <
6111 <
6109 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6110 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6111 >                echo "$as_me:$LINENO: result: ok" >&5
6112 > echo "${ECHO_T}ok" >&6
6113 >        else
6114 >                #
6115 >                # If either header or library was not found, revert and bomb
6116 >                #
6117 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6118 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6119 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6120 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6121 >                echo "$as_me:$LINENO: result: failed" >&5
6122 > echo "${ECHO_T}failed" >&6
6123 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6124 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6125 >   { (exit 1); exit 1; }; }
6126 >        fi
6127   fi
6128  
6129  
6130  
6131 <
6132 <  if test "${ac_cv_header_iomanip+set}" = set; then
6133 <  echo "$as_me:$LINENO: checking for iomanip" >&5
6134 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
5694 < if test "${ac_cv_header_iomanip+set}" = set; then
6131 > # Checks for header files.
6132 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6133 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6134 > if test "${ac_cv_header_stdc+set}" = set; then
6135    echo $ECHO_N "(cached) $ECHO_C" >&6
5696 fi
5697 echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
5698 echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6136   else
6137 <  # Is the header compilable?
5701 < echo "$as_me:$LINENO: checking iomanip usability" >&5
5702 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
5703 < cat >conftest.$ac_ext <<_ACEOF
6137 >  cat >conftest.$ac_ext <<_ACEOF
6138   /* confdefs.h.  */
6139   _ACEOF
6140   cat confdefs.h >>conftest.$ac_ext
6141   cat >>conftest.$ac_ext <<_ACEOF
6142   /* end confdefs.h.  */
6143 < $ac_includes_default
6144 < #include <iomanip>
6143 > #include <stdlib.h>
6144 > #include <stdarg.h>
6145 > #include <string.h>
6146 > #include <float.h>
6147 >
6148 > #ifdef FC_DUMMY_MAIN
6149 > #ifndef FC_DUMMY_MAIN_EQ_F77
6150 > #  ifdef __cplusplus
6151 >     extern "C"
6152 > #  endif
6153 >   int FC_DUMMY_MAIN() { return 1; }
6154 > #endif
6155 > #endif
6156 > int
6157 > main ()
6158 > {
6159 >
6160 >  ;
6161 >  return 0;
6162 > }
6163   _ACEOF
6164   rm -f conftest.$ac_objext
6165   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5718 | Line 6170 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6170    cat conftest.err >&5
6171    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6172    (exit $ac_status); } &&
6173 <         { ac_try='test -z "$ac_cxx_werror_flag"
6173 >         { ac_try='test -z "$ac_c_werror_flag"
6174                           || test ! -s conftest.err'
6175    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6176    (eval $ac_try) 2>&5
# Line 5731 | Line 6183 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6183    ac_status=$?
6184    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6185    (exit $ac_status); }; }; then
6186 <  ac_header_compiler=yes
6186 >  ac_cv_header_stdc=yes
6187   else
6188    echo "$as_me: failed program was:" >&5
6189   sed 's/^/| /' conftest.$ac_ext >&5
6190  
6191 < ac_header_compiler=no
6191 > ac_cv_header_stdc=no
6192   fi
6193   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5742 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5743 echo "${ECHO_T}$ac_header_compiler" >&6
6194  
6195 < # Is the header present?
6196 < echo "$as_me:$LINENO: checking iomanip presence" >&5
6197 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
5748 < cat >conftest.$ac_ext <<_ACEOF
6195 > if test $ac_cv_header_stdc = yes; then
6196 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6197 >  cat >conftest.$ac_ext <<_ACEOF
6198   /* confdefs.h.  */
6199   _ACEOF
6200   cat confdefs.h >>conftest.$ac_ext
6201   cat >>conftest.$ac_ext <<_ACEOF
6202   /* end confdefs.h.  */
6203 < #include <iomanip>
6203 > #include <string.h>
6204 >
6205   _ACEOF
6206 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6207 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6208 <  ac_status=$?
5759 <  grep -v '^ *+' conftest.er1 >conftest.err
5760 <  rm -f conftest.er1
5761 <  cat conftest.err >&5
5762 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5763 <  (exit $ac_status); } >/dev/null; then
5764 <  if test -s conftest.err; then
5765 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5766 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5767 <  else
5768 <    ac_cpp_err=
5769 <  fi
5770 < else
5771 <  ac_cpp_err=yes
5772 < fi
5773 < if test -z "$ac_cpp_err"; then
5774 <  ac_header_preproc=yes
6206 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6207 >  $EGREP "memchr" >/dev/null 2>&1; then
6208 >  :
6209   else
6210 <  echo "$as_me: failed program was:" >&5
6211 < sed 's/^/| /' conftest.$ac_ext >&5
6210 >  ac_cv_header_stdc=no
6211 > fi
6212 > rm -f conftest*
6213  
5779  ac_header_preproc=no
6214   fi
5781 rm -f conftest.err conftest.$ac_ext
5782 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5783 echo "${ECHO_T}$ac_header_preproc" >&6
6215  
6216 < # So?  What about this header?
6217 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6218 <  yes:no: )
6219 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
6220 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
6221 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
6222 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
6223 <    ac_header_preproc=yes
6224 <    ;;
6225 <  no:yes:* )
6226 <    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
6227 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
6228 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
6229 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
5799 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
5800 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
5801 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
5802 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
5803 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
5804 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
5805 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
5806 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
5807 <    (
5808 <      cat <<\_ASBOX
5809 < ## ------------------------------ ##
5810 < ## Report this to gezelter@nd.edu ##
5811 < ## ------------------------------ ##
5812 < _ASBOX
5813 <    ) |
5814 <      sed "s/^/$as_me: WARNING:     /" >&2
5815 <    ;;
5816 < esac
5817 < echo "$as_me:$LINENO: checking for iomanip" >&5
5818 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
5819 < if test "${ac_cv_header_iomanip+set}" = set; then
5820 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6216 > if test $ac_cv_header_stdc = yes; then
6217 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6218 >  cat >conftest.$ac_ext <<_ACEOF
6219 > /* confdefs.h.  */
6220 > _ACEOF
6221 > cat confdefs.h >>conftest.$ac_ext
6222 > cat >>conftest.$ac_ext <<_ACEOF
6223 > /* end confdefs.h.  */
6224 > #include <stdlib.h>
6225 >
6226 > _ACEOF
6227 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6228 >  $EGREP "free" >/dev/null 2>&1; then
6229 >  :
6230   else
6231 <  ac_cv_header_iomanip=$ac_header_preproc
6231 >  ac_cv_header_stdc=no
6232   fi
6233 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
5825 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6233 > rm -f conftest*
6234  
6235   fi
5828 if test $ac_cv_header_iomanip = yes; then
6236  
6237 + if test $ac_cv_header_stdc = yes; then
6238 +  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6239 +  if test "$cross_compiling" = yes; then
6240 +  :
6241 + else
6242 +  cat >conftest.$ac_ext <<_ACEOF
6243 + /* confdefs.h.  */
6244 + _ACEOF
6245 + cat confdefs.h >>conftest.$ac_ext
6246 + cat >>conftest.$ac_ext <<_ACEOF
6247 + /* end confdefs.h.  */
6248 + #include <ctype.h>
6249 + #if ((' ' & 0x0FF) == 0x020)
6250 + # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6251 + # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6252 + #else
6253 + # define ISLOWER(c) \
6254 +                   (('a' <= (c) && (c) <= 'i') \
6255 +                     || ('j' <= (c) && (c) <= 'r') \
6256 +                     || ('s' <= (c) && (c) <= 'z'))
6257 + # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6258 + #endif
6259  
6260 < cat >>confdefs.h <<\_ACEOF
6261 < #define HAVE_IOMANIP 1
6260 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6261 > int
6262 > main ()
6263 > {
6264 >  int i;
6265 >  for (i = 0; i < 256; i++)
6266 >    if (XOR (islower (i), ISLOWER (i))
6267 >        || toupper (i) != TOUPPER (i))
6268 >      exit(2);
6269 >  exit (0);
6270 > }
6271   _ACEOF
6272 + rm -f conftest$ac_exeext
6273 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6274 +  (eval $ac_link) 2>&5
6275 +  ac_status=$?
6276 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6277 +  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6278 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6279 +  (eval $ac_try) 2>&5
6280 +  ac_status=$?
6281 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6282 +  (exit $ac_status); }; }; then
6283 +  :
6284 + else
6285 +  echo "$as_me: program exited with status $ac_status" >&5
6286 + echo "$as_me: failed program was:" >&5
6287 + sed 's/^/| /' conftest.$ac_ext >&5
6288  
6289 + ( exit $ac_status )
6290 + ac_cv_header_stdc=no
6291 + fi
6292 + rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6293 + fi
6294 + fi
6295 + fi
6296 + echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6297 + echo "${ECHO_T}$ac_cv_header_stdc" >&6
6298 + if test $ac_cv_header_stdc = yes; then
6299  
6300 < else
6300 > cat >>confdefs.h <<\_ACEOF
6301 > #define STDC_HEADERS 1
6302 > _ACEOF
6303  
6304 + fi
6305  
6306 < for ac_header in iomanip.h
6306 >
6307 >
6308 >
6309 >
6310 >
6311 >
6312 >
6313 >
6314 >
6315 >
6316 >
6317 >
6318 >
6319 >
6320 >
6321 >
6322 >
6323 >
6324 >
6325 >
6326 >
6327 >
6328 >
6329 >
6330 >
6331 > 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
6332   do
6333   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6334   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5869 | Line 6361 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6361    cat conftest.err >&5
6362    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6363    (exit $ac_status); } &&
6364 <         { ac_try='test -z "$ac_cxx_werror_flag"
6364 >         { ac_try='test -z "$ac_c_werror_flag"
6365                           || test ! -s conftest.err'
6366    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6367    (eval $ac_try) 2>&5
# Line 5913 | Line 6405 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6405    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6406    (exit $ac_status); } >/dev/null; then
6407    if test -s conftest.err; then
6408 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6409 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6408 >    ac_cpp_err=$ac_c_preproc_warn_flag
6409 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6410    else
6411      ac_cpp_err=
6412    fi
# Line 5934 | Line 6426 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
6426   echo "${ECHO_T}$ac_header_preproc" >&6
6427  
6428   # So?  What about this header?
6429 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6429 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6430    yes:no: )
6431      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6432   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 5986 | Line 6478 | fi
6478   done
6479  
6480  
6481 < fi
6482 <
6483 <
6484 <
5993 <
5994 < for ac_header in cmath
5995 < do
5996 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5997 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5998 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5999 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6000 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6481 > # Checks for typedefs, structures, and compiler characteristics.
6482 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
6483 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
6484 > if test "${ac_cv_header_stdbool_h+set}" = set; then
6485    echo $ECHO_N "(cached) $ECHO_C" >&6
6002 fi
6003 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6004 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6486   else
6487 <  # Is the header compilable?
6007 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6008 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6009 < cat >conftest.$ac_ext <<_ACEOF
6487 >  cat >conftest.$ac_ext <<_ACEOF
6488   /* confdefs.h.  */
6489   _ACEOF
6490   cat confdefs.h >>conftest.$ac_ext
6491   cat >>conftest.$ac_ext <<_ACEOF
6492   /* end confdefs.h.  */
6015 $ac_includes_default
6016 #include <$ac_header>
6017 _ACEOF
6018 rm -f conftest.$ac_objext
6019 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6020  (eval $ac_compile) 2>conftest.er1
6021  ac_status=$?
6022  grep -v '^ *+' conftest.er1 >conftest.err
6023  rm -f conftest.er1
6024  cat conftest.err >&5
6025  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6026  (exit $ac_status); } &&
6027         { ac_try='test -z "$ac_cxx_werror_flag"
6028                         || test ! -s conftest.err'
6029  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6030  (eval $ac_try) 2>&5
6031  ac_status=$?
6032  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6033  (exit $ac_status); }; } &&
6034         { ac_try='test -s conftest.$ac_objext'
6035  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6036  (eval $ac_try) 2>&5
6037  ac_status=$?
6038  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6039  (exit $ac_status); }; }; then
6040  ac_header_compiler=yes
6041 else
6042  echo "$as_me: failed program was:" >&5
6043 sed 's/^/| /' conftest.$ac_ext >&5
6493  
6494 < ac_header_compiler=no
6495 < fi
6496 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6497 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6498 < echo "${ECHO_T}$ac_header_compiler" >&6
6499 <
6500 < # Is the header present?
6501 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6502 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6503 < cat >conftest.$ac_ext <<_ACEOF
6504 < /* confdefs.h.  */
6505 < _ACEOF
6506 < cat confdefs.h >>conftest.$ac_ext
6507 < cat >>conftest.$ac_ext <<_ACEOF
6508 < /* end confdefs.h.  */
6509 < #include <$ac_header>
6510 < _ACEOF
6511 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6512 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6513 <  ac_status=$?
6514 <  grep -v '^ *+' conftest.er1 >conftest.err
6515 <  rm -f conftest.er1
6516 <  cat conftest.err >&5
6517 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6518 <  (exit $ac_status); } >/dev/null; then
6519 <  if test -s conftest.err; then
6520 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6521 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6522 <  else
6523 <    ac_cpp_err=
6524 <  fi
6525 < else
6526 <  ac_cpp_err=yes
6527 < fi
6528 < if test -z "$ac_cpp_err"; then
6529 <  ac_header_preproc=yes
6530 < else
6531 <  echo "$as_me: failed program was:" >&5
6532 < sed 's/^/| /' conftest.$ac_ext >&5
6533 <
6534 <  ac_header_preproc=no
6535 < fi
6536 < rm -f conftest.err conftest.$ac_ext
6537 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6538 < echo "${ECHO_T}$ac_header_preproc" >&6
6539 <
6540 < # So?  What about this header?
6541 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6542 <  yes:no: )
6543 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6544 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6545 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6546 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6547 <    ac_header_preproc=yes
6548 <    ;;
6549 <  no:yes:* )
6550 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6551 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6552 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6553 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6554 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6555 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6556 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6557 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6558 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6559 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6560 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6561 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6562 <    (
6563 <      cat <<\_ASBOX
6564 < ## ------------------------------ ##
6565 < ## Report this to gezelter@nd.edu ##
6566 < ## ------------------------------ ##
6567 < _ASBOX
6568 <    ) |
6569 <      sed "s/^/$as_me: WARNING:     /" >&2
6570 <    ;;
6571 < esac
6572 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6573 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6574 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6575 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6576 < else
6577 <  eval "$as_ac_Header=\$ac_header_preproc"
6578 < fi
6579 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6580 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6581 <
6582 < fi
6583 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6584 <  cat >>confdefs.h <<_ACEOF
6585 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6586 < _ACEOF
6587 <
6588 < fi
6589 <
6590 < done
6591 <
6592 <
6593 <
6594 <
6595 <  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
6596 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
6597 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
6598 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6599 < else
6600 <
6601 <      ac_cv_cxx_have_std_iostream=no
6602 <      ac_cv_cxx_need_use_std_iostream=no
6603 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6604 <
6605 <
6606 <        ac_ext=cc
6607 < ac_cpp='$CXXCPP $CPPFLAGS'
6608 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6609 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6610 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6611 <
6612 <        cat >conftest.$ac_ext <<_ACEOF
6613 < /* confdefs.h.  */
6614 < _ACEOF
6615 < cat confdefs.h >>conftest.$ac_ext
6616 < cat >>conftest.$ac_ext <<_ACEOF
6617 < /* end confdefs.h.  */
6618 <
6619 < #ifdef HAVE_IOSTREAM
6620 < #include <iostream>
6621 < #else
6622 < #include <iostream.h>
6623 < #endif
6624 <
6625 < int
6626 < main ()
6627 < {
6628 < std::cout<<"Hello World"<<std::endl;return 0;
6629 <  ;
6630 <  return 0;
6631 < }
6632 < _ACEOF
6633 < rm -f conftest.$ac_objext
6634 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6635 <  (eval $ac_compile) 2>conftest.er1
6636 <  ac_status=$?
6637 <  grep -v '^ *+' conftest.er1 >conftest.err
6638 <  rm -f conftest.er1
6639 <  cat conftest.err >&5
6640 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6641 <  (exit $ac_status); } &&
6642 <         { ac_try='test -z "$ac_cxx_werror_flag"
6643 <                         || test ! -s conftest.err'
6644 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6645 <  (eval $ac_try) 2>&5
6646 <  ac_status=$?
6647 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6648 <  (exit $ac_status); }; } &&
6649 <         { ac_try='test -s conftest.$ac_objext'
6650 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6651 <  (eval $ac_try) 2>&5
6652 <  ac_status=$?
6653 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6654 <  (exit $ac_status); }; }; then
6655 <  ac_cv_cxx_have_std_iostream=yes
6656 < else
6657 <  echo "$as_me: failed program was:" >&5
6658 < sed 's/^/| /' conftest.$ac_ext >&5
6659 <
6660 < fi
6661 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6662 <        cat >conftest.$ac_ext <<_ACEOF
6663 < /* confdefs.h.  */
6664 < _ACEOF
6665 < cat confdefs.h >>conftest.$ac_ext
6666 < cat >>conftest.$ac_ext <<_ACEOF
6667 < /* end confdefs.h.  */
6668 <
6669 < #define __USE_STD_IOSTREAM 1
6670 < #ifdef HAVE_IOSTREAM
6671 < #include <iostream>
6672 < #else
6673 < #include <iostream.h>
6674 < #endif
6675 <
6676 < int
6677 < main ()
6678 < {
6679 < std::cout<<"Hello World"<<std::endl;return 0;
6680 <  ;
6681 <  return 0;
6682 < }
6683 < _ACEOF
6684 < rm -f conftest.$ac_objext
6685 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6686 <  (eval $ac_compile) 2>conftest.er1
6687 <  ac_status=$?
6688 <  grep -v '^ *+' conftest.er1 >conftest.err
6689 <  rm -f conftest.er1
6690 <  cat conftest.err >&5
6691 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6692 <  (exit $ac_status); } &&
6693 <         { ac_try='test -z "$ac_cxx_werror_flag"
6694 <                         || test ! -s conftest.err'
6695 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6696 <  (eval $ac_try) 2>&5
6697 <  ac_status=$?
6698 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6699 <  (exit $ac_status); }; } &&
6700 <         { ac_try='test -s conftest.$ac_objext'
6701 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6702 <  (eval $ac_try) 2>&5
6703 <  ac_status=$?
6704 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6705 <  (exit $ac_status); }; }; then
6706 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
6707 < else
6708 <  echo "$as_me: failed program was:" >&5
6709 < sed 's/^/| /' conftest.$ac_ext >&5
6710 <
6711 < fi
6712 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6713 <        ac_ext=cc
6714 < ac_cpp='$CXXCPP $CPPFLAGS'
6715 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6716 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6717 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6718 <
6719 <      fi
6720 <
6721 < fi
6722 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
6723 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
6724 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
6725 <
6726 < cat >>confdefs.h <<\_ACEOF
6727 < #define HAVE_STD_IOSTREAM 1
6728 < _ACEOF
6729 <
6730 <  fi
6731 <  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
6732 <
6733 < cat >>confdefs.h <<\_ACEOF
6734 < #define __USE_STD_IOSTREAM 1
6735 < _ACEOF
6736 <
6737 <  fi
6738 <
6739 <
6740 <
6741 <
6742 <  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
6743 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
6744 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
6745 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6746 < else
6747 <
6748 <      ac_cv_cxx_have_std_stl=no
6749 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6750 <
6751 <
6752 <        ac_ext=cc
6753 < ac_cpp='$CXXCPP $CPPFLAGS'
6754 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6755 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6756 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6757 <
6758 <        cat >conftest.$ac_ext <<_ACEOF
6759 < /* confdefs.h.  */
6760 < _ACEOF
6761 < cat confdefs.h >>conftest.$ac_ext
6762 < cat >>conftest.$ac_ext <<_ACEOF
6763 < /* end confdefs.h.  */
6764 < #include <list>
6765 <
6766 < int
6767 < main ()
6768 < {
6769 < std::list<int> foo;return 0;
6770 <  ;
6771 <  return 0;
6772 < }
6773 < _ACEOF
6774 < rm -f conftest.$ac_objext
6775 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6776 <  (eval $ac_compile) 2>conftest.er1
6777 <  ac_status=$?
6778 <  grep -v '^ *+' conftest.er1 >conftest.err
6779 <  rm -f conftest.er1
6780 <  cat conftest.err >&5
6781 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6782 <  (exit $ac_status); } &&
6783 <         { ac_try='test -z "$ac_cxx_werror_flag"
6784 <                         || test ! -s conftest.err'
6785 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6786 <  (eval $ac_try) 2>&5
6787 <  ac_status=$?
6788 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6789 <  (exit $ac_status); }; } &&
6790 <         { ac_try='test -s conftest.$ac_objext'
6791 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6792 <  (eval $ac_try) 2>&5
6793 <  ac_status=$?
6794 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6795 <  (exit $ac_status); }; }; then
6796 <  ac_cv_cxx_have_std_stl=yes
6797 < else
6798 <  echo "$as_me: failed program was:" >&5
6799 < sed 's/^/| /' conftest.$ac_ext >&5
6800 <
6801 < fi
6802 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6803 <        ac_ext=cc
6804 < ac_cpp='$CXXCPP $CPPFLAGS'
6805 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6806 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6807 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6808 <
6809 <      fi
6810 <
6811 < fi
6812 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
6813 < echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
6814 <  if test "$ac_cv_cxx_have_std_stl" = yes; then
6815 <
6816 < cat >>confdefs.h <<\_ACEOF
6817 < #define HAVE_STD_STL 1
6818 < _ACEOF
6819 <
6820 <  fi
6821 <
6822 <
6823 <
6824 <  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
6825 < echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
6826 < if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
6827 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6828 < else
6829 <
6830 <    ac_cv_cxx_have_fstream_attach=no
6831 <
6832 <
6833 <    ac_ext=cc
6834 < ac_cpp='$CXXCPP $CPPFLAGS'
6835 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6836 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6837 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6838 <
6839 <    cat >conftest.$ac_ext <<_ACEOF
6840 < /* confdefs.h.  */
6841 < _ACEOF
6842 < cat confdefs.h >>conftest.$ac_ext
6843 < cat >>conftest.$ac_ext <<_ACEOF
6844 < /* end confdefs.h.  */
6845 <
6846 < #ifdef HAVE_IOSTREAM
6847 < #include <fstream>
6848 < #else
6849 < #include <fstream.h>
6850 < #endif
6851 < #ifdef HAVE_STD_IOSTREAM
6852 < using namespace std;
6853 < #endif
6854 <
6855 < int
6856 < main ()
6857 < {
6858 < int fd=0;ofstream s;s.attach(fd);
6859 <  ;
6860 <  return 0;
6861 < }
6862 < _ACEOF
6863 < rm -f conftest.$ac_objext
6864 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6865 <  (eval $ac_compile) 2>conftest.er1
6866 <  ac_status=$?
6867 <  grep -v '^ *+' conftest.er1 >conftest.err
6868 <  rm -f conftest.er1
6869 <  cat conftest.err >&5
6870 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871 <  (exit $ac_status); } &&
6872 <         { ac_try='test -z "$ac_cxx_werror_flag"
6873 <                         || test ! -s conftest.err'
6874 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6875 <  (eval $ac_try) 2>&5
6876 <  ac_status=$?
6877 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6878 <  (exit $ac_status); }; } &&
6879 <         { ac_try='test -s conftest.$ac_objext'
6880 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6881 <  (eval $ac_try) 2>&5
6882 <  ac_status=$?
6883 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6884 <  (exit $ac_status); }; }; then
6885 <  ac_cv_cxx_have_fstream_attach=yes
6886 < else
6887 <  echo "$as_me: failed program was:" >&5
6888 < sed 's/^/| /' conftest.$ac_ext >&5
6889 <
6890 < fi
6891 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6892 <    ac_ext=cc
6893 < ac_cpp='$CXXCPP $CPPFLAGS'
6894 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6895 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6896 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6897 <
6898 <
6899 < fi
6900 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
6901 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
6902 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
6903 <
6904 < cat >>confdefs.h <<\_ACEOF
6905 < #define HAVE_FSTREAM_ATTACH 1
6906 < _ACEOF
6907 <
6908 <  fi
6909 <
6910 <
6911 <
6912 <  echo "$as_me:$LINENO: checking for fstream::open()" >&5
6913 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
6914 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
6915 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6916 < else
6917 <
6918 <    ac_cv_cxx_have_fstream_open=no
6919 <    ac_cv_cxx_fstream_open_prot=no
6920 <
6921 <
6922 <    ac_ext=cc
6923 < ac_cpp='$CXXCPP $CPPFLAGS'
6924 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6925 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6926 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6927 <
6928 <    # Try with 2 parameters
6929 <    cat >conftest.$ac_ext <<_ACEOF
6930 < /* confdefs.h.  */
6931 < _ACEOF
6932 < cat confdefs.h >>conftest.$ac_ext
6933 < cat >>conftest.$ac_ext <<_ACEOF
6934 < /* end confdefs.h.  */
6935 <
6936 < #ifdef HAVE_IOSTREAM
6937 < #include <fstream>
6938 < #else
6939 < #include <fstream.h>
6940 < #endif
6941 < #ifdef HAVE_STD_IOSTREAM
6942 < using namespace std;
6943 < #endif
6944 <
6945 < int
6946 < main ()
6947 < {
6948 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
6949 <  ;
6950 <  return 0;
6951 < }
6952 < _ACEOF
6953 < rm -f conftest.$ac_objext
6954 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6955 <  (eval $ac_compile) 2>conftest.er1
6956 <  ac_status=$?
6957 <  grep -v '^ *+' conftest.er1 >conftest.err
6958 <  rm -f conftest.er1
6959 <  cat conftest.err >&5
6960 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6961 <  (exit $ac_status); } &&
6962 <         { ac_try='test -z "$ac_cxx_werror_flag"
6963 <                         || test ! -s conftest.err'
6964 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6965 <  (eval $ac_try) 2>&5
6966 <  ac_status=$?
6967 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6968 <  (exit $ac_status); }; } &&
6969 <         { ac_try='test -s conftest.$ac_objext'
6970 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6971 <  (eval $ac_try) 2>&5
6972 <  ac_status=$?
6973 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6974 <  (exit $ac_status); }; }; then
6975 <  ac_cv_cxx_have_fstream_open=yes
6976 < else
6977 <  echo "$as_me: failed program was:" >&5
6978 < sed 's/^/| /' conftest.$ac_ext >&5
6494 > #include <stdbool.h>
6495 > #ifndef bool
6496 > # error bool is not defined
6497 > #endif
6498 > #ifndef false
6499 > # error false is not defined
6500 > #endif
6501 > #if false
6502 > # error false is not 0
6503 > #endif
6504 > #ifndef true
6505 > # error true is not defined
6506 > #endif
6507 > #if true != 1
6508 > # error true is not 1
6509 > #endif
6510 > #ifndef __bool_true_false_are_defined
6511 > # error __bool_true_false_are_defined is not defined
6512 > #endif
6513 >
6514 >        struct s { _Bool s: 1; _Bool t; } s;
6515 >
6516 >        char a[true == 1 ? 1 : -1];
6517 >        char b[false == 0 ? 1 : -1];
6518 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
6519 >        char d[(bool) -0.5 == true ? 1 : -1];
6520 >        bool e = &s;
6521 >        char f[(_Bool) -0.0 == false ? 1 : -1];
6522 >        char g[true];
6523 >        char h[sizeof (_Bool)];
6524 >        char i[sizeof s.t];
6525 >
6526 > #ifdef FC_DUMMY_MAIN
6527 > #ifndef FC_DUMMY_MAIN_EQ_F77
6528 > #  ifdef __cplusplus
6529 >     extern "C"
6530 > #  endif
6531 >   int FC_DUMMY_MAIN() { return 1; }
6532 > #endif
6533 > #endif
6534 > int
6535 > main ()
6536 > {
6537 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
6538 >  ;
6539 >  return 0;
6540 > }
6541 > _ACEOF
6542 > rm -f conftest.$ac_objext
6543 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6544 >  (eval $ac_compile) 2>conftest.er1
6545 >  ac_status=$?
6546 >  grep -v '^ *+' conftest.er1 >conftest.err
6547 >  rm -f conftest.er1
6548 >  cat conftest.err >&5
6549 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6550 >  (exit $ac_status); } &&
6551 >         { ac_try='test -z "$ac_c_werror_flag"
6552 >                         || test ! -s conftest.err'
6553 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6554 >  (eval $ac_try) 2>&5
6555 >  ac_status=$?
6556 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6557 >  (exit $ac_status); }; } &&
6558 >         { ac_try='test -s conftest.$ac_objext'
6559 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6560 >  (eval $ac_try) 2>&5
6561 >  ac_status=$?
6562 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6563 >  (exit $ac_status); }; }; then
6564 >  ac_cv_header_stdbool_h=yes
6565 > else
6566 >  echo "$as_me: failed program was:" >&5
6567 > sed 's/^/| /' conftest.$ac_ext >&5
6568 >
6569 > ac_cv_header_stdbool_h=no
6570 > fi
6571 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6572 > fi
6573 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
6574 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
6575 > echo "$as_me:$LINENO: checking for _Bool" >&5
6576 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
6577 > if test "${ac_cv_type__Bool+set}" = set; then
6578 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6579 > else
6580 >  cat >conftest.$ac_ext <<_ACEOF
6581 > /* confdefs.h.  */
6582 > _ACEOF
6583 > cat confdefs.h >>conftest.$ac_ext
6584 > cat >>conftest.$ac_ext <<_ACEOF
6585 > /* end confdefs.h.  */
6586 > $ac_includes_default
6587 > #ifdef FC_DUMMY_MAIN
6588 > #ifndef FC_DUMMY_MAIN_EQ_F77
6589 > #  ifdef __cplusplus
6590 >     extern "C"
6591 > #  endif
6592 >   int FC_DUMMY_MAIN() { return 1; }
6593 > #endif
6594 > #endif
6595 > int
6596 > main ()
6597 > {
6598 > if ((_Bool *) 0)
6599 >  return 0;
6600 > if (sizeof (_Bool))
6601 >  return 0;
6602 >  ;
6603 >  return 0;
6604 > }
6605 > _ACEOF
6606 > rm -f conftest.$ac_objext
6607 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6608 >  (eval $ac_compile) 2>conftest.er1
6609 >  ac_status=$?
6610 >  grep -v '^ *+' conftest.er1 >conftest.err
6611 >  rm -f conftest.er1
6612 >  cat conftest.err >&5
6613 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6614 >  (exit $ac_status); } &&
6615 >         { ac_try='test -z "$ac_c_werror_flag"
6616 >                         || test ! -s conftest.err'
6617 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6618 >  (eval $ac_try) 2>&5
6619 >  ac_status=$?
6620 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6621 >  (exit $ac_status); }; } &&
6622 >         { ac_try='test -s conftest.$ac_objext'
6623 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6624 >  (eval $ac_try) 2>&5
6625 >  ac_status=$?
6626 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6627 >  (exit $ac_status); }; }; then
6628 >  ac_cv_type__Bool=yes
6629 > else
6630 >  echo "$as_me: failed program was:" >&5
6631 > sed 's/^/| /' conftest.$ac_ext >&5
6632 >
6633 > ac_cv_type__Bool=no
6634 > fi
6635 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6636 > fi
6637 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
6638 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
6639 > if test $ac_cv_type__Bool = yes; then
6640 >
6641 > cat >>confdefs.h <<_ACEOF
6642 > #define HAVE__BOOL 1
6643 > _ACEOF
6644 >
6645 >
6646 > fi
6647 >
6648 > if test $ac_cv_header_stdbool_h = yes; then
6649 >
6650 > cat >>confdefs.h <<\_ACEOF
6651 > #define HAVE_STDBOOL_H 1
6652 > _ACEOF
6653 >
6654 > fi
6655 >
6656 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
6657 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
6658 > if test "${ac_cv_c_const+set}" = set; then
6659 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6660 > else
6661 >  cat >conftest.$ac_ext <<_ACEOF
6662 > /* confdefs.h.  */
6663 > _ACEOF
6664 > cat confdefs.h >>conftest.$ac_ext
6665 > cat >>conftest.$ac_ext <<_ACEOF
6666 > /* end confdefs.h.  */
6667 >
6668 > #ifdef FC_DUMMY_MAIN
6669 > #ifndef FC_DUMMY_MAIN_EQ_F77
6670 > #  ifdef __cplusplus
6671 >     extern "C"
6672 > #  endif
6673 >   int FC_DUMMY_MAIN() { return 1; }
6674 > #endif
6675 > #endif
6676 > int
6677 > main ()
6678 > {
6679 > /* FIXME: Include the comments suggested by Paul. */
6680 > #ifndef __cplusplus
6681 >  /* Ultrix mips cc rejects this.  */
6682 >  typedef int charset[2];
6683 >  const charset x;
6684 >  /* SunOS 4.1.1 cc rejects this.  */
6685 >  char const *const *ccp;
6686 >  char **p;
6687 >  /* NEC SVR4.0.2 mips cc rejects this.  */
6688 >  struct point {int x, y;};
6689 >  static struct point const zero = {0,0};
6690 >  /* AIX XL C 1.02.0.0 rejects this.
6691 >     It does not let you subtract one const X* pointer from another in
6692 >     an arm of an if-expression whose if-part is not a constant
6693 >     expression */
6694 >  const char *g = "string";
6695 >  ccp = &g + (g ? g-g : 0);
6696 >  /* HPUX 7.0 cc rejects these. */
6697 >  ++ccp;
6698 >  p = (char**) ccp;
6699 >  ccp = (char const *const *) p;
6700 >  { /* SCO 3.2v4 cc rejects this.  */
6701 >    char *t;
6702 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
6703 >
6704 >    *t++ = 0;
6705 >  }
6706 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6707 >    int x[] = {25, 17};
6708 >    const int *foo = &x[0];
6709 >    ++foo;
6710 >  }
6711 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6712 >    typedef const int *iptr;
6713 >    iptr p = 0;
6714 >    ++p;
6715 >  }
6716 >  { /* AIX XL C 1.02.0.0 rejects this saying
6717 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6718 >    struct s { int j; const int *ap[3]; };
6719 >    struct s *b; b->j = 5;
6720 >  }
6721 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6722 >    const int foo = 10;
6723 >  }
6724 > #endif
6725 >
6726 >  ;
6727 >  return 0;
6728 > }
6729 > _ACEOF
6730 > rm -f conftest.$ac_objext
6731 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6732 >  (eval $ac_compile) 2>conftest.er1
6733 >  ac_status=$?
6734 >  grep -v '^ *+' conftest.er1 >conftest.err
6735 >  rm -f conftest.er1
6736 >  cat conftest.err >&5
6737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738 >  (exit $ac_status); } &&
6739 >         { ac_try='test -z "$ac_c_werror_flag"
6740 >                         || test ! -s conftest.err'
6741 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6742 >  (eval $ac_try) 2>&5
6743 >  ac_status=$?
6744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6745 >  (exit $ac_status); }; } &&
6746 >         { ac_try='test -s conftest.$ac_objext'
6747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6748 >  (eval $ac_try) 2>&5
6749 >  ac_status=$?
6750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6751 >  (exit $ac_status); }; }; then
6752 >  ac_cv_c_const=yes
6753 > else
6754 >  echo "$as_me: failed program was:" >&5
6755 > sed 's/^/| /' conftest.$ac_ext >&5
6756 >
6757 > ac_cv_c_const=no
6758 > fi
6759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760 > fi
6761 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
6762 > echo "${ECHO_T}$ac_cv_c_const" >&6
6763 > if test $ac_cv_c_const = no; then
6764 >
6765 > cat >>confdefs.h <<\_ACEOF
6766 > #define const
6767 > _ACEOF
6768 >
6769 > fi
6770 >
6771 > echo "$as_me:$LINENO: checking for inline" >&5
6772 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
6773 > if test "${ac_cv_c_inline+set}" = set; then
6774 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6775 > else
6776 >  ac_cv_c_inline=no
6777 > for ac_kw in inline __inline__ __inline; do
6778 >  cat >conftest.$ac_ext <<_ACEOF
6779 > /* confdefs.h.  */
6780 > _ACEOF
6781 > cat confdefs.h >>conftest.$ac_ext
6782 > cat >>conftest.$ac_ext <<_ACEOF
6783 > /* end confdefs.h.  */
6784 > #ifndef __cplusplus
6785 > typedef int foo_t;
6786 > static $ac_kw foo_t static_foo () {return 0; }
6787 > $ac_kw foo_t foo () {return 0; }
6788 > #endif
6789 >
6790 > _ACEOF
6791 > rm -f conftest.$ac_objext
6792 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6793 >  (eval $ac_compile) 2>conftest.er1
6794 >  ac_status=$?
6795 >  grep -v '^ *+' conftest.er1 >conftest.err
6796 >  rm -f conftest.er1
6797 >  cat conftest.err >&5
6798 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6799 >  (exit $ac_status); } &&
6800 >         { ac_try='test -z "$ac_c_werror_flag"
6801 >                         || test ! -s conftest.err'
6802 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6803 >  (eval $ac_try) 2>&5
6804 >  ac_status=$?
6805 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6806 >  (exit $ac_status); }; } &&
6807 >         { ac_try='test -s conftest.$ac_objext'
6808 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6809 >  (eval $ac_try) 2>&5
6810 >  ac_status=$?
6811 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6812 >  (exit $ac_status); }; }; then
6813 >  ac_cv_c_inline=$ac_kw; break
6814 > else
6815 >  echo "$as_me: failed program was:" >&5
6816 > sed 's/^/| /' conftest.$ac_ext >&5
6817 >
6818 > fi
6819 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6820 > done
6821 >
6822 > fi
6823 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
6824 > echo "${ECHO_T}$ac_cv_c_inline" >&6
6825 >
6826 >
6827 > case $ac_cv_c_inline in
6828 >  inline | yes) ;;
6829 >  *)
6830 >    case $ac_cv_c_inline in
6831 >      no) ac_val=;;
6832 >      *) ac_val=$ac_cv_c_inline;;
6833 >    esac
6834 >    cat >>confdefs.h <<_ACEOF
6835 > #ifndef __cplusplus
6836 > #define inline $ac_val
6837 > #endif
6838 > _ACEOF
6839 >    ;;
6840 > esac
6841 >
6842 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
6843 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
6844 > if test "${ac_cv_c_restrict+set}" = set; then
6845 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6846 > else
6847 >  ac_cv_c_restrict=no
6848 >   # Try the official restrict keyword, then gcc's __restrict, and
6849 >   # the less common variants.
6850 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
6851 >     cat >conftest.$ac_ext <<_ACEOF
6852 > /* confdefs.h.  */
6853 > _ACEOF
6854 > cat confdefs.h >>conftest.$ac_ext
6855 > cat >>conftest.$ac_ext <<_ACEOF
6856 > /* end confdefs.h.  */
6857 > float * $ac_kw x;
6858 > _ACEOF
6859 > rm -f conftest.$ac_objext
6860 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6861 >  (eval $ac_compile) 2>conftest.er1
6862 >  ac_status=$?
6863 >  grep -v '^ *+' conftest.er1 >conftest.err
6864 >  rm -f conftest.er1
6865 >  cat conftest.err >&5
6866 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6867 >  (exit $ac_status); } &&
6868 >         { ac_try='test -z "$ac_c_werror_flag"
6869 >                         || test ! -s conftest.err'
6870 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6871 >  (eval $ac_try) 2>&5
6872 >  ac_status=$?
6873 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6874 >  (exit $ac_status); }; } &&
6875 >         { ac_try='test -s conftest.$ac_objext'
6876 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6877 >  (eval $ac_try) 2>&5
6878 >  ac_status=$?
6879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6880 >  (exit $ac_status); }; }; then
6881 >  ac_cv_c_restrict=$ac_kw; break
6882 > else
6883 >  echo "$as_me: failed program was:" >&5
6884 > sed 's/^/| /' conftest.$ac_ext >&5
6885 >
6886 > fi
6887 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6888 >   done
6889 >
6890 > fi
6891 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
6892 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
6893 > case $ac_cv_c_restrict in
6894 >   restrict) ;;
6895 >   no)
6896 > cat >>confdefs.h <<\_ACEOF
6897 > #define restrict
6898 > _ACEOF
6899 > ;;
6900 >   *)  cat >>confdefs.h <<_ACEOF
6901 > #define restrict $ac_cv_c_restrict
6902 > _ACEOF
6903 > ;;
6904 > esac
6905 >
6906 > echo "$as_me:$LINENO: checking for size_t" >&5
6907 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
6908 > if test "${ac_cv_type_size_t+set}" = set; then
6909 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6910 > else
6911 >  cat >conftest.$ac_ext <<_ACEOF
6912 > /* confdefs.h.  */
6913 > _ACEOF
6914 > cat confdefs.h >>conftest.$ac_ext
6915 > cat >>conftest.$ac_ext <<_ACEOF
6916 > /* end confdefs.h.  */
6917 > $ac_includes_default
6918 > #ifdef FC_DUMMY_MAIN
6919 > #ifndef FC_DUMMY_MAIN_EQ_F77
6920 > #  ifdef __cplusplus
6921 >     extern "C"
6922 > #  endif
6923 >   int FC_DUMMY_MAIN() { return 1; }
6924 > #endif
6925 > #endif
6926 > int
6927 > main ()
6928 > {
6929 > if ((size_t *) 0)
6930 >  return 0;
6931 > if (sizeof (size_t))
6932 >  return 0;
6933 >  ;
6934 >  return 0;
6935 > }
6936 > _ACEOF
6937 > rm -f conftest.$ac_objext
6938 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6939 >  (eval $ac_compile) 2>conftest.er1
6940 >  ac_status=$?
6941 >  grep -v '^ *+' conftest.er1 >conftest.err
6942 >  rm -f conftest.er1
6943 >  cat conftest.err >&5
6944 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6945 >  (exit $ac_status); } &&
6946 >         { ac_try='test -z "$ac_c_werror_flag"
6947 >                         || test ! -s conftest.err'
6948 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6949 >  (eval $ac_try) 2>&5
6950 >  ac_status=$?
6951 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6952 >  (exit $ac_status); }; } &&
6953 >         { ac_try='test -s conftest.$ac_objext'
6954 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6955 >  (eval $ac_try) 2>&5
6956 >  ac_status=$?
6957 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6958 >  (exit $ac_status); }; }; then
6959 >  ac_cv_type_size_t=yes
6960 > else
6961 >  echo "$as_me: failed program was:" >&5
6962 > sed 's/^/| /' conftest.$ac_ext >&5
6963 >
6964 > ac_cv_type_size_t=no
6965 > fi
6966 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6967 > fi
6968 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
6969 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
6970 > if test $ac_cv_type_size_t = yes; then
6971 >  :
6972 > else
6973 >
6974 > cat >>confdefs.h <<_ACEOF
6975 > #define size_t unsigned
6976 > _ACEOF
6977 >
6978 > fi
6979 >
6980 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6981 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6982 > if test "${ac_cv_header_time+set}" = set; then
6983 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6984 > else
6985 >  cat >conftest.$ac_ext <<_ACEOF
6986 > /* confdefs.h.  */
6987 > _ACEOF
6988 > cat confdefs.h >>conftest.$ac_ext
6989 > cat >>conftest.$ac_ext <<_ACEOF
6990 > /* end confdefs.h.  */
6991 > #include <sys/types.h>
6992 > #include <sys/time.h>
6993 > #include <time.h>
6994 >
6995 > #ifdef FC_DUMMY_MAIN
6996 > #ifndef FC_DUMMY_MAIN_EQ_F77
6997 > #  ifdef __cplusplus
6998 >     extern "C"
6999 > #  endif
7000 >   int FC_DUMMY_MAIN() { return 1; }
7001 > #endif
7002 > #endif
7003 > int
7004 > main ()
7005 > {
7006 > if ((struct tm *) 0)
7007 > return 0;
7008 >  ;
7009 >  return 0;
7010 > }
7011 > _ACEOF
7012 > rm -f conftest.$ac_objext
7013 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7014 >  (eval $ac_compile) 2>conftest.er1
7015 >  ac_status=$?
7016 >  grep -v '^ *+' conftest.er1 >conftest.err
7017 >  rm -f conftest.er1
7018 >  cat conftest.err >&5
7019 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7020 >  (exit $ac_status); } &&
7021 >         { ac_try='test -z "$ac_c_werror_flag"
7022 >                         || test ! -s conftest.err'
7023 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7024 >  (eval $ac_try) 2>&5
7025 >  ac_status=$?
7026 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7027 >  (exit $ac_status); }; } &&
7028 >         { ac_try='test -s conftest.$ac_objext'
7029 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7030 >  (eval $ac_try) 2>&5
7031 >  ac_status=$?
7032 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033 >  (exit $ac_status); }; }; then
7034 >  ac_cv_header_time=yes
7035 > else
7036 >  echo "$as_me: failed program was:" >&5
7037 > sed 's/^/| /' conftest.$ac_ext >&5
7038 >
7039 > ac_cv_header_time=no
7040 > fi
7041 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7042 > fi
7043 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7044 > echo "${ECHO_T}$ac_cv_header_time" >&6
7045 > if test $ac_cv_header_time = yes; then
7046 >
7047 > cat >>confdefs.h <<\_ACEOF
7048 > #define TIME_WITH_SYS_TIME 1
7049 > _ACEOF
7050 >
7051 > fi
7052 >
7053 > echo "$as_me:$LINENO: checking for clock_t" >&5
7054 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7055 > if test "${ac_cv_type_clock_t+set}" = set; then
7056 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7057 > else
7058 >  cat >conftest.$ac_ext <<_ACEOF
7059 > /* confdefs.h.  */
7060 > _ACEOF
7061 > cat confdefs.h >>conftest.$ac_ext
7062 > cat >>conftest.$ac_ext <<_ACEOF
7063 > /* end confdefs.h.  */
7064 > $ac_includes_default
7065 > #ifdef FC_DUMMY_MAIN
7066 > #ifndef FC_DUMMY_MAIN_EQ_F77
7067 > #  ifdef __cplusplus
7068 >     extern "C"
7069 > #  endif
7070 >   int FC_DUMMY_MAIN() { return 1; }
7071 > #endif
7072 > #endif
7073 > int
7074 > main ()
7075 > {
7076 > if ((clock_t *) 0)
7077 >  return 0;
7078 > if (sizeof (clock_t))
7079 >  return 0;
7080 >  ;
7081 >  return 0;
7082 > }
7083 > _ACEOF
7084 > rm -f conftest.$ac_objext
7085 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7086 >  (eval $ac_compile) 2>conftest.er1
7087 >  ac_status=$?
7088 >  grep -v '^ *+' conftest.er1 >conftest.err
7089 >  rm -f conftest.er1
7090 >  cat conftest.err >&5
7091 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7092 >  (exit $ac_status); } &&
7093 >         { ac_try='test -z "$ac_c_werror_flag"
7094 >                         || test ! -s conftest.err'
7095 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7096 >  (eval $ac_try) 2>&5
7097 >  ac_status=$?
7098 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7099 >  (exit $ac_status); }; } &&
7100 >         { ac_try='test -s conftest.$ac_objext'
7101 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7102 >  (eval $ac_try) 2>&5
7103 >  ac_status=$?
7104 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7105 >  (exit $ac_status); }; }; then
7106 >  ac_cv_type_clock_t=yes
7107 > else
7108 >  echo "$as_me: failed program was:" >&5
7109 > sed 's/^/| /' conftest.$ac_ext >&5
7110 >
7111 > ac_cv_type_clock_t=no
7112 > fi
7113 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7114 > fi
7115 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7116 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7117 > if test $ac_cv_type_clock_t = yes; then
7118 >
7119 > cat >>confdefs.h <<_ACEOF
7120 > #define HAVE_CLOCK_T 1
7121 > _ACEOF
7122 >
7123 >
7124 > fi
7125 >
7126 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7127 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7128 > if test "${ac_cv_c_const+set}" = set; then
7129 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7130 > else
7131 >  cat >conftest.$ac_ext <<_ACEOF
7132 > /* confdefs.h.  */
7133 > _ACEOF
7134 > cat confdefs.h >>conftest.$ac_ext
7135 > cat >>conftest.$ac_ext <<_ACEOF
7136 > /* end confdefs.h.  */
7137 >
7138 > #ifdef FC_DUMMY_MAIN
7139 > #ifndef FC_DUMMY_MAIN_EQ_F77
7140 > #  ifdef __cplusplus
7141 >     extern "C"
7142 > #  endif
7143 >   int FC_DUMMY_MAIN() { return 1; }
7144 > #endif
7145 > #endif
7146 > int
7147 > main ()
7148 > {
7149 > /* FIXME: Include the comments suggested by Paul. */
7150 > #ifndef __cplusplus
7151 >  /* Ultrix mips cc rejects this.  */
7152 >  typedef int charset[2];
7153 >  const charset x;
7154 >  /* SunOS 4.1.1 cc rejects this.  */
7155 >  char const *const *ccp;
7156 >  char **p;
7157 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7158 >  struct point {int x, y;};
7159 >  static struct point const zero = {0,0};
7160 >  /* AIX XL C 1.02.0.0 rejects this.
7161 >     It does not let you subtract one const X* pointer from another in
7162 >     an arm of an if-expression whose if-part is not a constant
7163 >     expression */
7164 >  const char *g = "string";
7165 >  ccp = &g + (g ? g-g : 0);
7166 >  /* HPUX 7.0 cc rejects these. */
7167 >  ++ccp;
7168 >  p = (char**) ccp;
7169 >  ccp = (char const *const *) p;
7170 >  { /* SCO 3.2v4 cc rejects this.  */
7171 >    char *t;
7172 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7173 >
7174 >    *t++ = 0;
7175 >  }
7176 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7177 >    int x[] = {25, 17};
7178 >    const int *foo = &x[0];
7179 >    ++foo;
7180 >  }
7181 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7182 >    typedef const int *iptr;
7183 >    iptr p = 0;
7184 >    ++p;
7185 >  }
7186 >  { /* AIX XL C 1.02.0.0 rejects this saying
7187 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7188 >    struct s { int j; const int *ap[3]; };
7189 >    struct s *b; b->j = 5;
7190 >  }
7191 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7192 >    const int foo = 10;
7193 >  }
7194 > #endif
7195 >
7196 >  ;
7197 >  return 0;
7198 > }
7199 > _ACEOF
7200 > rm -f conftest.$ac_objext
7201 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7202 >  (eval $ac_compile) 2>conftest.er1
7203 >  ac_status=$?
7204 >  grep -v '^ *+' conftest.er1 >conftest.err
7205 >  rm -f conftest.er1
7206 >  cat conftest.err >&5
7207 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7208 >  (exit $ac_status); } &&
7209 >         { ac_try='test -z "$ac_c_werror_flag"
7210 >                         || test ! -s conftest.err'
7211 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7212 >  (eval $ac_try) 2>&5
7213 >  ac_status=$?
7214 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7215 >  (exit $ac_status); }; } &&
7216 >         { ac_try='test -s conftest.$ac_objext'
7217 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7218 >  (eval $ac_try) 2>&5
7219 >  ac_status=$?
7220 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7221 >  (exit $ac_status); }; }; then
7222 >  ac_cv_c_const=yes
7223 > else
7224 >  echo "$as_me: failed program was:" >&5
7225 > sed 's/^/| /' conftest.$ac_ext >&5
7226 >
7227 > ac_cv_c_const=no
7228 > fi
7229 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7230 > fi
7231 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7232 > echo "${ECHO_T}$ac_cv_c_const" >&6
7233 > if test $ac_cv_c_const = no; then
7234 >
7235 > cat >>confdefs.h <<\_ACEOF
7236 > #define const
7237 > _ACEOF
7238 >
7239 > fi
7240 >
7241 > echo "$as_me:$LINENO: checking for inline" >&5
7242 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7243 > if test "${ac_cv_c_inline+set}" = set; then
7244 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7245 > else
7246 >  ac_cv_c_inline=no
7247 > for ac_kw in inline __inline__ __inline; do
7248 >  cat >conftest.$ac_ext <<_ACEOF
7249 > /* confdefs.h.  */
7250 > _ACEOF
7251 > cat confdefs.h >>conftest.$ac_ext
7252 > cat >>conftest.$ac_ext <<_ACEOF
7253 > /* end confdefs.h.  */
7254 > #ifndef __cplusplus
7255 > typedef int foo_t;
7256 > static $ac_kw foo_t static_foo () {return 0; }
7257 > $ac_kw foo_t foo () {return 0; }
7258 > #endif
7259 >
7260 > _ACEOF
7261 > rm -f conftest.$ac_objext
7262 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7263 >  (eval $ac_compile) 2>conftest.er1
7264 >  ac_status=$?
7265 >  grep -v '^ *+' conftest.er1 >conftest.err
7266 >  rm -f conftest.er1
7267 >  cat conftest.err >&5
7268 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7269 >  (exit $ac_status); } &&
7270 >         { ac_try='test -z "$ac_c_werror_flag"
7271 >                         || test ! -s conftest.err'
7272 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7273 >  (eval $ac_try) 2>&5
7274 >  ac_status=$?
7275 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7276 >  (exit $ac_status); }; } &&
7277 >         { ac_try='test -s conftest.$ac_objext'
7278 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7279 >  (eval $ac_try) 2>&5
7280 >  ac_status=$?
7281 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7282 >  (exit $ac_status); }; }; then
7283 >  ac_cv_c_inline=$ac_kw; break
7284 > else
7285 >  echo "$as_me: failed program was:" >&5
7286 > sed 's/^/| /' conftest.$ac_ext >&5
7287 >
7288 > fi
7289 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7290 > done
7291 >
7292 > fi
7293 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7294 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7295 >
7296 >
7297 > case $ac_cv_c_inline in
7298 >  inline | yes) ;;
7299 >  *)
7300 >    case $ac_cv_c_inline in
7301 >      no) ac_val=;;
7302 >      *) ac_val=$ac_cv_c_inline;;
7303 >    esac
7304 >    cat >>confdefs.h <<_ACEOF
7305 > #ifndef __cplusplus
7306 > #define inline $ac_val
7307 > #endif
7308 > _ACEOF
7309 >    ;;
7310 > esac
7311 >
7312 >
7313 > # Checks for library functions.
7314 >
7315 > for ac_header in stdlib.h
7316 > do
7317 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7318 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7319 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7320 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7321 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7322 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7323 > fi
7324 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7325 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7326 > else
7327 >  # Is the header compilable?
7328 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7329 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7330 > cat >conftest.$ac_ext <<_ACEOF
7331 > /* confdefs.h.  */
7332 > _ACEOF
7333 > cat confdefs.h >>conftest.$ac_ext
7334 > cat >>conftest.$ac_ext <<_ACEOF
7335 > /* end confdefs.h.  */
7336 > $ac_includes_default
7337 > #include <$ac_header>
7338 > _ACEOF
7339 > rm -f conftest.$ac_objext
7340 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7341 >  (eval $ac_compile) 2>conftest.er1
7342 >  ac_status=$?
7343 >  grep -v '^ *+' conftest.er1 >conftest.err
7344 >  rm -f conftest.er1
7345 >  cat conftest.err >&5
7346 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7347 >  (exit $ac_status); } &&
7348 >         { ac_try='test -z "$ac_c_werror_flag"
7349 >                         || test ! -s conftest.err'
7350 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7351 >  (eval $ac_try) 2>&5
7352 >  ac_status=$?
7353 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7354 >  (exit $ac_status); }; } &&
7355 >         { ac_try='test -s conftest.$ac_objext'
7356 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7357 >  (eval $ac_try) 2>&5
7358 >  ac_status=$?
7359 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7360 >  (exit $ac_status); }; }; then
7361 >  ac_header_compiler=yes
7362 > else
7363 >  echo "$as_me: failed program was:" >&5
7364 > sed 's/^/| /' conftest.$ac_ext >&5
7365 >
7366 > ac_header_compiler=no
7367 > fi
7368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7369 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7370 > echo "${ECHO_T}$ac_header_compiler" >&6
7371 >
7372 > # Is the header present?
7373 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7374 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7375 > cat >conftest.$ac_ext <<_ACEOF
7376 > /* confdefs.h.  */
7377 > _ACEOF
7378 > cat confdefs.h >>conftest.$ac_ext
7379 > cat >>conftest.$ac_ext <<_ACEOF
7380 > /* end confdefs.h.  */
7381 > #include <$ac_header>
7382 > _ACEOF
7383 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7384 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7385 >  ac_status=$?
7386 >  grep -v '^ *+' conftest.er1 >conftest.err
7387 >  rm -f conftest.er1
7388 >  cat conftest.err >&5
7389 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7390 >  (exit $ac_status); } >/dev/null; then
7391 >  if test -s conftest.err; then
7392 >    ac_cpp_err=$ac_c_preproc_warn_flag
7393 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7394 >  else
7395 >    ac_cpp_err=
7396 >  fi
7397 > else
7398 >  ac_cpp_err=yes
7399 > fi
7400 > if test -z "$ac_cpp_err"; then
7401 >  ac_header_preproc=yes
7402 > else
7403 >  echo "$as_me: failed program was:" >&5
7404 > sed 's/^/| /' conftest.$ac_ext >&5
7405 >
7406 >  ac_header_preproc=no
7407 > fi
7408 > rm -f conftest.err conftest.$ac_ext
7409 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7410 > echo "${ECHO_T}$ac_header_preproc" >&6
7411 >
7412 > # So?  What about this header?
7413 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7414 >  yes:no: )
7415 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7416 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7417 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7418 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7419 >    ac_header_preproc=yes
7420 >    ;;
7421 >  no:yes:* )
7422 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7423 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7424 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7425 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7426 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7427 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7428 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7429 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7430 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7431 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7432 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7433 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7434 >    (
7435 >      cat <<\_ASBOX
7436 > ## ------------------------------ ##
7437 > ## Report this to gezelter@nd.edu ##
7438 > ## ------------------------------ ##
7439 > _ASBOX
7440 >    ) |
7441 >      sed "s/^/$as_me: WARNING:     /" >&2
7442 >    ;;
7443 > esac
7444 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7445 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7446 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7447 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7448 > else
7449 >  eval "$as_ac_Header=\$ac_header_preproc"
7450 > fi
7451 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7452 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7453 >
7454 > fi
7455 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7456 >  cat >>confdefs.h <<_ACEOF
7457 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7458 > _ACEOF
7459 >
7460 > fi
7461 >
7462 > done
7463 >
7464 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
7465 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
7466 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
7467 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7468 > else
7469 >  if test "$cross_compiling" = yes; then
7470 >  ac_cv_func_malloc_0_nonnull=no
7471 > else
7472 >  cat >conftest.$ac_ext <<_ACEOF
7473 > /* confdefs.h.  */
7474 > _ACEOF
7475 > cat confdefs.h >>conftest.$ac_ext
7476 > cat >>conftest.$ac_ext <<_ACEOF
7477 > /* end confdefs.h.  */
7478 > #if STDC_HEADERS || HAVE_STDLIB_H
7479 > # include <stdlib.h>
7480 > #else
7481 > char *malloc ();
7482 > #endif
7483 >
7484 > #ifdef FC_DUMMY_MAIN
7485 > #ifndef FC_DUMMY_MAIN_EQ_F77
7486 > #  ifdef __cplusplus
7487 >     extern "C"
7488 > #  endif
7489 >   int FC_DUMMY_MAIN() { return 1; }
7490 > #endif
7491 > #endif
7492 > int
7493 > main ()
7494 > {
7495 > exit (malloc (0) ? 0 : 1);
7496 >  ;
7497 >  return 0;
7498 > }
7499 > _ACEOF
7500 > rm -f conftest$ac_exeext
7501 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7502 >  (eval $ac_link) 2>&5
7503 >  ac_status=$?
7504 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7505 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7506 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7507 >  (eval $ac_try) 2>&5
7508 >  ac_status=$?
7509 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7510 >  (exit $ac_status); }; }; then
7511 >  ac_cv_func_malloc_0_nonnull=yes
7512 > else
7513 >  echo "$as_me: program exited with status $ac_status" >&5
7514 > echo "$as_me: failed program was:" >&5
7515 > sed 's/^/| /' conftest.$ac_ext >&5
7516 >
7517 > ( exit $ac_status )
7518 > ac_cv_func_malloc_0_nonnull=no
7519 > fi
7520 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7521 > fi
7522 > fi
7523 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
7524 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
7525 > if test $ac_cv_func_malloc_0_nonnull = yes; then
7526 >
7527 > cat >>confdefs.h <<\_ACEOF
7528 > #define HAVE_MALLOC 1
7529 > _ACEOF
7530 >
7531 > else
7532 >  cat >>confdefs.h <<\_ACEOF
7533 > #define HAVE_MALLOC 0
7534 > _ACEOF
7535 >
7536 >   case $LIBOBJS in
7537 >    "malloc.$ac_objext"   | \
7538 >  *" malloc.$ac_objext"   | \
7539 >    "malloc.$ac_objext "* | \
7540 >  *" malloc.$ac_objext "* ) ;;
7541 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
7542 > esac
7543 >
7544 >
7545 > cat >>confdefs.h <<\_ACEOF
7546 > #define malloc rpl_malloc
7547 > _ACEOF
7548 >
7549 > fi
7550 >
7551 >
7552 >
7553 > echo "$as_me:$LINENO: checking for working memcmp" >&5
7554 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
7555 > if test "${ac_cv_func_memcmp_working+set}" = set; then
7556 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7557 > else
7558 >  if test "$cross_compiling" = yes; then
7559 >  ac_cv_func_memcmp_working=no
7560 > else
7561 >  cat >conftest.$ac_ext <<_ACEOF
7562 > /* confdefs.h.  */
7563 > _ACEOF
7564 > cat confdefs.h >>conftest.$ac_ext
7565 > cat >>conftest.$ac_ext <<_ACEOF
7566 > /* end confdefs.h.  */
7567 > $ac_includes_default
7568 > #ifdef FC_DUMMY_MAIN
7569 > #ifndef FC_DUMMY_MAIN_EQ_F77
7570 > #  ifdef __cplusplus
7571 >     extern "C"
7572 > #  endif
7573 >   int FC_DUMMY_MAIN() { return 1; }
7574 > #endif
7575 > #endif
7576 > int
7577 > main ()
7578 > {
7579 >
7580 >  /* Some versions of memcmp are not 8-bit clean.  */
7581 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
7582 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
7583 >    exit (1);
7584 >
7585 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
7586 >     or more and with at least one buffer not starting on a 4-byte boundary.
7587 >     William Lewis provided this test program.   */
7588 >  {
7589 >    char foo[21];
7590 >    char bar[21];
7591 >    int i;
7592 >    for (i = 0; i < 4; i++)
7593 >      {
7594 >        char *a = foo + i;
7595 >        char *b = bar + i;
7596 >        strcpy (a, "--------01111111");
7597 >        strcpy (b, "--------10000000");
7598 >        if (memcmp (a, b, 16) >= 0)
7599 >          exit (1);
7600 >      }
7601 >    exit (0);
7602 >  }
7603 >
7604 >  ;
7605 >  return 0;
7606 > }
7607 > _ACEOF
7608 > rm -f conftest$ac_exeext
7609 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7610 >  (eval $ac_link) 2>&5
7611 >  ac_status=$?
7612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7613 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7614 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7615 >  (eval $ac_try) 2>&5
7616 >  ac_status=$?
7617 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7618 >  (exit $ac_status); }; }; then
7619 >  ac_cv_func_memcmp_working=yes
7620 > else
7621 >  echo "$as_me: program exited with status $ac_status" >&5
7622 > echo "$as_me: failed program was:" >&5
7623 > sed 's/^/| /' conftest.$ac_ext >&5
7624 >
7625 > ( exit $ac_status )
7626 > ac_cv_func_memcmp_working=no
7627 > fi
7628 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7629 > fi
7630 > fi
7631 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
7632 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
7633 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
7634 >    "memcmp.$ac_objext"   | \
7635 >  *" memcmp.$ac_objext"   | \
7636 >    "memcmp.$ac_objext "* | \
7637 >  *" memcmp.$ac_objext "* ) ;;
7638 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
7639 > esac
7640 >
7641 >
7642 >
7643 > for ac_header in stdlib.h
7644 > do
7645 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7646 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7647 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7648 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7649 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7650 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7651 > fi
7652 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7653 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7654 > else
7655 >  # Is the header compilable?
7656 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7657 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7658 > cat >conftest.$ac_ext <<_ACEOF
7659 > /* confdefs.h.  */
7660 > _ACEOF
7661 > cat confdefs.h >>conftest.$ac_ext
7662 > cat >>conftest.$ac_ext <<_ACEOF
7663 > /* end confdefs.h.  */
7664 > $ac_includes_default
7665 > #include <$ac_header>
7666 > _ACEOF
7667 > rm -f conftest.$ac_objext
7668 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7669 >  (eval $ac_compile) 2>conftest.er1
7670 >  ac_status=$?
7671 >  grep -v '^ *+' conftest.er1 >conftest.err
7672 >  rm -f conftest.er1
7673 >  cat conftest.err >&5
7674 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7675 >  (exit $ac_status); } &&
7676 >         { ac_try='test -z "$ac_c_werror_flag"
7677 >                         || test ! -s conftest.err'
7678 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7679 >  (eval $ac_try) 2>&5
7680 >  ac_status=$?
7681 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7682 >  (exit $ac_status); }; } &&
7683 >         { ac_try='test -s conftest.$ac_objext'
7684 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7685 >  (eval $ac_try) 2>&5
7686 >  ac_status=$?
7687 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7688 >  (exit $ac_status); }; }; then
7689 >  ac_header_compiler=yes
7690 > else
7691 >  echo "$as_me: failed program was:" >&5
7692 > sed 's/^/| /' conftest.$ac_ext >&5
7693 >
7694 > ac_header_compiler=no
7695 > fi
7696 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7697 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7698 > echo "${ECHO_T}$ac_header_compiler" >&6
7699 >
7700 > # Is the header present?
7701 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7702 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7703 > cat >conftest.$ac_ext <<_ACEOF
7704 > /* confdefs.h.  */
7705 > _ACEOF
7706 > cat confdefs.h >>conftest.$ac_ext
7707 > cat >>conftest.$ac_ext <<_ACEOF
7708 > /* end confdefs.h.  */
7709 > #include <$ac_header>
7710 > _ACEOF
7711 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7712 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7713 >  ac_status=$?
7714 >  grep -v '^ *+' conftest.er1 >conftest.err
7715 >  rm -f conftest.er1
7716 >  cat conftest.err >&5
7717 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7718 >  (exit $ac_status); } >/dev/null; then
7719 >  if test -s conftest.err; then
7720 >    ac_cpp_err=$ac_c_preproc_warn_flag
7721 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7722 >  else
7723 >    ac_cpp_err=
7724 >  fi
7725 > else
7726 >  ac_cpp_err=yes
7727 > fi
7728 > if test -z "$ac_cpp_err"; then
7729 >  ac_header_preproc=yes
7730 > else
7731 >  echo "$as_me: failed program was:" >&5
7732 > sed 's/^/| /' conftest.$ac_ext >&5
7733 >
7734 >  ac_header_preproc=no
7735 > fi
7736 > rm -f conftest.err conftest.$ac_ext
7737 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7738 > echo "${ECHO_T}$ac_header_preproc" >&6
7739 >
7740 > # So?  What about this header?
7741 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7742 >  yes:no: )
7743 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7744 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7745 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7746 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7747 >    ac_header_preproc=yes
7748 >    ;;
7749 >  no:yes:* )
7750 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7751 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7752 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7753 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7754 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7755 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7756 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7757 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7758 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7759 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7760 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7761 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7762 >    (
7763 >      cat <<\_ASBOX
7764 > ## ------------------------------ ##
7765 > ## Report this to gezelter@nd.edu ##
7766 > ## ------------------------------ ##
7767 > _ASBOX
7768 >    ) |
7769 >      sed "s/^/$as_me: WARNING:     /" >&2
7770 >    ;;
7771 > esac
7772 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7773 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7774 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7775 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7776 > else
7777 >  eval "$as_ac_Header=\$ac_header_preproc"
7778 > fi
7779 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7780 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7781 >
7782 > fi
7783 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7784 >  cat >>confdefs.h <<_ACEOF
7785 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7786 > _ACEOF
7787 >
7788 > fi
7789 >
7790 > done
7791 >
7792 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
7793 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
7794 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
7795 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7796 > else
7797 >  if test "$cross_compiling" = yes; then
7798 >  ac_cv_func_realloc_0_nonnull=no
7799 > else
7800 >  cat >conftest.$ac_ext <<_ACEOF
7801 > /* confdefs.h.  */
7802 > _ACEOF
7803 > cat confdefs.h >>conftest.$ac_ext
7804 > cat >>conftest.$ac_ext <<_ACEOF
7805 > /* end confdefs.h.  */
7806 > #if STDC_HEADERS || HAVE_STDLIB_H
7807 > # include <stdlib.h>
7808 > #else
7809 > char *realloc ();
7810 > #endif
7811 >
7812 > #ifdef FC_DUMMY_MAIN
7813 > #ifndef FC_DUMMY_MAIN_EQ_F77
7814 > #  ifdef __cplusplus
7815 >     extern "C"
7816 > #  endif
7817 >   int FC_DUMMY_MAIN() { return 1; }
7818 > #endif
7819 > #endif
7820 > int
7821 > main ()
7822 > {
7823 > exit (realloc (0, 0) ? 0 : 1);
7824 >  ;
7825 >  return 0;
7826 > }
7827 > _ACEOF
7828 > rm -f conftest$ac_exeext
7829 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7830 >  (eval $ac_link) 2>&5
7831 >  ac_status=$?
7832 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7833 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7834 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7835 >  (eval $ac_try) 2>&5
7836 >  ac_status=$?
7837 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7838 >  (exit $ac_status); }; }; then
7839 >  ac_cv_func_realloc_0_nonnull=yes
7840 > else
7841 >  echo "$as_me: program exited with status $ac_status" >&5
7842 > echo "$as_me: failed program was:" >&5
7843 > sed 's/^/| /' conftest.$ac_ext >&5
7844 >
7845 > ( exit $ac_status )
7846 > ac_cv_func_realloc_0_nonnull=no
7847 > fi
7848 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7849 > fi
7850 > fi
7851 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
7852 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
7853 > if test $ac_cv_func_realloc_0_nonnull = yes; then
7854 >
7855 > cat >>confdefs.h <<\_ACEOF
7856 > #define HAVE_REALLOC 1
7857 > _ACEOF
7858 >
7859 > else
7860 >  cat >>confdefs.h <<\_ACEOF
7861 > #define HAVE_REALLOC 0
7862 > _ACEOF
7863 >
7864 >   case $LIBOBJS in
7865 >    "realloc.$ac_objext"   | \
7866 >  *" realloc.$ac_objext"   | \
7867 >    "realloc.$ac_objext "* | \
7868 >  *" realloc.$ac_objext "* ) ;;
7869 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
7870 > esac
7871 >
7872 >
7873 > cat >>confdefs.h <<\_ACEOF
7874 > #define realloc rpl_realloc
7875 > _ACEOF
7876 >
7877 > fi
7878 >
7879 >
7880 >
7881 >
7882 >
7883 > for ac_header in sys/select.h sys/socket.h
7884 > do
7885 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7886 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7887 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7888 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7889 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7890 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7891 > fi
7892 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7893 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7894 > else
7895 >  # Is the header compilable?
7896 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7897 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7898 > cat >conftest.$ac_ext <<_ACEOF
7899 > /* confdefs.h.  */
7900 > _ACEOF
7901 > cat confdefs.h >>conftest.$ac_ext
7902 > cat >>conftest.$ac_ext <<_ACEOF
7903 > /* end confdefs.h.  */
7904 > $ac_includes_default
7905 > #include <$ac_header>
7906 > _ACEOF
7907 > rm -f conftest.$ac_objext
7908 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7909 >  (eval $ac_compile) 2>conftest.er1
7910 >  ac_status=$?
7911 >  grep -v '^ *+' conftest.er1 >conftest.err
7912 >  rm -f conftest.er1
7913 >  cat conftest.err >&5
7914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7915 >  (exit $ac_status); } &&
7916 >         { ac_try='test -z "$ac_c_werror_flag"
7917 >                         || test ! -s conftest.err'
7918 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7919 >  (eval $ac_try) 2>&5
7920 >  ac_status=$?
7921 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7922 >  (exit $ac_status); }; } &&
7923 >         { ac_try='test -s conftest.$ac_objext'
7924 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7925 >  (eval $ac_try) 2>&5
7926 >  ac_status=$?
7927 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7928 >  (exit $ac_status); }; }; then
7929 >  ac_header_compiler=yes
7930 > else
7931 >  echo "$as_me: failed program was:" >&5
7932 > sed 's/^/| /' conftest.$ac_ext >&5
7933 >
7934 > ac_header_compiler=no
7935 > fi
7936 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7937 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7938 > echo "${ECHO_T}$ac_header_compiler" >&6
7939 >
7940 > # Is the header present?
7941 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7942 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7943 > cat >conftest.$ac_ext <<_ACEOF
7944 > /* confdefs.h.  */
7945 > _ACEOF
7946 > cat confdefs.h >>conftest.$ac_ext
7947 > cat >>conftest.$ac_ext <<_ACEOF
7948 > /* end confdefs.h.  */
7949 > #include <$ac_header>
7950 > _ACEOF
7951 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7952 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7953 >  ac_status=$?
7954 >  grep -v '^ *+' conftest.er1 >conftest.err
7955 >  rm -f conftest.er1
7956 >  cat conftest.err >&5
7957 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7958 >  (exit $ac_status); } >/dev/null; then
7959 >  if test -s conftest.err; then
7960 >    ac_cpp_err=$ac_c_preproc_warn_flag
7961 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7962 >  else
7963 >    ac_cpp_err=
7964 >  fi
7965 > else
7966 >  ac_cpp_err=yes
7967 > fi
7968 > if test -z "$ac_cpp_err"; then
7969 >  ac_header_preproc=yes
7970 > else
7971 >  echo "$as_me: failed program was:" >&5
7972 > sed 's/^/| /' conftest.$ac_ext >&5
7973 >
7974 >  ac_header_preproc=no
7975 > fi
7976 > rm -f conftest.err conftest.$ac_ext
7977 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7978 > echo "${ECHO_T}$ac_header_preproc" >&6
7979 >
7980 > # So?  What about this header?
7981 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7982 >  yes:no: )
7983 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7984 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7985 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7986 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7987 >    ac_header_preproc=yes
7988 >    ;;
7989 >  no:yes:* )
7990 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7991 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7992 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7993 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7994 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7995 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7996 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7997 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7998 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7999 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8000 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8001 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8002 >    (
8003 >      cat <<\_ASBOX
8004 > ## ------------------------------ ##
8005 > ## Report this to gezelter@nd.edu ##
8006 > ## ------------------------------ ##
8007 > _ASBOX
8008 >    ) |
8009 >      sed "s/^/$as_me: WARNING:     /" >&2
8010 >    ;;
8011 > esac
8012 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8013 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8014 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8015 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8016 > else
8017 >  eval "$as_ac_Header=\$ac_header_preproc"
8018 > fi
8019 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8020 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8021 >
8022 > fi
8023 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8024 >  cat >>confdefs.h <<_ACEOF
8025 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8026 > _ACEOF
8027 >
8028 > fi
8029 >
8030 > done
8031 >
8032 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8033 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8034 > if test "${ac_cv_func_select_args+set}" = set; then
8035 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8036 > else
8037 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8038 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8039 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8040 >   cat >conftest.$ac_ext <<_ACEOF
8041 > /* confdefs.h.  */
8042 > _ACEOF
8043 > cat confdefs.h >>conftest.$ac_ext
8044 > cat >>conftest.$ac_ext <<_ACEOF
8045 > /* end confdefs.h.  */
8046 > $ac_includes_default
8047 > #if HAVE_SYS_SELECT_H
8048 > # include <sys/select.h>
8049 > #endif
8050 > #if HAVE_SYS_SOCKET_H
8051 > # include <sys/socket.h>
8052 > #endif
8053 >
8054 > #ifdef FC_DUMMY_MAIN
8055 > #ifndef FC_DUMMY_MAIN_EQ_F77
8056 > #  ifdef __cplusplus
8057 >     extern "C"
8058 > #  endif
8059 >   int FC_DUMMY_MAIN() { return 1; }
8060 > #endif
8061 > #endif
8062 > int
8063 > main ()
8064 > {
8065 > extern int select ($ac_arg1,
8066 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8067 >                                            $ac_arg5);
8068 >  ;
8069 >  return 0;
8070 > }
8071 > _ACEOF
8072 > rm -f conftest.$ac_objext
8073 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8074 >  (eval $ac_compile) 2>conftest.er1
8075 >  ac_status=$?
8076 >  grep -v '^ *+' conftest.er1 >conftest.err
8077 >  rm -f conftest.er1
8078 >  cat conftest.err >&5
8079 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8080 >  (exit $ac_status); } &&
8081 >         { ac_try='test -z "$ac_c_werror_flag"
8082 >                         || test ! -s conftest.err'
8083 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8084 >  (eval $ac_try) 2>&5
8085 >  ac_status=$?
8086 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8087 >  (exit $ac_status); }; } &&
8088 >         { ac_try='test -s conftest.$ac_objext'
8089 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8090 >  (eval $ac_try) 2>&5
8091 >  ac_status=$?
8092 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8093 >  (exit $ac_status); }; }; then
8094 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8095 > else
8096 >  echo "$as_me: failed program was:" >&5
8097 > sed 's/^/| /' conftest.$ac_ext >&5
8098 >
8099 > fi
8100 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8101 >  done
8102 > done
8103 > done
8104 > # Provide a safe default value.
8105 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8106 >
8107 > fi
8108 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8109 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8110 > ac_save_IFS=$IFS; IFS=','
8111 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8112 > IFS=$ac_save_IFS
8113 > shift
8114 >
8115 > cat >>confdefs.h <<_ACEOF
8116 > #define SELECT_TYPE_ARG1 $1
8117 > _ACEOF
8118 >
8119 >
8120 > cat >>confdefs.h <<_ACEOF
8121 > #define SELECT_TYPE_ARG234 ($2)
8122 > _ACEOF
8123 >
8124 >
8125 > cat >>confdefs.h <<_ACEOF
8126 > #define SELECT_TYPE_ARG5 ($3)
8127 > _ACEOF
8128 >
8129 > rm -f conftest*
8130 >
8131 >
8132 > for ac_func in strftime
8133 > do
8134 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8135 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8136 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8137 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8138 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8139 > else
8140 >  cat >conftest.$ac_ext <<_ACEOF
8141 > /* confdefs.h.  */
8142 > _ACEOF
8143 > cat confdefs.h >>conftest.$ac_ext
8144 > cat >>conftest.$ac_ext <<_ACEOF
8145 > /* end confdefs.h.  */
8146 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8147 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8148 > #define $ac_func innocuous_$ac_func
8149 >
8150 > /* System header to define __stub macros and hopefully few prototypes,
8151 >    which can conflict with char $ac_func (); below.
8152 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8153 >    <limits.h> exists even on freestanding compilers.  */
8154 >
8155 > #ifdef __STDC__
8156 > # include <limits.h>
8157 > #else
8158 > # include <assert.h>
8159 > #endif
8160 >
8161 > #undef $ac_func
8162 >
8163 > /* Override any gcc2 internal prototype to avoid an error.  */
8164 > #ifdef __cplusplus
8165 > extern "C"
8166 > {
8167 > #endif
8168 > /* We use char because int might match the return type of a gcc2
8169 >   builtin and then its argument prototype would still apply.  */
8170 > char $ac_func ();
8171 > /* The GNU C library defines this for functions which it implements
8172 >    to always fail with ENOSYS.  Some functions are actually named
8173 >    something starting with __ and the normal name is an alias.  */
8174 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8175 > choke me
8176 > #else
8177 > char (*f) () = $ac_func;
8178 > #endif
8179 > #ifdef __cplusplus
8180 > }
8181 > #endif
8182 >
8183 > #ifdef FC_DUMMY_MAIN
8184 > #ifndef FC_DUMMY_MAIN_EQ_F77
8185 > #  ifdef __cplusplus
8186 >     extern "C"
8187 > #  endif
8188 >   int FC_DUMMY_MAIN() { return 1; }
8189 > #endif
8190 > #endif
8191 > int
8192 > main ()
8193 > {
8194 > return f != $ac_func;
8195 >  ;
8196 >  return 0;
8197 > }
8198 > _ACEOF
8199 > rm -f conftest.$ac_objext conftest$ac_exeext
8200 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8201 >  (eval $ac_link) 2>conftest.er1
8202 >  ac_status=$?
8203 >  grep -v '^ *+' conftest.er1 >conftest.err
8204 >  rm -f conftest.er1
8205 >  cat conftest.err >&5
8206 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8207 >  (exit $ac_status); } &&
8208 >         { ac_try='test -z "$ac_c_werror_flag"
8209 >                         || test ! -s conftest.err'
8210 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8211 >  (eval $ac_try) 2>&5
8212 >  ac_status=$?
8213 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8214 >  (exit $ac_status); }; } &&
8215 >         { ac_try='test -s conftest$ac_exeext'
8216 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8217 >  (eval $ac_try) 2>&5
8218 >  ac_status=$?
8219 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8220 >  (exit $ac_status); }; }; then
8221 >  eval "$as_ac_var=yes"
8222 > else
8223 >  echo "$as_me: failed program was:" >&5
8224 > sed 's/^/| /' conftest.$ac_ext >&5
8225 >
8226 > eval "$as_ac_var=no"
8227 > fi
8228 > rm -f conftest.err conftest.$ac_objext \
8229 >      conftest$ac_exeext conftest.$ac_ext
8230 > fi
8231 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8232 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8233 > if test `eval echo '${'$as_ac_var'}'` = yes; then
8234 >  cat >>confdefs.h <<_ACEOF
8235 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8236 > _ACEOF
8237 >
8238 > else
8239 >  # strftime is in -lintl on SCO UNIX.
8240 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
8241 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
8242 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
8243 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8244 > else
8245 >  ac_check_lib_save_LIBS=$LIBS
8246 > LIBS="-lintl  $LIBS"
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 >
8254 > /* Override any gcc2 internal prototype to avoid an error.  */
8255 > #ifdef __cplusplus
8256 > extern "C"
8257 > #endif
8258 > /* We use char because int might match the return type of a gcc2
8259 >   builtin and then its argument prototype would still apply.  */
8260 > char strftime ();
8261 > #ifdef FC_DUMMY_MAIN
8262 > #ifndef FC_DUMMY_MAIN_EQ_F77
8263 > #  ifdef __cplusplus
8264 >     extern "C"
8265 > #  endif
8266 >   int FC_DUMMY_MAIN() { return 1; }
8267 > #endif
8268 > #endif
8269 > int
8270 > main ()
8271 > {
8272 > strftime ();
8273 >  ;
8274 >  return 0;
8275 > }
8276 > _ACEOF
8277 > rm -f conftest.$ac_objext conftest$ac_exeext
8278 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8279 >  (eval $ac_link) 2>conftest.er1
8280 >  ac_status=$?
8281 >  grep -v '^ *+' conftest.er1 >conftest.err
8282 >  rm -f conftest.er1
8283 >  cat conftest.err >&5
8284 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8285 >  (exit $ac_status); } &&
8286 >         { ac_try='test -z "$ac_c_werror_flag"
8287 >                         || test ! -s conftest.err'
8288 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8289 >  (eval $ac_try) 2>&5
8290 >  ac_status=$?
8291 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8292 >  (exit $ac_status); }; } &&
8293 >         { ac_try='test -s conftest$ac_exeext'
8294 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8295 >  (eval $ac_try) 2>&5
8296 >  ac_status=$?
8297 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8298 >  (exit $ac_status); }; }; then
8299 >  ac_cv_lib_intl_strftime=yes
8300 > else
8301 >  echo "$as_me: failed program was:" >&5
8302 > sed 's/^/| /' conftest.$ac_ext >&5
8303 >
8304 > ac_cv_lib_intl_strftime=no
8305 > fi
8306 > rm -f conftest.err conftest.$ac_objext \
8307 >      conftest$ac_exeext conftest.$ac_ext
8308 > LIBS=$ac_check_lib_save_LIBS
8309 > fi
8310 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
8311 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
8312 > if test $ac_cv_lib_intl_strftime = yes; then
8313 >  cat >>confdefs.h <<\_ACEOF
8314 > #define HAVE_STRFTIME 1
8315 > _ACEOF
8316 >
8317 > LIBS="-lintl $LIBS"
8318 > fi
8319 >
8320 > fi
8321 > done
8322 >
8323 > echo "$as_me:$LINENO: checking for working strtod" >&5
8324 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
8325 > if test "${ac_cv_func_strtod+set}" = set; then
8326 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8327 > else
8328 >  if test "$cross_compiling" = yes; then
8329 >  ac_cv_func_strtod=no
8330 > else
8331 >  cat >conftest.$ac_ext <<_ACEOF
8332 > /* confdefs.h.  */
8333 > _ACEOF
8334 > cat confdefs.h >>conftest.$ac_ext
8335 > cat >>conftest.$ac_ext <<_ACEOF
8336 > /* end confdefs.h.  */
8337 >
8338 > double strtod ();
8339 > int
8340 > main()
8341 > {
8342 >  {
8343 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
8344 >    char *string = " +69";
8345 >    char *term;
8346 >    double value;
8347 >    value = strtod (string, &term);
8348 >    if (value != 69 || term != (string + 4))
8349 >      exit (1);
8350 >  }
8351 >
8352 >  {
8353 >    /* Under Solaris 2.4, strtod returns the wrong value for the
8354 >       terminating character under some conditions.  */
8355 >    char *string = "NaN";
8356 >    char *term;
8357 >    strtod (string, &term);
8358 >    if (term != string && *(term - 1) == 0)
8359 >      exit (1);
8360 >  }
8361 >  exit (0);
8362 > }
8363 >
8364 > _ACEOF
8365 > rm -f conftest$ac_exeext
8366 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8367 >  (eval $ac_link) 2>&5
8368 >  ac_status=$?
8369 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8371 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8372 >  (eval $ac_try) 2>&5
8373 >  ac_status=$?
8374 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8375 >  (exit $ac_status); }; }; then
8376 >  ac_cv_func_strtod=yes
8377 > else
8378 >  echo "$as_me: program exited with status $ac_status" >&5
8379 > echo "$as_me: failed program was:" >&5
8380 > sed 's/^/| /' conftest.$ac_ext >&5
8381 >
8382 > ( exit $ac_status )
8383 > ac_cv_func_strtod=no
8384 > fi
8385 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8386 > fi
8387 > fi
8388 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
8389 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
8390 > if test $ac_cv_func_strtod = no; then
8391 >  case $LIBOBJS in
8392 >    "strtod.$ac_objext"   | \
8393 >  *" strtod.$ac_objext"   | \
8394 >    "strtod.$ac_objext "* | \
8395 >  *" strtod.$ac_objext "* ) ;;
8396 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
8397 > esac
8398 >
8399 > echo "$as_me:$LINENO: checking for pow" >&5
8400 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
8401 > if test "${ac_cv_func_pow+set}" = set; then
8402 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8403 > else
8404 >  cat >conftest.$ac_ext <<_ACEOF
8405 > /* confdefs.h.  */
8406 > _ACEOF
8407 > cat confdefs.h >>conftest.$ac_ext
8408 > cat >>conftest.$ac_ext <<_ACEOF
8409 > /* end confdefs.h.  */
8410 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
8411 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8412 > #define pow innocuous_pow
8413 >
8414 > /* System header to define __stub macros and hopefully few prototypes,
8415 >    which can conflict with char pow (); below.
8416 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8417 >    <limits.h> exists even on freestanding compilers.  */
8418 >
8419 > #ifdef __STDC__
8420 > # include <limits.h>
8421 > #else
8422 > # include <assert.h>
8423 > #endif
8424 >
8425 > #undef pow
8426 >
8427 > /* Override any gcc2 internal prototype to avoid an error.  */
8428 > #ifdef __cplusplus
8429 > extern "C"
8430 > {
8431 > #endif
8432 > /* We use char because int might match the return type of a gcc2
8433 >   builtin and then its argument prototype would still apply.  */
8434 > char pow ();
8435 > /* The GNU C library defines this for functions which it implements
8436 >    to always fail with ENOSYS.  Some functions are actually named
8437 >    something starting with __ and the normal name is an alias.  */
8438 > #if defined (__stub_pow) || defined (__stub___pow)
8439 > choke me
8440 > #else
8441 > char (*f) () = pow;
8442 > #endif
8443 > #ifdef __cplusplus
8444 > }
8445 > #endif
8446 >
8447 > #ifdef FC_DUMMY_MAIN
8448 > #ifndef FC_DUMMY_MAIN_EQ_F77
8449 > #  ifdef __cplusplus
8450 >     extern "C"
8451 > #  endif
8452 >   int FC_DUMMY_MAIN() { return 1; }
8453 > #endif
8454 > #endif
8455 > int
8456 > main ()
8457 > {
8458 > return f != pow;
8459 >  ;
8460 >  return 0;
8461 > }
8462 > _ACEOF
8463 > rm -f conftest.$ac_objext conftest$ac_exeext
8464 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8465 >  (eval $ac_link) 2>conftest.er1
8466 >  ac_status=$?
8467 >  grep -v '^ *+' conftest.er1 >conftest.err
8468 >  rm -f conftest.er1
8469 >  cat conftest.err >&5
8470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8471 >  (exit $ac_status); } &&
8472 >         { ac_try='test -z "$ac_c_werror_flag"
8473 >                         || test ! -s conftest.err'
8474 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8475 >  (eval $ac_try) 2>&5
8476 >  ac_status=$?
8477 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8478 >  (exit $ac_status); }; } &&
8479 >         { ac_try='test -s conftest$ac_exeext'
8480 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8481 >  (eval $ac_try) 2>&5
8482 >  ac_status=$?
8483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484 >  (exit $ac_status); }; }; then
8485 >  ac_cv_func_pow=yes
8486 > else
8487 >  echo "$as_me: failed program was:" >&5
8488 > sed 's/^/| /' conftest.$ac_ext >&5
8489 >
8490 > ac_cv_func_pow=no
8491 > fi
8492 > rm -f conftest.err conftest.$ac_objext \
8493 >      conftest$ac_exeext conftest.$ac_ext
8494 > fi
8495 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
8496 > echo "${ECHO_T}$ac_cv_func_pow" >&6
8497 >
8498 > if test $ac_cv_func_pow = no; then
8499 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
8500 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
8501 > if test "${ac_cv_lib_m_pow+set}" = set; then
8502 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8503 > else
8504 >  ac_check_lib_save_LIBS=$LIBS
8505 > LIBS="-lm  $LIBS"
8506 > cat >conftest.$ac_ext <<_ACEOF
8507 > /* confdefs.h.  */
8508 > _ACEOF
8509 > cat confdefs.h >>conftest.$ac_ext
8510 > cat >>conftest.$ac_ext <<_ACEOF
8511 > /* end confdefs.h.  */
8512 >
8513 > /* Override any gcc2 internal prototype to avoid an error.  */
8514 > #ifdef __cplusplus
8515 > extern "C"
8516 > #endif
8517 > /* We use char because int might match the return type of a gcc2
8518 >   builtin and then its argument prototype would still apply.  */
8519 > char pow ();
8520 > #ifdef FC_DUMMY_MAIN
8521 > #ifndef FC_DUMMY_MAIN_EQ_F77
8522 > #  ifdef __cplusplus
8523 >     extern "C"
8524 > #  endif
8525 >   int FC_DUMMY_MAIN() { return 1; }
8526 > #endif
8527 > #endif
8528 > int
8529 > main ()
8530 > {
8531 > pow ();
8532 >  ;
8533 >  return 0;
8534 > }
8535 > _ACEOF
8536 > rm -f conftest.$ac_objext conftest$ac_exeext
8537 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8538 >  (eval $ac_link) 2>conftest.er1
8539 >  ac_status=$?
8540 >  grep -v '^ *+' conftest.er1 >conftest.err
8541 >  rm -f conftest.er1
8542 >  cat conftest.err >&5
8543 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8544 >  (exit $ac_status); } &&
8545 >         { ac_try='test -z "$ac_c_werror_flag"
8546 >                         || test ! -s conftest.err'
8547 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8548 >  (eval $ac_try) 2>&5
8549 >  ac_status=$?
8550 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8551 >  (exit $ac_status); }; } &&
8552 >         { ac_try='test -s conftest$ac_exeext'
8553 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8554 >  (eval $ac_try) 2>&5
8555 >  ac_status=$?
8556 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8557 >  (exit $ac_status); }; }; then
8558 >  ac_cv_lib_m_pow=yes
8559 > else
8560 >  echo "$as_me: failed program was:" >&5
8561 > sed 's/^/| /' conftest.$ac_ext >&5
8562 >
8563 > ac_cv_lib_m_pow=no
8564 > fi
8565 > rm -f conftest.err conftest.$ac_objext \
8566 >      conftest$ac_exeext conftest.$ac_ext
8567 > LIBS=$ac_check_lib_save_LIBS
8568 > fi
8569 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
8570 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
8571 > if test $ac_cv_lib_m_pow = yes; then
8572 >  POW_LIB=-lm
8573 > else
8574 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
8575 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
8576 > fi
8577 >
8578 > fi
8579 >
8580 > fi
8581 >
8582 >
8583 >
8584 >
8585 >
8586 >
8587 >
8588 >
8589 >
8590 >
8591 >
8592 >
8593 >
8594 >
8595 >
8596 >
8597 >
8598 >
8599 >
8600 >
8601 >
8602 >
8603 >
8604 >
8605 >
8606 >
8607 >
8608 >
8609 > 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
8610 > do
8611 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8612 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8613 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8614 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8615 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8616 > else
8617 >  cat >conftest.$ac_ext <<_ACEOF
8618 > /* confdefs.h.  */
8619 > _ACEOF
8620 > cat confdefs.h >>conftest.$ac_ext
8621 > cat >>conftest.$ac_ext <<_ACEOF
8622 > /* end confdefs.h.  */
8623 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8624 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8625 > #define $ac_func innocuous_$ac_func
8626 >
8627 > /* System header to define __stub macros and hopefully few prototypes,
8628 >    which can conflict with char $ac_func (); below.
8629 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8630 >    <limits.h> exists even on freestanding compilers.  */
8631 >
8632 > #ifdef __STDC__
8633 > # include <limits.h>
8634 > #else
8635 > # include <assert.h>
8636 > #endif
8637 >
8638 > #undef $ac_func
8639 >
8640 > /* Override any gcc2 internal prototype to avoid an error.  */
8641 > #ifdef __cplusplus
8642 > extern "C"
8643 > {
8644 > #endif
8645 > /* We use char because int might match the return type of a gcc2
8646 >   builtin and then its argument prototype would still apply.  */
8647 > char $ac_func ();
8648 > /* The GNU C library defines this for functions which it implements
8649 >    to always fail with ENOSYS.  Some functions are actually named
8650 >    something starting with __ and the normal name is an alias.  */
8651 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8652 > choke me
8653 > #else
8654 > char (*f) () = $ac_func;
8655 > #endif
8656 > #ifdef __cplusplus
8657 > }
8658 > #endif
8659 >
8660 > #ifdef FC_DUMMY_MAIN
8661 > #ifndef FC_DUMMY_MAIN_EQ_F77
8662 > #  ifdef __cplusplus
8663 >     extern "C"
8664 > #  endif
8665 >   int FC_DUMMY_MAIN() { return 1; }
8666 > #endif
8667 > #endif
8668 > int
8669 > main ()
8670 > {
8671 > return f != $ac_func;
8672 >  ;
8673 >  return 0;
8674 > }
8675 > _ACEOF
8676 > rm -f conftest.$ac_objext conftest$ac_exeext
8677 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8678 >  (eval $ac_link) 2>conftest.er1
8679 >  ac_status=$?
8680 >  grep -v '^ *+' conftest.er1 >conftest.err
8681 >  rm -f conftest.er1
8682 >  cat conftest.err >&5
8683 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8684 >  (exit $ac_status); } &&
8685 >         { ac_try='test -z "$ac_c_werror_flag"
8686 >                         || test ! -s conftest.err'
8687 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8688 >  (eval $ac_try) 2>&5
8689 >  ac_status=$?
8690 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8691 >  (exit $ac_status); }; } &&
8692 >         { ac_try='test -s conftest$ac_exeext'
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); }; }; then
8698 >  eval "$as_ac_var=yes"
8699 > else
8700 >  echo "$as_me: failed program was:" >&5
8701 > sed 's/^/| /' conftest.$ac_ext >&5
8702 >
8703 > eval "$as_ac_var=no"
8704 > fi
8705 > rm -f conftest.err conftest.$ac_objext \
8706 >      conftest$ac_exeext conftest.$ac_ext
8707 > fi
8708 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8709 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8710 > if test `eval echo '${'$as_ac_var'}'` = yes; then
8711 >  cat >>confdefs.h <<_ACEOF
8712 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8713 > _ACEOF
8714 >
8715 > fi
8716 > done
8717 >
8718 >
8719 > # special check for _system_configuration because AIX <4.3.2 do not
8720 > # contain the `physmem' member.
8721 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
8722 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
8723 > cat >conftest.$ac_ext <<_ACEOF
8724 > /* confdefs.h.  */
8725 > _ACEOF
8726 > cat confdefs.h >>conftest.$ac_ext
8727 > cat >>conftest.$ac_ext <<_ACEOF
8728 > /* end confdefs.h.  */
8729 > #include <sys/systemcfg.h>
8730 > #ifdef FC_DUMMY_MAIN
8731 > #ifndef FC_DUMMY_MAIN_EQ_F77
8732 > #  ifdef __cplusplus
8733 >     extern "C"
8734 > #  endif
8735 >   int FC_DUMMY_MAIN() { return 1; }
8736 > #endif
8737 > #endif
8738 > int
8739 > main ()
8740 > {
8741 > double x = _system_configuration.physmem;
8742 >  ;
8743 >  return 0;
8744 > }
8745 > _ACEOF
8746 > rm -f conftest.$ac_objext
8747 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8748 >  (eval $ac_compile) 2>conftest.er1
8749 >  ac_status=$?
8750 >  grep -v '^ *+' conftest.er1 >conftest.err
8751 >  rm -f conftest.er1
8752 >  cat conftest.err >&5
8753 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8754 >  (exit $ac_status); } &&
8755 >         { ac_try='test -z "$ac_c_werror_flag"
8756 >                         || test ! -s conftest.err'
8757 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8758 >  (eval $ac_try) 2>&5
8759 >  ac_status=$?
8760 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8761 >  (exit $ac_status); }; } &&
8762 >         { ac_try='test -s conftest.$ac_objext'
8763 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8764 >  (eval $ac_try) 2>&5
8765 >  ac_status=$?
8766 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8767 >  (exit $ac_status); }; }; then
8768 >  echo "$as_me:$LINENO: result: yes" >&5
8769 > echo "${ECHO_T}yes" >&6
8770 >
8771 > cat >>confdefs.h <<\_ACEOF
8772 > #define HAVE__SYSTEM_CONFIGURATION 1
8773 > _ACEOF
8774 >
8775 > else
8776 >  echo "$as_me: failed program was:" >&5
8777 > sed 's/^/| /' conftest.$ac_ext >&5
8778 >
8779 > echo "$as_me:$LINENO: result: no" >&5
8780 > echo "${ECHO_T}no" >&6
8781 > fi
8782 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8783 >
8784 >  # clean out junk possibly left behind by a previous configuration
8785 >  rm -f src/getopt.h
8786 >  # Check for getopt_long support
8787 >
8788 > for ac_header in getopt.h
8789 > do
8790 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8791 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8792 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8793 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8794 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8795 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8796 > fi
8797 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8798 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8799 > else
8800 >  # Is the header compilable?
8801 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8802 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8803 > cat >conftest.$ac_ext <<_ACEOF
8804 > /* confdefs.h.  */
8805 > _ACEOF
8806 > cat confdefs.h >>conftest.$ac_ext
8807 > cat >>conftest.$ac_ext <<_ACEOF
8808 > /* end confdefs.h.  */
8809 > $ac_includes_default
8810 > #include <$ac_header>
8811 > _ACEOF
8812 > rm -f conftest.$ac_objext
8813 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8814 >  (eval $ac_compile) 2>conftest.er1
8815 >  ac_status=$?
8816 >  grep -v '^ *+' conftest.er1 >conftest.err
8817 >  rm -f conftest.er1
8818 >  cat conftest.err >&5
8819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8820 >  (exit $ac_status); } &&
8821 >         { ac_try='test -z "$ac_c_werror_flag"
8822 >                         || test ! -s conftest.err'
8823 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8824 >  (eval $ac_try) 2>&5
8825 >  ac_status=$?
8826 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8827 >  (exit $ac_status); }; } &&
8828 >         { ac_try='test -s conftest.$ac_objext'
8829 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8830 >  (eval $ac_try) 2>&5
8831 >  ac_status=$?
8832 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8833 >  (exit $ac_status); }; }; then
8834 >  ac_header_compiler=yes
8835 > else
8836 >  echo "$as_me: failed program was:" >&5
8837 > sed 's/^/| /' conftest.$ac_ext >&5
8838 >
8839 > ac_header_compiler=no
8840 > fi
8841 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8842 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8843 > echo "${ECHO_T}$ac_header_compiler" >&6
8844 >
8845 > # Is the header present?
8846 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8847 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8848 > cat >conftest.$ac_ext <<_ACEOF
8849 > /* confdefs.h.  */
8850 > _ACEOF
8851 > cat confdefs.h >>conftest.$ac_ext
8852 > cat >>conftest.$ac_ext <<_ACEOF
8853 > /* end confdefs.h.  */
8854 > #include <$ac_header>
8855 > _ACEOF
8856 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8857 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8858 >  ac_status=$?
8859 >  grep -v '^ *+' conftest.er1 >conftest.err
8860 >  rm -f conftest.er1
8861 >  cat conftest.err >&5
8862 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8863 >  (exit $ac_status); } >/dev/null; then
8864 >  if test -s conftest.err; then
8865 >    ac_cpp_err=$ac_c_preproc_warn_flag
8866 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8867 >  else
8868 >    ac_cpp_err=
8869 >  fi
8870 > else
8871 >  ac_cpp_err=yes
8872 > fi
8873 > if test -z "$ac_cpp_err"; then
8874 >  ac_header_preproc=yes
8875 > else
8876 >  echo "$as_me: failed program was:" >&5
8877 > sed 's/^/| /' conftest.$ac_ext >&5
8878 >
8879 >  ac_header_preproc=no
8880 > fi
8881 > rm -f conftest.err conftest.$ac_ext
8882 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8883 > echo "${ECHO_T}$ac_header_preproc" >&6
8884 >
8885 > # So?  What about this header?
8886 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8887 >  yes:no: )
8888 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8889 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8890 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8891 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8892 >    ac_header_preproc=yes
8893 >    ;;
8894 >  no:yes:* )
8895 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8896 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8897 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8898 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8899 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8900 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8901 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8902 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8903 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8904 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8905 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8906 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8907 >    (
8908 >      cat <<\_ASBOX
8909 > ## ------------------------------ ##
8910 > ## Report this to gezelter@nd.edu ##
8911 > ## ------------------------------ ##
8912 > _ASBOX
8913 >    ) |
8914 >      sed "s/^/$as_me: WARNING:     /" >&2
8915 >    ;;
8916 > esac
8917 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8918 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8919 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8920 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8921 > else
8922 >  eval "$as_ac_Header=\$ac_header_preproc"
8923 > fi
8924 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8925 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8926 >
8927 > fi
8928 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8929 >  cat >>confdefs.h <<_ACEOF
8930 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8931 > _ACEOF
8932 >
8933 > fi
8934 >
8935 > done
8936 >
8937 >
8938 > for ac_func in getopt_long
8939 > do
8940 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8941 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8942 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8943 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8944 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8945 > else
8946 >  cat >conftest.$ac_ext <<_ACEOF
8947 > /* confdefs.h.  */
8948 > _ACEOF
8949 > cat confdefs.h >>conftest.$ac_ext
8950 > cat >>conftest.$ac_ext <<_ACEOF
8951 > /* end confdefs.h.  */
8952 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8953 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8954 > #define $ac_func innocuous_$ac_func
8955 >
8956 > /* System header to define __stub macros and hopefully few prototypes,
8957 >    which can conflict with char $ac_func (); below.
8958 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8959 >    <limits.h> exists even on freestanding compilers.  */
8960 >
8961 > #ifdef __STDC__
8962 > # include <limits.h>
8963 > #else
8964 > # include <assert.h>
8965 > #endif
8966 >
8967 > #undef $ac_func
8968 >
8969 > /* Override any gcc2 internal prototype to avoid an error.  */
8970 > #ifdef __cplusplus
8971 > extern "C"
8972 > {
8973 > #endif
8974 > /* We use char because int might match the return type of a gcc2
8975 >   builtin and then its argument prototype would still apply.  */
8976 > char $ac_func ();
8977 > /* The GNU C library defines this for functions which it implements
8978 >    to always fail with ENOSYS.  Some functions are actually named
8979 >    something starting with __ and the normal name is an alias.  */
8980 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8981 > choke me
8982 > #else
8983 > char (*f) () = $ac_func;
8984 > #endif
8985 > #ifdef __cplusplus
8986 > }
8987 > #endif
8988 >
8989 > #ifdef FC_DUMMY_MAIN
8990 > #ifndef FC_DUMMY_MAIN_EQ_F77
8991 > #  ifdef __cplusplus
8992 >     extern "C"
8993 > #  endif
8994 >   int FC_DUMMY_MAIN() { return 1; }
8995 > #endif
8996 > #endif
8997 > int
8998 > main ()
8999 > {
9000 > return f != $ac_func;
9001 >  ;
9002 >  return 0;
9003 > }
9004 > _ACEOF
9005 > rm -f conftest.$ac_objext conftest$ac_exeext
9006 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9007 >  (eval $ac_link) 2>conftest.er1
9008 >  ac_status=$?
9009 >  grep -v '^ *+' conftest.er1 >conftest.err
9010 >  rm -f conftest.er1
9011 >  cat conftest.err >&5
9012 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9013 >  (exit $ac_status); } &&
9014 >         { ac_try='test -z "$ac_c_werror_flag"
9015 >                         || test ! -s conftest.err'
9016 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9017 >  (eval $ac_try) 2>&5
9018 >  ac_status=$?
9019 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9020 >  (exit $ac_status); }; } &&
9021 >         { ac_try='test -s conftest$ac_exeext'
9022 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9023 >  (eval $ac_try) 2>&5
9024 >  ac_status=$?
9025 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9026 >  (exit $ac_status); }; }; then
9027 >  eval "$as_ac_var=yes"
9028 > else
9029 >  echo "$as_me: failed program was:" >&5
9030 > sed 's/^/| /' conftest.$ac_ext >&5
9031 >
9032 > eval "$as_ac_var=no"
9033 > fi
9034 > rm -f conftest.err conftest.$ac_objext \
9035 >      conftest$ac_exeext conftest.$ac_ext
9036 > fi
9037 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9038 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9039 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9040 >  cat >>confdefs.h <<_ACEOF
9041 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9042 > _ACEOF
9043 >
9044 > else
9045 >  # FreeBSD has a gnugetopt library for this
9046 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9047 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9048 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9049 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9050 > else
9051 >  ac_check_lib_save_LIBS=$LIBS
9052 > LIBS="-lgnugetopt  $LIBS"
9053 > cat >conftest.$ac_ext <<_ACEOF
9054 > /* confdefs.h.  */
9055 > _ACEOF
9056 > cat confdefs.h >>conftest.$ac_ext
9057 > cat >>conftest.$ac_ext <<_ACEOF
9058 > /* end confdefs.h.  */
9059 >
9060 > /* Override any gcc2 internal prototype to avoid an error.  */
9061 > #ifdef __cplusplus
9062 > extern "C"
9063 > #endif
9064 > /* We use char because int might match the return type of a gcc2
9065 >   builtin and then its argument prototype would still apply.  */
9066 > char getopt_long ();
9067 > #ifdef FC_DUMMY_MAIN
9068 > #ifndef FC_DUMMY_MAIN_EQ_F77
9069 > #  ifdef __cplusplus
9070 >     extern "C"
9071 > #  endif
9072 >   int FC_DUMMY_MAIN() { return 1; }
9073 > #endif
9074 > #endif
9075 > int
9076 > main ()
9077 > {
9078 > getopt_long ();
9079 >  ;
9080 >  return 0;
9081 > }
9082 > _ACEOF
9083 > rm -f conftest.$ac_objext conftest$ac_exeext
9084 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9085 >  (eval $ac_link) 2>conftest.er1
9086 >  ac_status=$?
9087 >  grep -v '^ *+' conftest.er1 >conftest.err
9088 >  rm -f conftest.er1
9089 >  cat conftest.err >&5
9090 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9091 >  (exit $ac_status); } &&
9092 >         { ac_try='test -z "$ac_c_werror_flag"
9093 >                         || test ! -s conftest.err'
9094 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9095 >  (eval $ac_try) 2>&5
9096 >  ac_status=$?
9097 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9098 >  (exit $ac_status); }; } &&
9099 >         { ac_try='test -s conftest$ac_exeext'
9100 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9101 >  (eval $ac_try) 2>&5
9102 >  ac_status=$?
9103 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9104 >  (exit $ac_status); }; }; then
9105 >  ac_cv_lib_gnugetopt_getopt_long=yes
9106 > else
9107 >  echo "$as_me: failed program was:" >&5
9108 > sed 's/^/| /' conftest.$ac_ext >&5
9109 >
9110 > ac_cv_lib_gnugetopt_getopt_long=no
9111 > fi
9112 > rm -f conftest.err conftest.$ac_objext \
9113 >      conftest$ac_exeext conftest.$ac_ext
9114 > LIBS=$ac_check_lib_save_LIBS
9115 > fi
9116 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9117 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9118 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9119 >  cat >>confdefs.h <<\_ACEOF
9120 > #define HAVE_GETOPT_LONG 1
9121 > _ACEOF
9122 >
9123 > else
9124 >  # use the GNU replacement
9125 >      case $LIBOBJS in
9126 >    "getopt.$ac_objext"   | \
9127 >  *" getopt.$ac_objext"   | \
9128 >    "getopt.$ac_objext "* | \
9129 >  *" getopt.$ac_objext "* ) ;;
9130 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9131 > esac
9132 >
9133 >      case $LIBOBJS in
9134 >    "getopt1.$ac_objext"   | \
9135 >  *" getopt1.$ac_objext"   | \
9136 >    "getopt1.$ac_objext "* | \
9137 >  *" getopt1.$ac_objext "* ) ;;
9138 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9139 > esac
9140 >
9141 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9142 >
9143 > fi
9144 >
9145 > fi
9146 > done
9147 >
9148 >
9149 > ac_ext=cc
9150 > ac_cpp='$CXXCPP $CPPFLAGS'
9151 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9152 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9153 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9154 >
9155 >
9156 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9157 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9158 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9159 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9160 > else
9161 >
9162 >
9163 > ac_ext=cc
9164 > ac_cpp='$CXXCPP $CPPFLAGS'
9165 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9166 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9167 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9168 >
9169 > cat >conftest.$ac_ext <<_ACEOF
9170 > /* confdefs.h.  */
9171 > _ACEOF
9172 > cat confdefs.h >>conftest.$ac_ext
9173 > cat >>conftest.$ac_ext <<_ACEOF
9174 > /* end confdefs.h.  */
9175 > namespace Outer { namespace Inner { int i = 0; }}
9176 > #ifdef FC_DUMMY_MAIN
9177 > #ifndef FC_DUMMY_MAIN_EQ_F77
9178 > #  ifdef __cplusplus
9179 >     extern "C"
9180 > #  endif
9181 >   int FC_DUMMY_MAIN() { return 1; }
9182 > #endif
9183 > #endif
9184 > int
9185 > main ()
9186 > {
9187 > using namespace Outer::Inner; return i;
9188 >  ;
9189 >  return 0;
9190 > }
9191 > _ACEOF
9192 > rm -f conftest.$ac_objext
9193 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9194 >  (eval $ac_compile) 2>conftest.er1
9195 >  ac_status=$?
9196 >  grep -v '^ *+' conftest.er1 >conftest.err
9197 >  rm -f conftest.er1
9198 >  cat conftest.err >&5
9199 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9200 >  (exit $ac_status); } &&
9201 >         { ac_try='test -z "$ac_cxx_werror_flag"
9202 >                         || test ! -s conftest.err'
9203 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9204 >  (eval $ac_try) 2>&5
9205 >  ac_status=$?
9206 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9207 >  (exit $ac_status); }; } &&
9208 >         { ac_try='test -s conftest.$ac_objext'
9209 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9210 >  (eval $ac_try) 2>&5
9211 >  ac_status=$?
9212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9213 >  (exit $ac_status); }; }; then
9214 >  ac_cv_cxx_namespaces=yes
9215 > else
9216 >  echo "$as_me: failed program was:" >&5
9217 > sed 's/^/| /' conftest.$ac_ext >&5
9218 >
9219 > ac_cv_cxx_namespaces=no
9220 > fi
9221 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9222 > ac_ext=cc
9223 > ac_cpp='$CXXCPP $CPPFLAGS'
9224 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9225 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9226 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9227 >
9228 >
9229 > fi
9230 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
9231 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
9232 > if test "$ac_cv_cxx_namespaces" = yes; then
9233 >
9234 > cat >>confdefs.h <<\_ACEOF
9235 > #define HAVE_NAMESPACES
9236 > _ACEOF
9237 >
9238 > fi
9239 >
9240 > ac_ext=cc
9241 > ac_cpp='$CXXCPP $CPPFLAGS'
9242 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9243 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9244 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9245 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
9246 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
9247 > if test -z "$CXXCPP"; then
9248 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
9249 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9250 > else
9251 >      # Double quotes because CXXCPP needs to be expanded
9252 >    for CXXCPP in "$CXX -E" "/lib/cpp"
9253 >    do
9254 >      ac_preproc_ok=false
9255 > for ac_cxx_preproc_warn_flag in '' yes
9256 > do
9257 >  # Use a header file that comes with gcc, so configuring glibc
9258 >  # with a fresh cross-compiler works.
9259 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9260 >  # <limits.h> exists even on freestanding compilers.
9261 >  # On the NeXT, cc -E runs the code through the compiler's parser,
9262 >  # not just through cpp. "Syntax error" is here to catch this case.
9263 >  cat >conftest.$ac_ext <<_ACEOF
9264 > /* confdefs.h.  */
9265 > _ACEOF
9266 > cat confdefs.h >>conftest.$ac_ext
9267 > cat >>conftest.$ac_ext <<_ACEOF
9268 > /* end confdefs.h.  */
9269 > #ifdef __STDC__
9270 > # include <limits.h>
9271 > #else
9272 > # include <assert.h>
9273 > #endif
9274 >                     Syntax error
9275 > _ACEOF
9276 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9277 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9278 >  ac_status=$?
9279 >  grep -v '^ *+' conftest.er1 >conftest.err
9280 >  rm -f conftest.er1
9281 >  cat conftest.err >&5
9282 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9283 >  (exit $ac_status); } >/dev/null; then
9284 >  if test -s conftest.err; then
9285 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9286 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9287 >  else
9288 >    ac_cpp_err=
9289 >  fi
9290 > else
9291 >  ac_cpp_err=yes
9292 > fi
9293 > if test -z "$ac_cpp_err"; then
9294 >  :
9295 > else
9296 >  echo "$as_me: failed program was:" >&5
9297 > sed 's/^/| /' conftest.$ac_ext >&5
9298 >
9299 >  # Broken: fails on valid input.
9300 > continue
9301 > fi
9302 > rm -f conftest.err conftest.$ac_ext
9303 >
9304 >  # OK, works on sane cases.  Now check whether non-existent headers
9305 >  # can be detected and how.
9306 >  cat >conftest.$ac_ext <<_ACEOF
9307 > /* confdefs.h.  */
9308 > _ACEOF
9309 > cat confdefs.h >>conftest.$ac_ext
9310 > cat >>conftest.$ac_ext <<_ACEOF
9311 > /* end confdefs.h.  */
9312 > #include <ac_nonexistent.h>
9313 > _ACEOF
9314 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9315 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9316 >  ac_status=$?
9317 >  grep -v '^ *+' conftest.er1 >conftest.err
9318 >  rm -f conftest.er1
9319 >  cat conftest.err >&5
9320 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9321 >  (exit $ac_status); } >/dev/null; then
9322 >  if test -s conftest.err; then
9323 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9324 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9325 >  else
9326 >    ac_cpp_err=
9327 >  fi
9328 > else
9329 >  ac_cpp_err=yes
9330 > fi
9331 > if test -z "$ac_cpp_err"; then
9332 >  # Broken: success on invalid input.
9333 > continue
9334 > else
9335 >  echo "$as_me: failed program was:" >&5
9336 > sed 's/^/| /' conftest.$ac_ext >&5
9337 >
9338 >  # Passes both tests.
9339 > ac_preproc_ok=:
9340 > break
9341 > fi
9342 > rm -f conftest.err conftest.$ac_ext
9343 >
9344 > done
9345 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9346 > rm -f conftest.err conftest.$ac_ext
9347 > if $ac_preproc_ok; then
9348 >  break
9349 > fi
9350 >
9351 >    done
9352 >    ac_cv_prog_CXXCPP=$CXXCPP
9353 >
9354 > fi
9355 >  CXXCPP=$ac_cv_prog_CXXCPP
9356 > else
9357 >  ac_cv_prog_CXXCPP=$CXXCPP
9358 > fi
9359 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
9360 > echo "${ECHO_T}$CXXCPP" >&6
9361 > ac_preproc_ok=false
9362 > for ac_cxx_preproc_warn_flag in '' yes
9363 > do
9364 >  # Use a header file that comes with gcc, so configuring glibc
9365 >  # with a fresh cross-compiler works.
9366 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9367 >  # <limits.h> exists even on freestanding compilers.
9368 >  # On the NeXT, cc -E runs the code through the compiler's parser,
9369 >  # not just through cpp. "Syntax error" is here to catch this case.
9370 >  cat >conftest.$ac_ext <<_ACEOF
9371 > /* confdefs.h.  */
9372 > _ACEOF
9373 > cat confdefs.h >>conftest.$ac_ext
9374 > cat >>conftest.$ac_ext <<_ACEOF
9375 > /* end confdefs.h.  */
9376 > #ifdef __STDC__
9377 > # include <limits.h>
9378 > #else
9379 > # include <assert.h>
9380 > #endif
9381 >                     Syntax error
9382 > _ACEOF
9383 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9384 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9385 >  ac_status=$?
9386 >  grep -v '^ *+' conftest.er1 >conftest.err
9387 >  rm -f conftest.er1
9388 >  cat conftest.err >&5
9389 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9390 >  (exit $ac_status); } >/dev/null; then
9391 >  if test -s conftest.err; then
9392 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9393 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9394 >  else
9395 >    ac_cpp_err=
9396 >  fi
9397 > else
9398 >  ac_cpp_err=yes
9399 > fi
9400 > if test -z "$ac_cpp_err"; then
9401 >  :
9402 > else
9403 >  echo "$as_me: failed program was:" >&5
9404 > sed 's/^/| /' conftest.$ac_ext >&5
9405 >
9406 >  # Broken: fails on valid input.
9407 > continue
9408 > fi
9409 > rm -f conftest.err conftest.$ac_ext
9410 >
9411 >  # OK, works on sane cases.  Now check whether non-existent headers
9412 >  # can be detected and how.
9413 >  cat >conftest.$ac_ext <<_ACEOF
9414 > /* confdefs.h.  */
9415 > _ACEOF
9416 > cat confdefs.h >>conftest.$ac_ext
9417 > cat >>conftest.$ac_ext <<_ACEOF
9418 > /* end confdefs.h.  */
9419 > #include <ac_nonexistent.h>
9420 > _ACEOF
9421 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9422 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9423 >  ac_status=$?
9424 >  grep -v '^ *+' conftest.er1 >conftest.err
9425 >  rm -f conftest.er1
9426 >  cat conftest.err >&5
9427 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9428 >  (exit $ac_status); } >/dev/null; then
9429 >  if test -s conftest.err; then
9430 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9431 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9432 >  else
9433 >    ac_cpp_err=
9434 >  fi
9435 > else
9436 >  ac_cpp_err=yes
9437 > fi
9438 > if test -z "$ac_cpp_err"; then
9439 >  # Broken: success on invalid input.
9440 > continue
9441 > else
9442 >  echo "$as_me: failed program was:" >&5
9443 > sed 's/^/| /' conftest.$ac_ext >&5
9444 >
9445 >  # Passes both tests.
9446 > ac_preproc_ok=:
9447 > break
9448 > fi
9449 > rm -f conftest.err conftest.$ac_ext
9450 >
9451 > done
9452 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9453 > rm -f conftest.err conftest.$ac_ext
9454 > if $ac_preproc_ok; then
9455 >  :
9456 > else
9457 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9458 > See \`config.log' for more details." >&5
9459 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9460 > See \`config.log' for more details." >&2;}
9461 >   { (exit 1); exit 1; }; }
9462 > fi
9463 >
9464 > ac_ext=cc
9465 > ac_cpp='$CXXCPP $CPPFLAGS'
9466 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9467 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9468 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9469 >
9470 >
9471 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
9472 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
9473 > if test "${ac_cv_cxx_have_stl+set}" = set; then
9474 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9475 > else
9476 >
9477 >
9478  
9479 < fi
9480 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9481 <    # Try with mode parameter
9482 <    cat >conftest.$ac_ext <<_ACEOF
9479 > ac_ext=cc
9480 > ac_cpp='$CXXCPP $CPPFLAGS'
9481 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9482 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9483 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9484 >
9485 > cat >conftest.$ac_ext <<_ACEOF
9486   /* confdefs.h.  */
9487   _ACEOF
9488   cat confdefs.h >>conftest.$ac_ext
9489   cat >>conftest.$ac_ext <<_ACEOF
9490   /* end confdefs.h.  */
9491 <
9492 < #ifdef HAVE_IOSTREAM
9493 < #include <fstream>
6543 < #else
6544 < #include <fstream.h>
6545 < #endif
6546 < #ifdef HAVE_STD_IOSTREAM
9491 > #include <list>
9492 > #include <deque>
9493 > #ifdef HAVE_NAMESPACES
9494   using namespace std;
9495   #endif
9496 <
9496 > #ifdef FC_DUMMY_MAIN
9497 > #ifndef FC_DUMMY_MAIN_EQ_F77
9498 > #  ifdef __cplusplus
9499 >     extern "C"
9500 > #  endif
9501 >   int FC_DUMMY_MAIN() { return 1; }
9502 > #endif
9503 > #endif
9504   int
9505   main ()
9506   {
9507 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
9507 > list<int> x; x.push_back(5);
9508 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
9509    ;
9510    return 0;
9511   }
# Line 6577 | Line 9532 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9532    ac_status=$?
9533    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9534    (exit $ac_status); }; }; then
9535 <  ac_cv_cxx_fstream_open_prot=yes
9535 >  ac_cv_cxx_have_stl=yes
9536   else
9537    echo "$as_me: failed program was:" >&5
9538   sed 's/^/| /' conftest.$ac_ext >&5
9539  
9540 + ac_cv_cxx_have_stl=no
9541   fi
9542   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9543 <    ac_ext=cc
9543 > ac_ext=cc
9544   ac_cpp='$CXXCPP $CPPFLAGS'
9545   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9546   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
# Line 6592 | Line 9548 | echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_
9548  
9549  
9550   fi
9551 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
9552 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
9553 <  if test "$ac_cv_cxx_have_fstream_open" = yes; then
9551 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
9552 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
9553 > if test "$ac_cv_cxx_have_stl" = yes; then
9554  
9555   cat >>confdefs.h <<\_ACEOF
9556 < #define HAVE_FSTREAM_OPEN 1
9556 > #define HAVE_STL
9557   _ACEOF
9558  
9559 <  fi
6604 <  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
9559 > fi
9560  
6606 cat >>confdefs.h <<\_ACEOF
6607 #define FSTREAM_OPEN_PROT 1
6608 _ACEOF
9561  
6610  fi
9562  
9563 <
9564 <
9565 <
9566 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
6616 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
6617 < if test "${ac_cv_lib_m_asin+set}" = set; then
9563 >  if test "${ac_cv_header_iostream+set}" = set; then
9564 >  echo "$as_me:$LINENO: checking for iostream" >&5
9565 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
9566 > if test "${ac_cv_header_iostream+set}" = set; then
9567    echo $ECHO_N "(cached) $ECHO_C" >&6
9568 + fi
9569 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
9570 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
9571   else
9572 <  ac_check_lib_save_LIBS=$LIBS
9573 < LIBS="-lm  $LIBS"
9572 >  # Is the header compilable?
9573 > echo "$as_me:$LINENO: checking iostream usability" >&5
9574 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
9575   cat >conftest.$ac_ext <<_ACEOF
9576   /* confdefs.h.  */
9577   _ACEOF
9578   cat confdefs.h >>conftest.$ac_ext
9579   cat >>conftest.$ac_ext <<_ACEOF
9580   /* end confdefs.h.  */
9581 <
9582 < /* 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 < }
9581 > $ac_includes_default
9582 > #include <iostream>
9583   _ACEOF
9584 < rm -f conftest.$ac_objext conftest$ac_exeext
9585 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9586 <  (eval $ac_link) 2>conftest.er1
9584 > rm -f conftest.$ac_objext
9585 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9586 >  (eval $ac_compile) 2>conftest.er1
9587    ac_status=$?
9588    grep -v '^ *+' conftest.er1 >conftest.err
9589    rm -f conftest.er1
# Line 6657 | Line 9597 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9597    ac_status=$?
9598    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9599    (exit $ac_status); }; } &&
9600 <         { ac_try='test -s conftest$ac_exeext'
9600 >         { ac_try='test -s conftest.$ac_objext'
9601    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9602    (eval $ac_try) 2>&5
9603    ac_status=$?
9604    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9605    (exit $ac_status); }; }; then
9606 <  ac_cv_lib_m_asin=yes
9606 >  ac_header_compiler=yes
9607   else
9608    echo "$as_me: failed program was:" >&5
9609   sed 's/^/| /' conftest.$ac_ext >&5
9610  
9611 < ac_cv_lib_m_asin=no
9611 > ac_header_compiler=no
9612   fi
9613 < rm -f conftest.err conftest.$ac_objext \
9614 <      conftest$ac_exeext conftest.$ac_ext
9615 < 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
9613 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9614 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9615 > echo "${ECHO_T}$ac_header_compiler" >&6
9616  
9617 <  LIBS="-lm $LIBS"
9618 <
9619 < else
6687 <  exit
6688 < fi
6689 <
6690 <
6691 <
6692 < #
6693 < # Handle user hints
6694 < #
6695 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
6696 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
6697 <
6698 < # Check whether --with-zlib or --without-zlib was given.
6699 < if test "${with_zlib+set}" = set; then
6700 <  withval="$with_zlib"
6701 <  if test "$withval" != no ; then
6702 <  echo "$as_me:$LINENO: result: yes" >&5
6703 < echo "${ECHO_T}yes" >&6
6704 <  if test -d "$withval"
6705 <  then
6706 <    ZLIB_HOME="$withval"
6707 <  else
6708 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
6709 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
6710 <  fi
6711 < else
6712 <  echo "$as_me:$LINENO: result: no" >&5
6713 < echo "${ECHO_T}no" >&6
6714 < fi
6715 < fi;
6716 <
6717 < ZLIB_HOME=/usr/local
6718 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
6719 < then
6720 <        ZLIB_HOME=/usr
6721 < fi
6722 <
6723 < #
6724 < # Locate zlib, if wanted
6725 < #
6726 < if test -n "${ZLIB_HOME}"
6727 < then
6728 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
6729 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
6730 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
6731 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
6732 <
6733 <
6734 <        ac_ext=c
6735 < ac_cpp='$CPP $CPPFLAGS'
6736 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6737 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6738 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6739 <
6740 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6741 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6742 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6743 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6744 < else
6745 <  ac_check_lib_save_LIBS=$LIBS
6746 < LIBS="-lz  $LIBS"
9617 > # Is the header present?
9618 > echo "$as_me:$LINENO: checking iostream presence" >&5
9619 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
9620   cat >conftest.$ac_ext <<_ACEOF
9621   /* confdefs.h.  */
9622   _ACEOF
9623   cat confdefs.h >>conftest.$ac_ext
9624   cat >>conftest.$ac_ext <<_ACEOF
9625   /* end confdefs.h.  */
9626 <
6754 < /* Override any gcc2 internal prototype to avoid an error.  */
6755 < #ifdef __cplusplus
6756 < extern "C"
6757 < #endif
6758 < /* We use char because int might match the return type of a gcc2
6759 <   builtin and then its argument prototype would still apply.  */
6760 < char inflateEnd ();
6761 < int
6762 < main ()
6763 < {
6764 < inflateEnd ();
6765 <  ;
6766 <  return 0;
6767 < }
9626 > #include <iostream>
9627   _ACEOF
9628 < rm -f conftest.$ac_objext conftest$ac_exeext
9629 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6771 <  (eval $ac_link) 2>conftest.er1
9628 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9629 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9630    ac_status=$?
9631    grep -v '^ *+' conftest.er1 >conftest.err
9632    rm -f conftest.er1
9633    cat conftest.err >&5
9634    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9635 <  (exit $ac_status); } &&
9636 <         { ac_try='test -z "$ac_c_werror_flag"
9637 <                         || test ! -s conftest.err'
9638 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9639 <  (eval $ac_try) 2>&5
9640 <  ac_status=$?
9641 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6784 <  (exit $ac_status); }; } &&
6785 <         { ac_try='test -s conftest$ac_exeext'
6786 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6787 <  (eval $ac_try) 2>&5
6788 <  ac_status=$?
6789 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6790 <  (exit $ac_status); }; }; then
6791 <  ac_cv_lib_z_inflateEnd=yes
9635 >  (exit $ac_status); } >/dev/null; then
9636 >  if test -s conftest.err; then
9637 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9638 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9639 >  else
9640 >    ac_cpp_err=
9641 >  fi
9642   else
9643 +  ac_cpp_err=yes
9644 + fi
9645 + if test -z "$ac_cpp_err"; then
9646 +  ac_header_preproc=yes
9647 + else
9648    echo "$as_me: failed program was:" >&5
9649   sed 's/^/| /' conftest.$ac_ext >&5
9650  
9651 < ac_cv_lib_z_inflateEnd=no
9651 >  ac_header_preproc=no
9652   fi
9653 < rm -f conftest.err conftest.$ac_objext \
9654 <      conftest$ac_exeext conftest.$ac_ext
9655 < LIBS=$ac_check_lib_save_LIBS
9656 < fi
9657 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
9658 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
9659 < if test $ac_cv_lib_z_inflateEnd = yes; then
9660 <  zlib_cv_libz=yes
9653 > rm -f conftest.err conftest.$ac_ext
9654 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9655 > echo "${ECHO_T}$ac_header_preproc" >&6
9656 >
9657 > # So?  What about this header?
9658 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9659 >  yes:no: )
9660 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
9661 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
9662 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
9663 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
9664 >    ac_header_preproc=yes
9665 >    ;;
9666 >  no:yes:* )
9667 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
9668 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
9669 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
9670 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
9671 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
9672 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
9673 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
9674 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
9675 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
9676 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
9677 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
9678 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
9679 >    (
9680 >      cat <<\_ASBOX
9681 > ## ------------------------------ ##
9682 > ## Report this to gezelter@nd.edu ##
9683 > ## ------------------------------ ##
9684 > _ASBOX
9685 >    ) |
9686 >      sed "s/^/$as_me: WARNING:     /" >&2
9687 >    ;;
9688 > esac
9689 > echo "$as_me:$LINENO: checking for iostream" >&5
9690 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
9691 > if test "${ac_cv_header_iostream+set}" = set; then
9692 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9693   else
9694 <  zlib_cv_libz=no
9694 >  ac_cv_header_iostream=$ac_header_preproc
9695   fi
9696 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
9697 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
9698  
9699 <        if test "${ac_cv_header_zlib_h+set}" = set; then
9700 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
9701 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
9702 < if test "${ac_cv_header_zlib_h+set}" = set; then
9699 > fi
9700 > if test $ac_cv_header_iostream = yes; then
9701 >
9702 >
9703 > cat >>confdefs.h <<\_ACEOF
9704 > #define HAVE_IOSTREAM 1
9705 > _ACEOF
9706 >
9707 >
9708 > else
9709 >
9710 >
9711 > for ac_header in iostream.h
9712 > do
9713 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9714 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9715 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9716 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9717 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9718    echo $ECHO_N "(cached) $ECHO_C" >&6
9719   fi
9720 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
9721 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
9720 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9721 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9722   else
9723    # Is the header compilable?
9724 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
9725 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
9724 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9725 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9726   cat >conftest.$ac_ext <<_ACEOF
9727   /* confdefs.h.  */
9728   _ACEOF
# Line 6826 | Line 9730 | $ac_includes_default
9730   cat >>conftest.$ac_ext <<_ACEOF
9731   /* end confdefs.h.  */
9732   $ac_includes_default
9733 < #include <zlib.h>
9733 > #include <$ac_header>
9734   _ACEOF
9735   rm -f conftest.$ac_objext
9736   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6837 | Line 9741 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9741    cat conftest.err >&5
9742    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9743    (exit $ac_status); } &&
9744 <         { ac_try='test -z "$ac_c_werror_flag"
9744 >         { ac_try='test -z "$ac_cxx_werror_flag"
9745                           || test ! -s conftest.err'
9746    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9747    (eval $ac_try) 2>&5
# Line 6862 | Line 9766 | echo "$as_me:$LINENO: checking zlib.h presence" >&5
9766   echo "${ECHO_T}$ac_header_compiler" >&6
9767  
9768   # Is the header present?
9769 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
9770 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
9769 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9770 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9771   cat >conftest.$ac_ext <<_ACEOF
9772   /* confdefs.h.  */
9773   _ACEOF
9774   cat confdefs.h >>conftest.$ac_ext
9775   cat >>conftest.$ac_ext <<_ACEOF
9776   /* end confdefs.h.  */
9777 < #include <zlib.h>
9777 > #include <$ac_header>
9778   _ACEOF
9779   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9780    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6881 | Line 9785 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
9785    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9786    (exit $ac_status); } >/dev/null; then
9787    if test -s conftest.err; then
9788 <    ac_cpp_err=$ac_c_preproc_warn_flag
9789 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9788 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9789 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9790    else
9791      ac_cpp_err=
9792    fi
# Line 6902 | Line 9806 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
9806   echo "${ECHO_T}$ac_header_preproc" >&6
9807  
9808   # So?  What about this header?
9809 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9809 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9810    yes:no: )
9811 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
9812 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9813 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
9814 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
9811 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9812 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9813 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9814 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9815      ac_header_preproc=yes
9816      ;;
9817    no:yes:* )
9818 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
9819 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
9820 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
9821 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
9822 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
9823 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
9824 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
9825 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9826 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
9827 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
9828 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
9829 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
9818 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9819 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9820 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9821 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9822 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9823 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9824 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9825 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9826 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9827 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9828 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9829 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9830      (
9831        cat <<\_ASBOX
9832   ## ------------------------------ ##
# Line 6933 | Line 9837 | echo "$as_me:$LINENO: checking for zlib.h" >&5
9837        sed "s/^/$as_me: WARNING:     /" >&2
9838      ;;
9839   esac
9840 < echo "$as_me:$LINENO: checking for zlib.h" >&5
9841 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
9842 < if test "${ac_cv_header_zlib_h+set}" = set; then
9840 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9841 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9842 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9843    echo $ECHO_N "(cached) $ECHO_C" >&6
9844   else
9845 <  ac_cv_header_zlib_h=$ac_header_preproc
9845 >  eval "$as_ac_Header=\$ac_header_preproc"
9846   fi
9847 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
9848 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
9847 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9848 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9849  
9850   fi
9851 < if test $ac_cv_header_zlib_h = yes; then
9852 <  zlib_cv_zlib_h=yes
9853 < else
9854 <  zlib_cv_zlib_h=no
9851 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9852 >  cat >>confdefs.h <<_ACEOF
9853 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9854 > _ACEOF
9855 >
9856   fi
9857  
9858 + done
9859  
6954        ac_ext=cc
6955 ac_cpp='$CXXCPP $CPPFLAGS'
6956 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6957 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6958 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9860  
9861 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6961 <        then
6962 <                #
6963 <                # If both library and header were found, use them
6964 <                #
9861 > fi
9862  
9863 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
9864 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
9865 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
9863 >
9864 >
9865 >
9866 >  if test "${ac_cv_header_iomanip+set}" = set; then
9867 >  echo "$as_me:$LINENO: checking for iomanip" >&5
9868 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
9869 > if test "${ac_cv_header_iomanip+set}" = set; then
9870    echo $ECHO_N "(cached) $ECHO_C" >&6
9871 + fi
9872 + echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
9873 + echo "${ECHO_T}$ac_cv_header_iomanip" >&6
9874   else
9875 <  ac_check_lib_save_LIBS=$LIBS
9876 < LIBS="-lz  $LIBS"
9875 >  # Is the header compilable?
9876 > echo "$as_me:$LINENO: checking iomanip usability" >&5
9877 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
9878   cat >conftest.$ac_ext <<_ACEOF
9879   /* confdefs.h.  */
9880   _ACEOF
9881   cat confdefs.h >>conftest.$ac_ext
9882   cat >>conftest.$ac_ext <<_ACEOF
9883   /* end confdefs.h.  */
9884 <
9885 < /* Override any gcc2 internal prototype to avoid an error.  */
6981 < #ifdef __cplusplus
6982 < extern "C"
6983 < #endif
6984 < /* We use char because int might match the return type of a gcc2
6985 <   builtin and then its argument prototype would still apply.  */
6986 < char inflateEnd ();
6987 < int
6988 < main ()
6989 < {
6990 < inflateEnd ();
6991 <  ;
6992 <  return 0;
6993 < }
9884 > $ac_includes_default
9885 > #include <iomanip>
9886   _ACEOF
9887 < rm -f conftest.$ac_objext conftest$ac_exeext
9888 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9889 <  (eval $ac_link) 2>conftest.er1
9887 > rm -f conftest.$ac_objext
9888 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9889 >  (eval $ac_compile) 2>conftest.er1
9890    ac_status=$?
9891    grep -v '^ *+' conftest.er1 >conftest.err
9892    rm -f conftest.er1
# Line 7008 | Line 9900 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9900    ac_status=$?
9901    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9902    (exit $ac_status); }; } &&
9903 <         { ac_try='test -s conftest$ac_exeext'
9903 >         { ac_try='test -s conftest.$ac_objext'
9904    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9905    (eval $ac_try) 2>&5
9906    ac_status=$?
9907    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9908    (exit $ac_status); }; }; then
9909 <  ac_cv_lib_z_inflateEnd=yes
9909 >  ac_header_compiler=yes
9910   else
9911    echo "$as_me: failed program was:" >&5
9912   sed 's/^/| /' conftest.$ac_ext >&5
9913  
9914 < ac_cv_lib_z_inflateEnd=no
9914 > ac_header_compiler=no
9915   fi
9916 < rm -f conftest.err conftest.$ac_objext \
9917 <      conftest$ac_exeext conftest.$ac_ext
9918 < LIBS=$ac_check_lib_save_LIBS
7027 < fi
7028 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7029 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
7030 < if test $ac_cv_lib_z_inflateEnd = yes; then
7031 <  cat >>confdefs.h <<_ACEOF
7032 < #define HAVE_LIBZ 1
7033 < _ACEOF
9916 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9917 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9918 > echo "${ECHO_T}$ac_header_compiler" >&6
9919  
9920 <  LIBS="-lz $LIBS"
9921 <
9922 < fi
9923 <
9924 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
9925 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
9926 <                echo "$as_me:$LINENO: result: ok" >&5
9927 < echo "${ECHO_T}ok" >&6
9928 <        else
9929 <                #
9930 <                # If either header or library was not found, revert and bomb
9931 <                #
9932 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
9933 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
9934 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
9935 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
9936 <                echo "$as_me:$LINENO: result: failed" >&5
9937 < echo "${ECHO_T}failed" >&6
9938 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
9939 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
9940 <   { (exit 1); exit 1; }; }
9941 <        fi
9920 > # Is the header present?
9921 > echo "$as_me:$LINENO: checking iomanip presence" >&5
9922 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
9923 > cat >conftest.$ac_ext <<_ACEOF
9924 > /* confdefs.h.  */
9925 > _ACEOF
9926 > cat confdefs.h >>conftest.$ac_ext
9927 > cat >>conftest.$ac_ext <<_ACEOF
9928 > /* end confdefs.h.  */
9929 > #include <iomanip>
9930 > _ACEOF
9931 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9932 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9933 >  ac_status=$?
9934 >  grep -v '^ *+' conftest.er1 >conftest.err
9935 >  rm -f conftest.er1
9936 >  cat conftest.err >&5
9937 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9938 >  (exit $ac_status); } >/dev/null; then
9939 >  if test -s conftest.err; then
9940 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9941 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9942 >  else
9943 >    ac_cpp_err=
9944 >  fi
9945 > else
9946 >  ac_cpp_err=yes
9947   fi
9948 + if test -z "$ac_cpp_err"; then
9949 +  ac_header_preproc=yes
9950 + else
9951 +  echo "$as_me: failed program was:" >&5
9952 + sed 's/^/| /' conftest.$ac_ext >&5
9953  
9954 +  ac_header_preproc=no
9955 + fi
9956 + rm -f conftest.err conftest.$ac_ext
9957 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9958 + echo "${ECHO_T}$ac_header_preproc" >&6
9959  
9960 <
9961 <
9962 <
9963 <
9964 <
9965 <
9966 <
9967 <
9968 <
9969 <
9970 <
9971 <
9960 > # So?  What about this header?
9961 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9962 >  yes:no: )
9963 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
9964 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
9965 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
9966 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
9967 >    ac_header_preproc=yes
9968 >    ;;
9969 >  no:yes:* )
9970 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
9971 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
9972 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
9973 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
9974 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
9975 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
9976 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
9977 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
9978 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
9979 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
9980 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
9981 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
9982 >    (
9983 >      cat <<\_ASBOX
9984 > ## ------------------------------ ##
9985 > ## Report this to gezelter@nd.edu ##
9986 > ## ------------------------------ ##
9987 > _ASBOX
9988 >    ) |
9989 >      sed "s/^/$as_me: WARNING:     /" >&2
9990 >    ;;
9991 > esac
9992 > echo "$as_me:$LINENO: checking for iomanip" >&5
9993 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
9994 > if test "${ac_cv_header_iomanip+set}" = set; then
9995 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9996 > else
9997 >  ac_cv_header_iomanip=$ac_header_preproc
9998 > fi
9999 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10000 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10001  
10002 + fi
10003 + if test $ac_cv_header_iomanip = yes; then
10004  
10005  
10006 + cat >>confdefs.h <<\_ACEOF
10007 + #define HAVE_IOMANIP 1
10008 + _ACEOF
10009  
10010  
10011 + else
10012  
10013  
10014 < 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
10014 > for ac_header in iomanip.h
10015   do
10016   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10017   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7225 | Line 10160 | ac_ext=cc
10160  
10161   done
10162  
7228 ac_ext=cc
7229 ac_cpp='$CXXCPP $CPPFLAGS'
7230 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7231 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7232 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10163  
10164 + fi
10165  
10166  
10167  
10168  
10169 <
7239 < for ac_header in ctype.h iostream fstream sstream strstream
10169 > for ac_header in cmath
10170   do
10171   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10172   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7384 | Line 10314 | done
10314   fi
10315  
10316   done
7387
7388 ac_ext=c
7389 ac_cpp='$CPP $CPPFLAGS'
7390 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7391 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7392 ac_compiler_gnu=$ac_cv_c_compiler_gnu
7393
10317  
10318  
10319  
10320  
10321 +  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
10322 + echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
10323 + if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
10324 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10325 + else
10326  
10327 +      ac_cv_cxx_have_std_iostream=no
10328 +      ac_cv_cxx_need_use_std_iostream=no
10329 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
10330  
10331  
10332 +        ac_ext=cc
10333 + ac_cpp='$CXXCPP $CPPFLAGS'
10334 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10335 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10336 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10337  
10338 <
7403 <
7404 <
7405 <
7406 < for ac_func in rint snprintf sranddev strcasecmp strncasecmp stricmp strnicmp pstat_getstatic sysmp getsysinfo sysctl table
7407 < do
7408 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7409 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7410 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7411 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7412 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7413 < else
7414 <  cat >conftest.$ac_ext <<_ACEOF
10338 >        cat >conftest.$ac_ext <<_ACEOF
10339   /* confdefs.h.  */
10340   _ACEOF
10341   cat confdefs.h >>conftest.$ac_ext
10342   cat >>conftest.$ac_ext <<_ACEOF
10343   /* end confdefs.h.  */
7420 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7421   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7422 #define $ac_func innocuous_$ac_func
10344  
10345 < /* System header to define __stub macros and hopefully few prototypes,
10346 <    which can conflict with char $ac_func (); below.
7426 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7427 <    <limits.h> exists even on freestanding compilers.  */
7428 <
7429 < #ifdef __STDC__
7430 < # include <limits.h>
10345 > #ifdef HAVE_IOSTREAM
10346 > #include <iostream>
10347   #else
10348 < # include <assert.h>
10348 > #include <iostream.h>
10349   #endif
10350  
10351 < #undef $ac_func
10352 <
10353 < /* Override any gcc2 internal prototype to avoid an error.  */
10354 < #ifdef __cplusplus
10355 < extern "C"
10356 < {
10351 > #ifdef FC_DUMMY_MAIN
10352 > #ifndef FC_DUMMY_MAIN_EQ_F77
10353 > #  ifdef __cplusplus
10354 >     extern "C"
10355 > #  endif
10356 >   int FC_DUMMY_MAIN() { return 1; }
10357   #endif
7442 /* We use char because int might match the return type of a gcc2
7443   builtin and then its argument prototype would still apply.  */
7444 char $ac_func ();
7445 /* The GNU C library defines this for functions which it implements
7446    to always fail with ENOSYS.  Some functions are actually named
7447    something starting with __ and the normal name is an alias.  */
7448 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7449 choke me
7450 #else
7451 char (*f) () = $ac_func;
10358   #endif
7453 #ifdef __cplusplus
7454 }
7455 #endif
7456
10359   int
10360   main ()
10361   {
10362 < return f != $ac_func;
10362 > std::cout<<"Hello World"<<std::endl;return 0;
10363    ;
10364    return 0;
10365   }
10366   _ACEOF
10367 < rm -f conftest.$ac_objext conftest$ac_exeext
10368 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10369 <  (eval $ac_link) 2>conftest.er1
10367 > rm -f conftest.$ac_objext
10368 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10369 >  (eval $ac_compile) 2>conftest.er1
10370    ac_status=$?
10371    grep -v '^ *+' conftest.er1 >conftest.err
10372    rm -f conftest.er1
10373    cat conftest.err >&5
10374    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10375    (exit $ac_status); } &&
10376 <         { ac_try='test -z "$ac_c_werror_flag"
10376 >         { ac_try='test -z "$ac_cxx_werror_flag"
10377                           || test ! -s conftest.err'
10378    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10379    (eval $ac_try) 2>&5
10380    ac_status=$?
10381    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10382    (exit $ac_status); }; } &&
10383 <         { ac_try='test -s conftest$ac_exeext'
10383 >         { ac_try='test -s conftest.$ac_objext'
10384    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10385    (eval $ac_try) 2>&5
10386    ac_status=$?
10387    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10388    (exit $ac_status); }; }; then
10389 <  eval "$as_ac_var=yes"
10389 >  ac_cv_cxx_have_std_iostream=yes
10390   else
10391    echo "$as_me: failed program was:" >&5
10392   sed 's/^/| /' conftest.$ac_ext >&5
10393  
7492 eval "$as_ac_var=no"
10394   fi
10395 < rm -f conftest.err conftest.$ac_objext \
10396 <      conftest$ac_exeext conftest.$ac_ext
7496 < fi
7497 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7498 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7499 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7500 <  cat >>confdefs.h <<_ACEOF
7501 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7502 < _ACEOF
7503 <
7504 < fi
7505 < done
7506 <
7507 < # special check for _system_configuration because AIX <4.3.2 do not
7508 < # contain the `physmem' member.
7509 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
7510 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
7511 < cat >conftest.$ac_ext <<_ACEOF
10395 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10396 >        cat >conftest.$ac_ext <<_ACEOF
10397   /* confdefs.h.  */
10398   _ACEOF
10399   cat confdefs.h >>conftest.$ac_ext
10400   cat >>conftest.$ac_ext <<_ACEOF
10401   /* end confdefs.h.  */
10402 < #include <sys/systemcfg.h>
10402 >
10403 > #define __USE_STD_IOSTREAM 1
10404 > #ifdef HAVE_IOSTREAM
10405 > #include <iostream>
10406 > #else
10407 > #include <iostream.h>
10408 > #endif
10409 >
10410 > #ifdef FC_DUMMY_MAIN
10411 > #ifndef FC_DUMMY_MAIN_EQ_F77
10412 > #  ifdef __cplusplus
10413 >     extern "C"
10414 > #  endif
10415 >   int FC_DUMMY_MAIN() { return 1; }
10416 > #endif
10417 > #endif
10418   int
10419   main ()
10420   {
10421 < double x = _system_configuration.physmem;
10421 > std::cout<<"Hello World"<<std::endl;return 0;
10422    ;
10423    return 0;
10424   }
# Line 7532 | Line 10432 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10432    cat conftest.err >&5
10433    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10434    (exit $ac_status); } &&
10435 <         { ac_try='test -z "$ac_c_werror_flag"
10435 >         { ac_try='test -z "$ac_cxx_werror_flag"
10436                           || test ! -s conftest.err'
10437    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10438    (eval $ac_try) 2>&5
# Line 7545 | Line 10445 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10445    ac_status=$?
10446    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10447    (exit $ac_status); }; }; then
10448 <  echo "$as_me:$LINENO: result: yes" >&5
7549 < echo "${ECHO_T}yes" >&6
7550 <
7551 < cat >>confdefs.h <<\_ACEOF
7552 < #define HAVE__SYSTEM_CONFIGURATION 1
7553 < _ACEOF
7554 <
10448 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
10449   else
10450    echo "$as_me: failed program was:" >&5
10451   sed 's/^/| /' conftest.$ac_ext >&5
10452  
7559 echo "$as_me:$LINENO: result: no" >&5
7560 echo "${ECHO_T}no" >&6
10453   fi
10454   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10455 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
10456 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
10457 < if test "${ac_cv_header_time+set}" = set; then
10455 >        ac_ext=cc
10456 > ac_cpp='$CXXCPP $CPPFLAGS'
10457 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10458 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10459 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10460 >
10461 >      fi
10462 >
10463 > fi
10464 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
10465 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
10466 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
10467 >
10468 > cat >>confdefs.h <<\_ACEOF
10469 > #define HAVE_STD_IOSTREAM 1
10470 > _ACEOF
10471 >
10472 >  fi
10473 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
10474 >
10475 > cat >>confdefs.h <<\_ACEOF
10476 > #define __USE_STD_IOSTREAM 1
10477 > _ACEOF
10478 >
10479 >  fi
10480 >
10481 >
10482 >
10483 >
10484 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
10485 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
10486 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
10487    echo $ECHO_N "(cached) $ECHO_C" >&6
10488   else
10489 <  cat >conftest.$ac_ext <<_ACEOF
10489 >
10490 >      ac_cv_cxx_have_std_stl=no
10491 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
10492 >
10493 >
10494 >        ac_ext=cc
10495 > ac_cpp='$CXXCPP $CPPFLAGS'
10496 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10497 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10498 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10499 >
10500 >        cat >conftest.$ac_ext <<_ACEOF
10501   /* confdefs.h.  */
10502   _ACEOF
10503   cat confdefs.h >>conftest.$ac_ext
10504   cat >>conftest.$ac_ext <<_ACEOF
10505   /* end confdefs.h.  */
10506 < #include <sys/types.h>
7575 < #include <sys/time.h>
7576 < #include <time.h>
10506 > #include <list>
10507  
10508 + #ifdef FC_DUMMY_MAIN
10509 + #ifndef FC_DUMMY_MAIN_EQ_F77
10510 + #  ifdef __cplusplus
10511 +     extern "C"
10512 + #  endif
10513 +   int FC_DUMMY_MAIN() { return 1; }
10514 + #endif
10515 + #endif
10516   int
10517   main ()
10518   {
10519 < if ((struct tm *) 0)
7582 < return 0;
10519 > std::list<int> foo;return 0;
10520    ;
10521    return 0;
10522   }
# Line 7593 | Line 10530 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10530    cat conftest.err >&5
10531    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10532    (exit $ac_status); } &&
10533 <         { ac_try='test -z "$ac_c_werror_flag"
10533 >         { ac_try='test -z "$ac_cxx_werror_flag"
10534                           || test ! -s conftest.err'
10535    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10536    (eval $ac_try) 2>&5
# Line 7606 | Line 10543 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10543    ac_status=$?
10544    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10545    (exit $ac_status); }; }; then
10546 <  ac_cv_header_time=yes
10546 >  ac_cv_cxx_have_std_stl=yes
10547   else
10548    echo "$as_me: failed program was:" >&5
10549   sed 's/^/| /' conftest.$ac_ext >&5
10550  
7614 ac_cv_header_time=no
10551   fi
10552   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10553 +        ac_ext=cc
10554 + ac_cpp='$CXXCPP $CPPFLAGS'
10555 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10556 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10557 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10558 +
10559 +      fi
10560 +
10561   fi
10562 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
10563 < echo "${ECHO_T}$ac_cv_header_time" >&6
10564 < if test $ac_cv_header_time = yes; then
10562 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
10563 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
10564 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
10565  
10566   cat >>confdefs.h <<\_ACEOF
10567 < #define TIME_WITH_SYS_TIME 1
10567 > #define HAVE_STD_STL 1
10568   _ACEOF
10569  
10570 < fi
10570 >  fi
10571  
10572  
10573 < echo "$as_me:$LINENO: checking for clock_t" >&5
10574 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
10575 < if test "${ac_cv_type_clock_t+set}" = set; then
10573 >
10574 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
10575 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
10576 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
10577    echo $ECHO_N "(cached) $ECHO_C" >&6
10578   else
10579 <  cat >conftest.$ac_ext <<_ACEOF
10579 >
10580 >    ac_cv_cxx_have_fstream_attach=no
10581 >
10582 >
10583 >    ac_ext=cc
10584 > ac_cpp='$CXXCPP $CPPFLAGS'
10585 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10586 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10587 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10588 >
10589 >    cat >conftest.$ac_ext <<_ACEOF
10590   /* confdefs.h.  */
10591   _ACEOF
10592   cat confdefs.h >>conftest.$ac_ext
10593   cat >>conftest.$ac_ext <<_ACEOF
10594   /* end confdefs.h.  */
10595 < $ac_includes_default
10595 >
10596 > #ifdef HAVE_IOSTREAM
10597 > #include <fstream>
10598 > #else
10599 > #include <fstream.h>
10600 > #endif
10601 > #ifdef HAVE_STD_IOSTREAM
10602 > using namespace std;
10603 > #endif
10604 >
10605 > #ifdef FC_DUMMY_MAIN
10606 > #ifndef FC_DUMMY_MAIN_EQ_F77
10607 > #  ifdef __cplusplus
10608 >     extern "C"
10609 > #  endif
10610 >   int FC_DUMMY_MAIN() { return 1; }
10611 > #endif
10612 > #endif
10613   int
10614   main ()
10615   {
10616 < if ((clock_t *) 0)
7645 <  return 0;
7646 < if (sizeof (clock_t))
7647 <  return 0;
10616 > int fd=0;ofstream s;s.attach(fd);
10617    ;
10618    return 0;
10619   }
# Line 7658 | Line 10627 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10627    cat conftest.err >&5
10628    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10629    (exit $ac_status); } &&
10630 <         { ac_try='test -z "$ac_c_werror_flag"
10630 >         { ac_try='test -z "$ac_cxx_werror_flag"
10631                           || test ! -s conftest.err'
10632    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10633    (eval $ac_try) 2>&5
# Line 7671 | Line 10640 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10640    ac_status=$?
10641    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10642    (exit $ac_status); }; }; then
10643 <  ac_cv_type_clock_t=yes
10643 >  ac_cv_cxx_have_fstream_attach=yes
10644   else
10645    echo "$as_me: failed program was:" >&5
10646   sed 's/^/| /' conftest.$ac_ext >&5
10647  
7679 ac_cv_type_clock_t=no
10648   fi
10649   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10650 +    ac_ext=cc
10651 + ac_cpp='$CXXCPP $CPPFLAGS'
10652 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10653 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10654 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10655 +
10656 +
10657   fi
10658 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
10659 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
10660 < if test $ac_cv_type_clock_t = yes; then
10658 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
10659 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
10660 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
10661  
10662 < cat >>confdefs.h <<_ACEOF
10663 < #define HAVE_CLOCK_T 1
10662 > cat >>confdefs.h <<\_ACEOF
10663 > #define HAVE_FSTREAM_ATTACH 1
10664   _ACEOF
10665  
10666 +  fi
10667  
7692 fi
10668  
10669 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
10670 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
10671 < if test "${ac_cv_c_const+set}" = set; then
10669 >
10670 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
10671 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
10672 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
10673    echo $ECHO_N "(cached) $ECHO_C" >&6
10674   else
10675 <  cat >conftest.$ac_ext <<_ACEOF
10675 >
10676 >    ac_cv_cxx_have_fstream_open=no
10677 >    ac_cv_cxx_fstream_open_prot=no
10678 >
10679 >
10680 >    ac_ext=cc
10681 > ac_cpp='$CXXCPP $CPPFLAGS'
10682 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10683 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10684 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10685 >
10686 >    # Try with 2 parameters
10687 >    cat >conftest.$ac_ext <<_ACEOF
10688   /* confdefs.h.  */
10689   _ACEOF
10690   cat confdefs.h >>conftest.$ac_ext
10691   cat >>conftest.$ac_ext <<_ACEOF
10692   /* end confdefs.h.  */
10693  
10694 + #ifdef HAVE_IOSTREAM
10695 + #include <fstream>
10696 + #else
10697 + #include <fstream.h>
10698 + #endif
10699 + #ifdef HAVE_STD_IOSTREAM
10700 + using namespace std;
10701 + #endif
10702 +
10703 + #ifdef FC_DUMMY_MAIN
10704 + #ifndef FC_DUMMY_MAIN_EQ_F77
10705 + #  ifdef __cplusplus
10706 +     extern "C"
10707 + #  endif
10708 +   int FC_DUMMY_MAIN() { return 1; }
10709 + #endif
10710 + #endif
10711   int
10712   main ()
10713   {
10714 < /* FIXME: Include the comments suggested by Paul. */
7710 < #ifndef __cplusplus
7711 <  /* Ultrix mips cc rejects this.  */
7712 <  typedef int charset[2];
7713 <  const charset x;
7714 <  /* SunOS 4.1.1 cc rejects this.  */
7715 <  char const *const *ccp;
7716 <  char **p;
7717 <  /* NEC SVR4.0.2 mips cc rejects this.  */
7718 <  struct point {int x, y;};
7719 <  static struct point const zero = {0,0};
7720 <  /* AIX XL C 1.02.0.0 rejects this.
7721 <     It does not let you subtract one const X* pointer from another in
7722 <     an arm of an if-expression whose if-part is not a constant
7723 <     expression */
7724 <  const char *g = "string";
7725 <  ccp = &g + (g ? g-g : 0);
7726 <  /* HPUX 7.0 cc rejects these. */
7727 <  ++ccp;
7728 <  p = (char**) ccp;
7729 <  ccp = (char const *const *) p;
7730 <  { /* SCO 3.2v4 cc rejects this.  */
7731 <    char *t;
7732 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
7733 <
7734 <    *t++ = 0;
7735 <  }
7736 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7737 <    int x[] = {25, 17};
7738 <    const int *foo = &x[0];
7739 <    ++foo;
7740 <  }
7741 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7742 <    typedef const int *iptr;
7743 <    iptr p = 0;
7744 <    ++p;
7745 <  }
7746 <  { /* AIX XL C 1.02.0.0 rejects this saying
7747 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7748 <    struct s { int j; const int *ap[3]; };
7749 <    struct s *b; b->j = 5;
7750 <  }
7751 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7752 <    const int foo = 10;
7753 <  }
7754 < #endif
7755 <
10714 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
10715    ;
10716    return 0;
10717   }
# Line 7766 | Line 10725 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10725    cat conftest.err >&5
10726    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10727    (exit $ac_status); } &&
10728 <         { ac_try='test -z "$ac_c_werror_flag"
10728 >         { ac_try='test -z "$ac_cxx_werror_flag"
10729                           || test ! -s conftest.err'
10730    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10731    (eval $ac_try) 2>&5
# Line 7779 | Line 10738 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10738    ac_status=$?
10739    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10740    (exit $ac_status); }; }; then
10741 <  ac_cv_c_const=yes
10741 >  ac_cv_cxx_have_fstream_open=yes
10742   else
10743    echo "$as_me: failed program was:" >&5
10744   sed 's/^/| /' conftest.$ac_ext >&5
10745  
7787 ac_cv_c_const=no
10746   fi
10747   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10748 < fi
10749 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7792 < echo "${ECHO_T}$ac_cv_c_const" >&6
7793 < if test $ac_cv_c_const = no; then
7794 <
7795 < cat >>confdefs.h <<\_ACEOF
7796 < #define const
7797 < _ACEOF
7798 <
7799 < fi
7800 <
7801 < echo "$as_me:$LINENO: checking for inline" >&5
7802 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7803 < if test "${ac_cv_c_inline+set}" = set; then
7804 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7805 < else
7806 <  ac_cv_c_inline=no
7807 < for ac_kw in inline __inline__ __inline; do
7808 <  cat >conftest.$ac_ext <<_ACEOF
10748 >    # Try with mode parameter
10749 >    cat >conftest.$ac_ext <<_ACEOF
10750   /* confdefs.h.  */
10751   _ACEOF
10752   cat confdefs.h >>conftest.$ac_ext
10753   cat >>conftest.$ac_ext <<_ACEOF
10754   /* end confdefs.h.  */
10755 < #ifndef __cplusplus
10756 < typedef int foo_t;
10757 < static $ac_kw foo_t static_foo () {return 0; }
10758 < $ac_kw foo_t foo () {return 0; }
10755 >
10756 > #ifdef HAVE_IOSTREAM
10757 > #include <fstream>
10758 > #else
10759 > #include <fstream.h>
10760   #endif
10761 + #ifdef HAVE_STD_IOSTREAM
10762 + using namespace std;
10763 + #endif
10764  
10765 + #ifdef FC_DUMMY_MAIN
10766 + #ifndef FC_DUMMY_MAIN_EQ_F77
10767 + #  ifdef __cplusplus
10768 +     extern "C"
10769 + #  endif
10770 +   int FC_DUMMY_MAIN() { return 1; }
10771 + #endif
10772 + #endif
10773 + int
10774 + main ()
10775 + {
10776 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
10777 +  ;
10778 +  return 0;
10779 + }
10780   _ACEOF
10781   rm -f conftest.$ac_objext
10782   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7827 | Line 10787 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10787    cat conftest.err >&5
10788    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10789    (exit $ac_status); } &&
10790 <         { ac_try='test -z "$ac_c_werror_flag"
10790 >         { ac_try='test -z "$ac_cxx_werror_flag"
10791                           || test ! -s conftest.err'
10792    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10793    (eval $ac_try) 2>&5
# Line 7840 | Line 10800 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10800    ac_status=$?
10801    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10802    (exit $ac_status); }; }; then
10803 <  ac_cv_c_inline=$ac_kw; break
10803 >  ac_cv_cxx_fstream_open_prot=yes
10804   else
10805    echo "$as_me: failed program was:" >&5
10806   sed 's/^/| /' conftest.$ac_ext >&5
10807  
10808   fi
10809   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10810 < done
10810 >    ac_ext=cc
10811 > ac_cpp='$CXXCPP $CPPFLAGS'
10812 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10813 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10814 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10815  
10816 +
10817   fi
10818 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
10819 < echo "${ECHO_T}$ac_cv_c_inline" >&6
10818 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
10819 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
10820 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
10821  
10822 + cat >>confdefs.h <<\_ACEOF
10823 + #define HAVE_FSTREAM_OPEN 1
10824 + _ACEOF
10825  
10826 < case $ac_cv_c_inline in
10827 <  inline | yes) ;;
10828 <  *)
10829 <    case $ac_cv_c_inline in
10830 <      no) ac_val=;;
7862 <      *) ac_val=$ac_cv_c_inline;;
7863 <    esac
7864 <    cat >>confdefs.h <<_ACEOF
7865 < #ifndef __cplusplus
7866 < #define inline $ac_val
7867 < #endif
10826 >  fi
10827 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
10828 >
10829 > cat >>confdefs.h <<\_ACEOF
10830 > #define FSTREAM_OPEN_PROT 1
10831   _ACEOF
7869    ;;
7870 esac
10832  
10833 +  fi
10834  
10835  
7874  # clean out junk possibly left behind by a previous configuration
7875  rm -f src/getopt.h
7876  # Check for getopt_long support
10836  
10837 < for ac_header in getopt.h
10837 >
10838 >
10839 >
10840 >
10841 > for ac_header in ctype.h iostream fstream sstream strstream
10842   do
10843   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10844   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7908 | Line 10871 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10871    cat conftest.err >&5
10872    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10873    (exit $ac_status); } &&
10874 <         { ac_try='test -z "$ac_c_werror_flag"
10874 >         { ac_try='test -z "$ac_cxx_werror_flag"
10875                           || test ! -s conftest.err'
10876    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10877    (eval $ac_try) 2>&5
# Line 7952 | Line 10915 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10915    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10916    (exit $ac_status); } >/dev/null; then
10917    if test -s conftest.err; then
10918 <    ac_cpp_err=$ac_c_preproc_warn_flag
10919 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10918 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10919 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10920    else
10921      ac_cpp_err=
10922    fi
# Line 7973 | Line 10936 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
10936   echo "${ECHO_T}$ac_header_preproc" >&6
10937  
10938   # So?  What about this header?
10939 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10939 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10940    yes:no: )
10941      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10942   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 8024 | Line 10987 | done
10987  
10988   done
10989  
10990 + # AC_CPP_FUNC
10991 + # ------------------ #
10992 + # Checks to see if ANSI C99 CPP variable __func__ works.
10993 + # If not, perhaps __FUNCTION__ works instead.
10994 + # If not, we'll just define __func__ to "".
10995 + # AC_CPP_FUNC
10996  
10997 < for ac_func in getopt_long
10998 < do
10999 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11000 < echo "$as_me:$LINENO: checking for $ac_func" >&5
8032 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8033 < if eval "test \"\${$as_ac_var+set}\" = set"; then
10997 >
10998 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
10999 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11000 > if test "${ac_cv_cpp_func+set}" = set; then
11001    echo $ECHO_N "(cached) $ECHO_C" >&6
11002   else
11003    cat >conftest.$ac_ext <<_ACEOF
# Line 8039 | Line 11006 | cat >>conftest.$ac_ext <<_ACEOF
11006   cat confdefs.h >>conftest.$ac_ext
11007   cat >>conftest.$ac_ext <<_ACEOF
11008   /* end confdefs.h.  */
8042 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8043   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8044 #define $ac_func innocuous_$ac_func
11009  
11010 < /* System header to define __stub macros and hopefully few prototypes,
11011 <    which can conflict with char $ac_func (); below.
11012 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11013 <    <limits.h> exists even on freestanding compilers.  */
11014 <
11015 < #ifdef __STDC__
8052 < # include <limits.h>
8053 < #else
8054 < # include <assert.h>
11010 > #ifdef FC_DUMMY_MAIN
11011 > #ifndef FC_DUMMY_MAIN_EQ_F77
11012 > #  ifdef __cplusplus
11013 >     extern "C"
11014 > #  endif
11015 >   int FC_DUMMY_MAIN() { return 1; }
11016   #endif
8056
8057 #undef $ac_func
8058
8059 /* Override any gcc2 internal prototype to avoid an error.  */
8060 #ifdef __cplusplus
8061 extern "C"
8062 {
11017   #endif
8064 /* We use char because int might match the return type of a gcc2
8065   builtin and then its argument prototype would still apply.  */
8066 char $ac_func ();
8067 /* The GNU C library defines this for functions which it implements
8068    to always fail with ENOSYS.  Some functions are actually named
8069    something starting with __ and the normal name is an alias.  */
8070 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8071 choke me
8072 #else
8073 char (*f) () = $ac_func;
8074 #endif
8075 #ifdef __cplusplus
8076 }
8077 #endif
8078
11018   int
11019   main ()
11020   {
11021 < return f != $ac_func;
11021 > const char *foo = __func__;
11022    ;
11023    return 0;
11024   }
11025   _ACEOF
11026 < rm -f conftest.$ac_objext conftest$ac_exeext
11027 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11028 <  (eval $ac_link) 2>conftest.er1
11026 > rm -f conftest.$ac_objext
11027 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11028 >  (eval $ac_compile) 2>conftest.er1
11029    ac_status=$?
11030    grep -v '^ *+' conftest.er1 >conftest.err
11031    rm -f conftest.er1
11032    cat conftest.err >&5
11033    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11034    (exit $ac_status); } &&
11035 <         { ac_try='test -z "$ac_c_werror_flag"
11035 >         { ac_try='test -z "$ac_cxx_werror_flag"
11036                           || test ! -s conftest.err'
11037    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11038    (eval $ac_try) 2>&5
11039    ac_status=$?
11040    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11041    (exit $ac_status); }; } &&
11042 <         { ac_try='test -s conftest$ac_exeext'
11042 >         { ac_try='test -s conftest.$ac_objext'
11043    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11044    (eval $ac_try) 2>&5
11045    ac_status=$?
11046    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11047    (exit $ac_status); }; }; then
11048 <  eval "$as_ac_var=yes"
11048 >  ac_cv_cpp_func=yes
11049   else
11050    echo "$as_me: failed program was:" >&5
11051   sed 's/^/| /' conftest.$ac_ext >&5
11052  
8114 eval "$as_ac_var=no"
8115 fi
8116 rm -f conftest.err conftest.$ac_objext \
8117      conftest$ac_exeext conftest.$ac_ext
8118 fi
8119 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8120 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8121 if test `eval echo '${'$as_ac_var'}'` = yes; then
8122  cat >>confdefs.h <<_ACEOF
8123 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8124 _ACEOF
8125
8126 else
8127  # FreeBSD has a gnugetopt library for this
8128    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
8129 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
8130 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
8131  echo $ECHO_N "(cached) $ECHO_C" >&6
8132 else
8133  ac_check_lib_save_LIBS=$LIBS
8134 LIBS="-lgnugetopt  $LIBS"
11053   cat >conftest.$ac_ext <<_ACEOF
11054   /* confdefs.h.  */
11055   _ACEOF
# Line 8139 | Line 11057 | cat >>conftest.$ac_ext <<_ACEOF
11057   cat >>conftest.$ac_ext <<_ACEOF
11058   /* end confdefs.h.  */
11059  
11060 < /* Override any gcc2 internal prototype to avoid an error.  */
11061 < #ifdef __cplusplus
11062 < extern "C"
11060 > #ifdef FC_DUMMY_MAIN
11061 > #ifndef FC_DUMMY_MAIN_EQ_F77
11062 > #  ifdef __cplusplus
11063 >     extern "C"
11064 > #  endif
11065 >   int FC_DUMMY_MAIN() { return 1; }
11066   #endif
11067 < /* We use char because int might match the return type of a gcc2
8147 <   builtin and then its argument prototype would still apply.  */
8148 < char getopt_long ();
11067 > #endif
11068   int
11069   main ()
11070   {
11071 < getopt_long ();
11071 > const char *foo = __FUNCTION__;
11072    ;
11073    return 0;
11074   }
11075   _ACEOF
11076 < rm -f conftest.$ac_objext conftest$ac_exeext
11077 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11078 <  (eval $ac_link) 2>conftest.er1
11076 > rm -f conftest.$ac_objext
11077 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11078 >  (eval $ac_compile) 2>conftest.er1
11079    ac_status=$?
11080    grep -v '^ *+' conftest.er1 >conftest.err
11081    rm -f conftest.er1
11082    cat conftest.err >&5
11083    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11084    (exit $ac_status); } &&
11085 <         { ac_try='test -z "$ac_c_werror_flag"
11085 >         { ac_try='test -z "$ac_cxx_werror_flag"
11086                           || test ! -s conftest.err'
11087    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11088    (eval $ac_try) 2>&5
11089    ac_status=$?
11090    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11091    (exit $ac_status); }; } &&
11092 <         { ac_try='test -s conftest$ac_exeext'
11092 >         { ac_try='test -s conftest.$ac_objext'
11093    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11094    (eval $ac_try) 2>&5
11095    ac_status=$?
11096    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11097    (exit $ac_status); }; }; then
11098 <  ac_cv_lib_gnugetopt_getopt_long=yes
11098 >  ac_cv_cpp_func=__FUNCTION__
11099   else
11100    echo "$as_me: failed program was:" >&5
11101   sed 's/^/| /' conftest.$ac_ext >&5
11102  
11103 < ac_cv_lib_gnugetopt_getopt_long=no
11103 > ac_cv_cpp_func=no
11104   fi
11105 < rm -f conftest.err conftest.$ac_objext \
8187 <      conftest$ac_exeext conftest.$ac_ext
8188 < LIBS=$ac_check_lib_save_LIBS
11105 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11106   fi
11107 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11108 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11109 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11110 <  cat >>confdefs.h <<\_ACEOF
11111 < #define HAVE_GETOPT_LONG 1
11107 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11108 > fi
11109 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11110 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11111 > if test $ac_cv_cpp_func = __FUNCTION__; then
11112 >
11113 > cat >>confdefs.h <<\_ACEOF
11114 > #define __func__ __FUNCTION__
11115   _ACEOF
11116  
11117 < else
8198 <  # use the GNU replacement
8199 <      case $LIBOBJS in
8200 <    "getopt.$ac_objext"   | \
8201 <  *" getopt.$ac_objext"   | \
8202 <    "getopt.$ac_objext "* | \
8203 <  *" getopt.$ac_objext "* ) ;;
8204 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
8205 < esac
11117 > elif test $ac_cv_cpp_func = no; then
11118  
11119 <      case $LIBOBJS in
11120 <    "getopt1.$ac_objext"   | \
11121 <  *" getopt1.$ac_objext"   | \
8210 <    "getopt1.$ac_objext "* | \
8211 <  *" getopt1.$ac_objext "* ) ;;
8212 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
8213 < esac
11119 > cat >>confdefs.h <<\_ACEOF
11120 > #define __func__ ""
11121 > _ACEOF
11122  
8215                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
8216
11123   fi
11124  
8219 fi
8220 done
11125  
11126  
11127  
11128 +
11129   case $debug in
11130    1)
11131       ;;
# Line 8229 | Line 11134 | case $debug in
11134  
11135  
11136  
11137 + # Try to determine "good" native compiler flags if none specified on command
11138 + # line
11139  
11140 + if test "$ac_test_FCFLAGS" != "set"; then
11141 +  FCFLAGS=""
11142 +  case "${host_cpu}-${host_os}" in
11143  
11144 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11145 +                    FCFLAGS="-O"
11146 +                fi;;
11147 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11148 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11149 +                fi;;
11150 +   powerpc*-aix*)
11151 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11152 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11153 +                echo "*******************************************************"
11154 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11155 +                echo "*  recommended that you use                           *"
11156 +                echo "*                                                     *"
11157 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11158 +                echo "*                                 ^^^                 *"
11159 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11160 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11161 +                echo "*******************************************************"
11162 +        fi;;
11163 +   *darwin*)
11164 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11165 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11166 +        fi;;
11167 +  esac
11168 +
11169 +  if test -n "$CPU_FLAGS"; then
11170 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11171 +  fi
11172 +
11173 +  if test -z "$FCFLAGS"; then
11174 +        echo ""
11175 +        echo "*********************************************************"
11176 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11177 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11178 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11179 +        echo "*********************************************************"
11180 +        echo ""
11181 +        FCFLAGS="-O3"
11182 +  fi
11183 +
11184 +
11185 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11186 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11187 + if test "${ac_guessed_f90flags+set}" = set; then
11188 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11189 + else
11190 +
11191 +
11192 +
11193 + ac_ext=${FC_SRCEXT-f}
11194 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11195 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11196 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11197 +
11198 + echo 'program main' > conftest.$ac_ext
11199 + echo 'end program main' >> conftest.$ac_ext
11200 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11201 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11202 +  (eval $ac_compile) 2>&5
11203 +  ac_status=$?
11204 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11205 +  (exit $ac_status); }; then
11206 +        ac_guessed_f90flags=yes
11207 + else
11208 +        ac_guessed_f90flags=no
11209 + fi
11210 + rm -f conftest*
11211 + ac_ext=cc
11212 + ac_cpp='$CXXCPP $CPPFLAGS'
11213 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11214 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11215 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11216 +
11217 +
11218 + fi
11219 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
11220 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
11221 + if test "$ac_guessed_f90flags" = yes; then
11222 +        :
11223 +
11224 + else
11225 +        :
11226 +
11227 +        echo ""
11228 +        echo "**********************************************************"
11229 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
11230 +        echo "* your compiler.                                        *"
11231 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11232 +        echo "*********************************************************"
11233 +        echo ""
11234 +        FCFLAGS=""
11235 +
11236 + fi
11237 +
11238 +
11239 + fi
11240 +
11241 +
11242 +
11243 +
11244 +
11245 +
11246 +
11247   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
11248   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
11249   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 8322 | Line 11335 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11335      # -malign-double for x86 systems
11336  
11337  
11338 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
11339 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
11338 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
11339 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
11340   if test "${ac_align_double+set}" = set; then
11341    echo $ECHO_N "(cached) $ECHO_C" >&6
11342   else
11343    echo 'void f(){}' > conftest.c
11344 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
11344 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
11345          ac_align_double=yes
11346   else
11347          ac_align_double=no
# Line 8349 | Line 11362 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11362      # -fstrict-aliasing for gcc-2.95+
11363  
11364  
11365 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
11366 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
11365 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
11366 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
11367   if test "${ac_fstrict_aliasing+set}" = set; then
11368    echo $ECHO_N "(cached) $ECHO_C" >&6
11369   else
11370    echo 'void f(){}' > conftest.c
11371 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
11371 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
11372          ac_fstrict_aliasing=yes
11373   else
11374          ac_fstrict_aliasing=no
# Line 8380 | Line 11393 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11393                    case "${host_cpu}" in
11394            i586*)
11395  
11396 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
11397 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
11396 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
11397 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
11398   if test "${ac_cpu_pentium+set}" = set; then
11399    echo $ECHO_N "(cached) $ECHO_C" >&6
11400   else
11401    echo 'void f(){}' > conftest.c
11402 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
11402 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
11403          ac_cpu_pentium=yes
11404   else
11405          ac_cpu_pentium=no
# Line 8403 | Line 11416 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11416          :
11417  
11418  
11419 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
11420 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
11419 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
11420 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
11421   if test "${ac_pentium+set}" = set; then
11422    echo $ECHO_N "(cached) $ECHO_C" >&6
11423   else
11424    echo 'void f(){}' > conftest.c
11425 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
11425 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
11426          ac_pentium=yes
11427   else
11428          ac_pentium=no
# Line 8432 | Line 11445 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11445                    ;;
11446            i686*)
11447  
11448 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
11449 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
11448 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
11449 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
11450   if test "${ac_cpu_pentiumpro+set}" = set; then
11451    echo $ECHO_N "(cached) $ECHO_C" >&6
11452   else
11453    echo 'void f(){}' > conftest.c
11454 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
11454 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
11455          ac_cpu_pentiumpro=yes
11456   else
11457          ac_cpu_pentiumpro=no
# Line 8455 | Line 11468 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11468          :
11469  
11470  
11471 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
11472 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
11471 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
11472 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
11473   if test "${ac_pentiumpro+set}" = set; then
11474    echo $ECHO_N "(cached) $ECHO_C" >&6
11475   else
11476    echo 'void f(){}' > conftest.c
11477 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
11477 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
11478          ac_pentiumpro=yes
11479   else
11480          ac_pentiumpro=no
# Line 8488 | Line 11501 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11501                  if test -n "$is60x"; then
11502  
11503  
11504 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
11505 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
11504 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
11505 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
11506   if test "${ac_m_cpu_60x+set}" = set; then
11507    echo $ECHO_N "(cached) $ECHO_C" >&6
11508   else
11509    echo 'void f(){}' > conftest.c
11510 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
11510 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
11511          ac_m_cpu_60x=yes
11512   else
11513          ac_m_cpu_60x=no
# Line 8546 | Line 11559 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11559          :
11560  
11561  
11562 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
11563 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
11562 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
11563 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
11564   if test "${ac_m_cpu_750+set}" = set; then
11565    echo $ECHO_N "(cached) $ECHO_C" >&6
11566   else
11567    echo 'void f(){}' > conftest.c
11568 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
11568 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
11569          ac_m_cpu_750=yes
11570   else
11571          ac_m_cpu_750=no
# Line 8579 | Line 11592 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11592                  if test -z "$CPU_FLAGS"; then
11593  
11594  
11595 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
11596 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
11595 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
11596 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
11597   if test "${ac_m_cpu_powerpc+set}" = set; then
11598    echo $ECHO_N "(cached) $ECHO_C" >&6
11599   else
11600    echo 'void f(){}' > conftest.c
11601 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
11601 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
11602          ac_m_cpu_powerpc=yes
11603   else
11604          ac_m_cpu_powerpc=no
# Line 8607 | Line 11620 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11620                  if test -z "$CPU_FLAGS"; then
11621  
11622  
11623 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
11624 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
11623 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
11624 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
11625   if test "${ac_m_powerpc+set}" = set; then
11626    echo $ECHO_N "(cached) $ECHO_C" >&6
11627   else
11628    echo 'void f(){}' > conftest.c
11629 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
11629 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
11630          ac_m_powerpc=yes
11631   else
11632          ac_m_powerpc=no
# Line 8652 | Line 11665 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11665  
11666  
11667  
11668 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
11669 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
11668 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
11669 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
11670   if test "${ac_guessed_cflags+set}" = set; then
11671    echo $ECHO_N "(cached) $ECHO_C" >&6
11672   else
11673    echo 'void f(){}' > conftest.c
11674 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
11674 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
11675          ac_guessed_cflags=yes
11676   else
11677          ac_guessed_cflags=no
# Line 8776 | Line 11789 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11789      # -malign-double for x86 systems
11790  
11791  
11792 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
11793 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
11792 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
11793 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
11794   if test "${ac_align_double+set}" = set; then
11795    echo $ECHO_N "(cached) $ECHO_C" >&6
11796   else
11797    echo 'void f(){}' > conftest.cpp
11798 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
11798 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
11799          ac_align_double=yes
11800   else
11801          ac_align_double=no
# Line 8803 | Line 11816 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11816      # -fstrict-aliasing for gcc-2.95+
11817  
11818  
11819 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
11820 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
11819 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
11820 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
11821   if test "${ac_fstrict_aliasing+set}" = set; then
11822    echo $ECHO_N "(cached) $ECHO_C" >&6
11823   else
11824    echo 'void f(){}' > conftest.cpp
11825 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
11825 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
11826          ac_fstrict_aliasing=yes
11827   else
11828          ac_fstrict_aliasing=no
# Line 8834 | Line 11847 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11847                    case "${host_cpu}" in
11848            i586*)
11849  
11850 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
11851 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
11850 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
11851 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
11852   if test "${ac_cpu_pentium+set}" = set; then
11853    echo $ECHO_N "(cached) $ECHO_C" >&6
11854   else
11855    echo 'void f(){}' > conftest.cpp
11856 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
11856 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
11857          ac_cpu_pentium=yes
11858   else
11859          ac_cpu_pentium=no
# Line 8857 | Line 11870 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11870          :
11871  
11872  
11873 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
11874 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
11873 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
11874 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
11875   if test "${ac_pentium+set}" = set; then
11876    echo $ECHO_N "(cached) $ECHO_C" >&6
11877   else
11878    echo 'void f(){}' > conftest.cpp
11879 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
11879 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
11880          ac_pentium=yes
11881   else
11882          ac_pentium=no
# Line 8886 | Line 11899 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11899                    ;;
11900            i686*)
11901  
11902 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
11903 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
11902 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
11903 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
11904   if test "${ac_cpu_pentiumpro+set}" = set; then
11905    echo $ECHO_N "(cached) $ECHO_C" >&6
11906   else
11907    echo 'void f(){}' > conftest.cpp
11908 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
11908 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
11909          ac_cpu_pentiumpro=yes
11910   else
11911          ac_cpu_pentiumpro=no
# Line 8909 | Line 11922 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11922          :
11923  
11924  
11925 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
11926 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
11925 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
11926 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
11927   if test "${ac_pentiumpro+set}" = set; then
11928    echo $ECHO_N "(cached) $ECHO_C" >&6
11929   else
11930    echo 'void f(){}' > conftest.cpp
11931 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
11931 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
11932          ac_pentiumpro=yes
11933   else
11934          ac_pentiumpro=no
# Line 8942 | Line 11955 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11955                  if test -n "$is60x"; then
11956  
11957  
11958 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
11959 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
11958 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
11959 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
11960   if test "${ac_m_cpu_60x+set}" = set; then
11961    echo $ECHO_N "(cached) $ECHO_C" >&6
11962   else
11963    echo 'void f(){}' > conftest.cpp
11964 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
11964 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
11965          ac_m_cpu_60x=yes
8953 else
8954        ac_m_cpu_60x=no
8955 fi
8956 rm -f conftest*
8957
8958 fi
8959 echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
8960 echo "${ECHO_T}$ac_m_cpu_60x" >&6
8961 if test "$ac_m_cpu_60x" = yes; then
8962        :
8963        CPU_FLAGS=-mcpu=$cputype
8964 else
8965        :
8966
8967 fi
8968
8969                elif test "$cputype" = 750; then
8970
8971
8972 echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
8973 echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
8974 if test "${ac_cv_prog_gxx_2_95+set}" = set; then
8975  echo $ECHO_N "(cached) $ECHO_C" >&6
8976 else
8977
8978 cat > conftest.cpp <<EOF
8979 #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8980 #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8981     yes;
8982 #  endif
8983 #endif
8984 EOF
8985 if { ac_try='${CXX-c++} -E conftest.cpp'
8986  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8987  (eval $ac_try) 2>&5
8988  ac_status=$?
8989  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8990  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8991  ac_cv_prog_gxx_2_95=yes
8992 else
8993  ac_cv_prog_gxx_2_95=no
8994 fi
8995
8996 fi
8997 echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8998 echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8999 if test "$ac_cv_prog_gxx_2_95" = yes; then
9000        :
9001
9002
9003 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
9004 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
9005 if test "${ac_m_cpu_750+set}" = set; then
9006  echo $ECHO_N "(cached) $ECHO_C" >&6
9007 else
9008  echo 'void f(){}' > conftest.cpp
9009 if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
9010        ac_m_cpu_750=yes
9011 else
9012        ac_m_cpu_750=no
9013 fi
9014 rm -f conftest*
9015
9016 fi
9017 echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
9018 echo "${ECHO_T}$ac_m_cpu_750" >&6
9019 if test "$ac_m_cpu_750" = yes; then
9020        :
9021        CPU_FLAGS=-mcpu=750
9022 else
9023        :
9024
9025 fi
9026
9027 else
9028        :
9029
9030 fi
9031
9032                fi
9033                if test -z "$CPU_FLAGS"; then
9034
9035
9036 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
9037 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
9038 if test "${ac_m_cpu_powerpc+set}" = set; then
9039  echo $ECHO_N "(cached) $ECHO_C" >&6
9040 else
9041  echo 'void f(){}' > conftest.cpp
9042 if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
9043        ac_m_cpu_powerpc=yes
9044 else
9045        ac_m_cpu_powerpc=no
9046 fi
9047 rm -f conftest*
9048
9049 fi
9050 echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
9051 echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
9052 if test "$ac_m_cpu_powerpc" = yes; then
9053        :
9054        CPU_FLAGS=-mcpu=powerpc
9055 else
9056        :
9057
9058 fi
9059
9060                fi
9061                if test -z "$CPU_FLAGS"; then
9062
9063
9064 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
9065 echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
9066 if test "${ac_m_powerpc+set}" = set; then
9067  echo $ECHO_N "(cached) $ECHO_C" >&6
9068 else
9069  echo 'void f(){}' > conftest.cpp
9070 if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
9071        ac_m_powerpc=yes
9072 else
9073        ac_m_powerpc=no
9074 fi
9075 rm -f conftest*
9076
9077 fi
9078 echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
9079 echo "${ECHO_T}$ac_m_powerpc" >&6
9080 if test "$ac_m_powerpc" = yes; then
9081        :
9082        CPU_FLAGS=-mpowerpc
9083 else
9084        :
9085
9086 fi
9087
9088                fi
9089          esac
9090  fi
9091
9092  if test -n "$CPU_FLAGS"; then
9093        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
9094  fi
9095
9096  if test -z "$CXXFLAGS"; then
9097        echo ""
9098        echo "**********************************************************"
9099        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
9100        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9101        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
9102        echo "**********************************************************"
9103        echo ""
9104        CXXFLAGS="-O3"
9105  fi
9106
9107
9108
9109 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
9110 echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
9111 if test "${ac_guessed_cxxflags+set}" = set; then
9112  echo $ECHO_N "(cached) $ECHO_C" >&6
9113 else
9114  echo 'void f(){}' > conftest.cpp
9115 if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
9116        ac_guessed_cxxflags=yes
9117 else
9118        ac_guessed_cxxflags=no
9119 fi
9120 rm -f conftest*
9121
9122 fi
9123 echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
9124 echo "${ECHO_T}$ac_guessed_cxxflags" >&6
9125 if test "$ac_guessed_cxxflags" = yes; then
9126        :
9127
9128 else
9129        :
9130
9131        echo ""
9132        echo "**********************************************************"
9133        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
9134        echo "* your compiler.                                         *"
9135        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9136        echo "**********************************************************"
9137        echo ""
9138        CXXFLAGS=""
9139
9140 fi
9141
9142
9143 fi
9144
9145
9146
9147
9148
9149 # Try to determine "good" native compiler flags if none specified on command
9150 # line
9151
9152 if test x"$F90FLAGS" = x ; then
9153  F90FLAGS=""
9154  case "${host_cpu}-${host_os}" in
9155
9156  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
9157                    F90FLAGS="-O"
9158                fi;;
9159   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
9160                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
9161                fi;;
9162   powerpc*-aix*)
9163        if test "$F90" = f90 -o "$F90" = xlf90; then
9164                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
9165                echo "*******************************************************"
9166                echo "*  You have AIX on an unknown powerpc system.  It is  *"
9167                echo "*  recommended that you use                           *"
9168                echo "*                                                     *"
9169                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
9170                echo "*                                 ^^^                 *"
9171                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
9172                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
9173                echo "*******************************************************"
9174        fi;;
9175   *darwin*)
9176        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
9177                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
9178        fi;;
9179  esac
9180
9181  if test -n "$CPU_FLAGS"; then
9182        F90FLAGS="$F90FLAGS $CPU_FLAGS"
9183  fi
9184
9185  if test -z "$F90FLAGS"; then
9186        echo ""
9187        echo "**********************************************************"
9188        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
9189        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9190        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
9191        echo "**********************************************************"
9192        echo ""
9193        F90FLAGS="-O3"
9194  fi
9195
9196
9197 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
9198 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
9199 if test "${ac_guessed_f90flags+set}" = set; then
9200  echo $ECHO_N "(cached) $ECHO_C" >&6
9201 else
9202
9203
9204
9205 ac_ext=f90
9206 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
9207 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9208 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
9209
9210 echo 'program main' > conftest.$ac_ext
9211 echo 'end program main' >> conftest.$ac_ext
9212 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
9213 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9214  (eval $ac_compile) 2>&5
9215  ac_status=$?
9216  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9217  (exit $ac_status); }; then
9218        ac_guessed_f90flags=yes
9219 else
9220        ac_guessed_f90flags=no
9221 fi
9222 rm -f conftest*
9223 ac_ext=c
9224 ac_cpp='$CPP $CPPFLAGS'
9225 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9226 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9227 ac_compiler_gnu=$ac_cv_c_compiler_gnu
9228
9229
9230 fi
9231 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
9232 echo "${ECHO_T}$ac_guessed_f90flags" >&6
9233 if test "$ac_guessed_f90flags" = yes; then
9234        :
9235
9236 else
9237        :
9238
9239        echo ""
9240        echo "**********************************************************"
9241        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
9242        echo "* your compiler.                                         *"
9243        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9244        echo "**********************************************************"
9245        echo ""
9246        F90FLAGS=""
9247
9248 fi
9249
9250
9251 fi
9252
9253     ;;
9254 esac
9255
9256 ac_ext=cc
9257 ac_cpp='$CXXCPP $CPPFLAGS'
9258 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9259 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9260 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9261
9262 # AC_CPP_FUNC
9263 # ------------------ #
9264 # Checks to see if ANSI C99 CPP variable __func__ works.
9265 # If not, perhaps __FUNCTION__ works instead.
9266 # If not, we'll just define __func__ to "".
9267 # AC_CPP_FUNC
9268
9269
9270 echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
9271 echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
9272 if test "${ac_cv_cpp_func+set}" = set; then
9273  echo $ECHO_N "(cached) $ECHO_C" >&6
9274 else
9275  cat >conftest.$ac_ext <<_ACEOF
9276 /* confdefs.h.  */
9277 _ACEOF
9278 cat confdefs.h >>conftest.$ac_ext
9279 cat >>conftest.$ac_ext <<_ACEOF
9280 /* end confdefs.h.  */
9281
9282 int
9283 main ()
9284 {
9285 const char *foo = __func__;
9286  ;
9287  return 0;
9288 }
9289 _ACEOF
9290 rm -f conftest.$ac_objext
9291 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9292  (eval $ac_compile) 2>conftest.er1
9293  ac_status=$?
9294  grep -v '^ *+' conftest.er1 >conftest.err
9295  rm -f conftest.er1
9296  cat conftest.err >&5
9297  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9298  (exit $ac_status); } &&
9299         { ac_try='test -z "$ac_cxx_werror_flag"
9300                         || test ! -s conftest.err'
9301  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9302  (eval $ac_try) 2>&5
9303  ac_status=$?
9304  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9305  (exit $ac_status); }; } &&
9306         { ac_try='test -s conftest.$ac_objext'
9307  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9308  (eval $ac_try) 2>&5
9309  ac_status=$?
9310  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9311  (exit $ac_status); }; }; then
9312  ac_cv_cpp_func=yes
9313 else
9314  echo "$as_me: failed program was:" >&5
9315 sed 's/^/| /' conftest.$ac_ext >&5
9316
9317 cat >conftest.$ac_ext <<_ACEOF
9318 /* confdefs.h.  */
9319 _ACEOF
9320 cat confdefs.h >>conftest.$ac_ext
9321 cat >>conftest.$ac_ext <<_ACEOF
9322 /* end confdefs.h.  */
9323
9324 int
9325 main ()
9326 {
9327 const char *foo = __FUNCTION__;
9328  ;
9329  return 0;
9330 }
9331 _ACEOF
9332 rm -f conftest.$ac_objext
9333 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9334  (eval $ac_compile) 2>conftest.er1
9335  ac_status=$?
9336  grep -v '^ *+' conftest.er1 >conftest.err
9337  rm -f conftest.er1
9338  cat conftest.err >&5
9339  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9340  (exit $ac_status); } &&
9341         { ac_try='test -z "$ac_cxx_werror_flag"
9342                         || test ! -s conftest.err'
9343  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9344  (eval $ac_try) 2>&5
9345  ac_status=$?
9346  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9347  (exit $ac_status); }; } &&
9348         { ac_try='test -s conftest.$ac_objext'
9349  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9350  (eval $ac_try) 2>&5
9351  ac_status=$?
9352  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9353  (exit $ac_status); }; }; then
9354  ac_cv_cpp_func=__FUNCTION__
9355 else
9356  echo "$as_me: failed program was:" >&5
9357 sed 's/^/| /' conftest.$ac_ext >&5
9358
9359 ac_cv_cpp_func=no
9360 fi
9361 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9362 fi
9363 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9364 fi
9365 echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
9366 echo "${ECHO_T}$ac_cv_cpp_func" >&6
9367 if test $ac_cv_cpp_func = __FUNCTION__; then
9368
9369 cat >>confdefs.h <<\_ACEOF
9370 #define __func__ __FUNCTION__
9371 _ACEOF
9372
9373 elif test $ac_cv_cpp_func = no; then
9374
9375 cat >>confdefs.h <<\_ACEOF
9376 #define __func__ ""
9377 _ACEOF
9378
9379 fi
9380
9381
9382 ac_ext=c
9383 ac_cpp='$CPP $CPPFLAGS'
9384 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9385 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9386 ac_compiler_gnu=$ac_cv_c_compiler_gnu
9387
9388
9389 # Find a good install program.  We prefer a C program (faster),
9390 # so one script is as good as another.  But avoid the broken or
9391 # incompatible versions:
9392 # SysV /etc/install, /usr/sbin/install
9393 # SunOS /usr/etc/install
9394 # IRIX /sbin/install
9395 # AIX /bin/install
9396 # AmigaOS /C/install, which installs bootblocks on floppy discs
9397 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
9398 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
9399 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
9400 # OS/2's system install, which has a completely different semantic
9401 # ./install, which can be erroneously created by make from ./install.sh.
9402 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
9403 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
9404 if test -z "$INSTALL"; then
9405 if test "${ac_cv_path_install+set}" = set; then
9406  echo $ECHO_N "(cached) $ECHO_C" >&6
9407 else
9408  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9409 for as_dir in $PATH
9410 do
9411  IFS=$as_save_IFS
9412  test -z "$as_dir" && as_dir=.
9413  # Account for people who put trailing slashes in PATH elements.
9414 case $as_dir/ in
9415  ./ | .// | /cC/* | \
9416  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
9417  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
9418  /usr/ucb/* ) ;;
9419  *)
9420    # OSF1 and SCO ODT 3.0 have their own names for install.
9421    # Don't use installbsd from OSF since it installs stuff as root
9422    # by default.
9423    for ac_prog in ginstall scoinst install; do
9424      for ac_exec_ext in '' $ac_executable_extensions; do
9425        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
9426          if test $ac_prog = install &&
9427            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9428            # AIX install.  It has an incompatible calling convention.
9429            :
9430          elif test $ac_prog = install &&
9431            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9432            # program-specific install script used by HP pwplus--don't use.
9433            :
9434          else
9435            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
9436            break 3
9437          fi
9438        fi
9439      done
9440    done
9441    ;;
9442 esac
9443 done
9444
9445
9446 fi
9447  if test "${ac_cv_path_install+set}" = set; then
9448    INSTALL=$ac_cv_path_install
9449  else
9450    # As a last resort, use the slow shell script.  We don't cache a
9451    # path for INSTALL within a source directory, because that will
9452    # break other packages using the cache if that directory is
9453    # removed, or if the path is relative.
9454    INSTALL=$ac_install_sh
9455  fi
9456 fi
9457 echo "$as_me:$LINENO: result: $INSTALL" >&5
9458 echo "${ECHO_T}$INSTALL" >&6
9459
9460 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
9461 # It thinks the first close brace ends the variable substitution.
9462 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
9463
9464 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
9465
9466 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
9467
9468 echo "$as_me:$LINENO: checking whether ln -s works" >&5
9469 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
9470 LN_S=$as_ln_s
9471 if test "$LN_S" = "ln -s"; then
9472  echo "$as_me:$LINENO: result: yes" >&5
9473 echo "${ECHO_T}yes" >&6
11966   else
11967 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
9476 < echo "${ECHO_T}no, using $LN_S" >&6
11967 >        ac_m_cpu_60x=no
11968   fi
11969 + rm -f conftest*
11970  
9479 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
9480 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
9481 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
9482 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
9483  echo $ECHO_N "(cached) $ECHO_C" >&6
9484 else
9485  cat >conftest.make <<\_ACEOF
9486 all:
9487        @echo 'ac_maketemp="$(MAKE)"'
9488 _ACEOF
9489 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
9490 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
9491 if test -n "$ac_maketemp"; then
9492  eval ac_cv_prog_make_${ac_make}_set=yes
9493 else
9494  eval ac_cv_prog_make_${ac_make}_set=no
11971   fi
11972 < rm -f conftest.make
11973 < fi
11974 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
11975 <  echo "$as_me:$LINENO: result: yes" >&5
11976 < echo "${ECHO_T}yes" >&6
9501 <  SET_MAKE=
11972 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
11973 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
11974 > if test "$ac_m_cpu_60x" = yes; then
11975 >        :
11976 >        CPU_FLAGS=-mcpu=$cputype
11977   else
11978 <  echo "$as_me:$LINENO: result: no" >&5
11979 < echo "${ECHO_T}no" >&6
9505 <  SET_MAKE="MAKE=${MAKE-make}"
11978 >        :
11979 >
11980   fi
11981  
11982 < if test -n "$ac_tool_prefix"; then
11983 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
11984 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
11985 < echo "$as_me:$LINENO: checking for $ac_word" >&5
11986 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11987 < if test "${ac_cv_prog_RANLIB+set}" = set; then
11982 >                elif test "$cputype" = 750; then
11983 >
11984 >
11985 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
11986 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
11987 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
11988    echo $ECHO_N "(cached) $ECHO_C" >&6
11989   else
9516  if test -n "$RANLIB"; then
9517  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
9518 else
9519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9520 for as_dir in $PATH
9521 do
9522  IFS=$as_save_IFS
9523  test -z "$as_dir" && as_dir=.
9524  for ac_exec_ext in '' $ac_executable_extensions; do
9525  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9526    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
9527    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9528    break 2
9529  fi
9530 done
9531 done
11990  
11991 < fi
11992 < fi
11993 < RANLIB=$ac_cv_prog_RANLIB
11994 < if test -n "$RANLIB"; then
11995 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
11996 < echo "${ECHO_T}$RANLIB" >&6
11991 > cat > conftest.cpp <<EOF
11992 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
11993 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
11994 >     yes;
11995 > #  endif
11996 > #endif
11997 > EOF
11998 > if { ac_try='${CXX-c++} -E conftest.cpp'
11999 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12000 >  (eval $ac_try) 2>&5
12001 >  ac_status=$?
12002 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12003 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12004 >  ac_cv_prog_gxx_2_95=yes
12005   else
12006 <  echo "$as_me:$LINENO: result: no" >&5
9541 < echo "${ECHO_T}no" >&6
12006 >  ac_cv_prog_gxx_2_95=no
12007   fi
12008  
12009   fi
12010 < if test -z "$ac_cv_prog_RANLIB"; then
12011 <  ac_ct_RANLIB=$RANLIB
12012 <  # Extract the first word of "ranlib", so it can be a program name with args.
12013 < set dummy ranlib; ac_word=$2
12014 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12015 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12016 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
12010 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12011 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12012 > if test "$ac_cv_prog_gxx_2_95" = yes; then
12013 >        :
12014 >
12015 >
12016 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12017 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12018 > if test "${ac_m_cpu_750+set}" = set; then
12019    echo $ECHO_N "(cached) $ECHO_C" >&6
12020   else
12021 <  if test -n "$ac_ct_RANLIB"; then
12022 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
12021 >  echo 'void f(){}' > conftest.cpp
12022 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12023 >        ac_m_cpu_750=yes
12024   else
12025 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12026 < for as_dir in $PATH
12027 < do
9560 <  IFS=$as_save_IFS
9561 <  test -z "$as_dir" && as_dir=.
9562 <  for ac_exec_ext in '' $ac_executable_extensions; do
9563 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9564 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
9565 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9566 <    break 2
9567 <  fi
9568 < done
9569 < done
12025 >        ac_m_cpu_750=no
12026 > fi
12027 > rm -f conftest*
12028  
9571  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
12029   fi
12030 < fi
12031 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
12032 < if test -n "$ac_ct_RANLIB"; then
12033 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
12034 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
12030 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12031 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12032 > if test "$ac_m_cpu_750" = yes; then
12033 >        :
12034 >        CPU_FLAGS=-mcpu=750
12035   else
12036 <  echo "$as_me:$LINENO: result: no" >&5
12037 < echo "${ECHO_T}no" >&6
12036 >        :
12037 >
12038   fi
12039  
9583  RANLIB=$ac_ct_RANLIB
12040   else
12041 <  RANLIB="$ac_cv_prog_RANLIB"
12041 >        :
12042 >
12043   fi
12044  
12045 < for ac_prog in 'bison -y' byacc
12046 < do
12047 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12048 < set dummy $ac_prog; ac_word=$2
12049 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12050 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12051 < if test "${ac_cv_prog_YACC+set}" = set; then
12045 >                fi
12046 >                if test -z "$CPU_FLAGS"; then
12047 >
12048 >
12049 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12050 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12051 > if test "${ac_m_cpu_powerpc+set}" = set; then
12052    echo $ECHO_N "(cached) $ECHO_C" >&6
12053   else
12054 <  if test -n "$YACC"; then
12055 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
12054 >  echo 'void f(){}' > conftest.cpp
12055 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12056 >        ac_m_cpu_powerpc=yes
12057   else
12058 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12059 < for as_dir in $PATH
12060 < do
9603 <  IFS=$as_save_IFS
9604 <  test -z "$as_dir" && as_dir=.
9605 <  for ac_exec_ext in '' $ac_executable_extensions; do
9606 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9607 <    ac_cv_prog_YACC="$ac_prog"
9608 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9609 <    break 2
9610 <  fi
9611 < done
9612 < done
12058 >        ac_m_cpu_powerpc=no
12059 > fi
12060 > rm -f conftest*
12061  
12062   fi
12063 < fi
12064 < YACC=$ac_cv_prog_YACC
12065 < if test -n "$YACC"; then
12066 <  echo "$as_me:$LINENO: result: $YACC" >&5
12067 < echo "${ECHO_T}$YACC" >&6
12063 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12064 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12065 > if test "$ac_m_cpu_powerpc" = yes; then
12066 >        :
12067 >        CPU_FLAGS=-mcpu=powerpc
12068   else
12069 <  echo "$as_me:$LINENO: result: no" >&5
12070 < echo "${ECHO_T}no" >&6
12069 >        :
12070 >
12071   fi
12072  
12073 <  test -n "$YACC" && break
12074 < done
9627 < test -n "$YACC" || YACC="yacc"
12073 >                fi
12074 >                if test -z "$CPU_FLAGS"; then
12075  
12076 < for ac_prog in flex lex
12077 < do
12078 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12079 < set dummy $ac_prog; ac_word=$2
9633 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9634 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9635 < if test "${ac_cv_prog_LEX+set}" = set; then
12076 >
12077 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12078 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12079 > if test "${ac_m_powerpc+set}" = set; then
12080    echo $ECHO_N "(cached) $ECHO_C" >&6
12081   else
12082 <  if test -n "$LEX"; then
12083 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12082 >  echo 'void f(){}' > conftest.cpp
12083 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12084 >        ac_m_powerpc=yes
12085   else
12086 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12087 < for as_dir in $PATH
12088 < do
9644 <  IFS=$as_save_IFS
9645 <  test -z "$as_dir" && as_dir=.
9646 <  for ac_exec_ext in '' $ac_executable_extensions; do
9647 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9648 <    ac_cv_prog_LEX="$ac_prog"
9649 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9650 <    break 2
9651 <  fi
9652 < done
9653 < done
12086 >        ac_m_powerpc=no
12087 > fi
12088 > rm -f conftest*
12089  
12090   fi
12091 < fi
12092 < LEX=$ac_cv_prog_LEX
12093 < if test -n "$LEX"; then
12094 <  echo "$as_me:$LINENO: result: $LEX" >&5
12095 < echo "${ECHO_T}$LEX" >&6
12091 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12092 > echo "${ECHO_T}$ac_m_powerpc" >&6
12093 > if test "$ac_m_powerpc" = yes; then
12094 >        :
12095 >        CPU_FLAGS=-mpowerpc
12096   else
12097 <  echo "$as_me:$LINENO: result: no" >&5
12098 < echo "${ECHO_T}no" >&6
12097 >        :
12098 >
12099   fi
12100  
12101 <  test -n "$LEX" && break
12102 < done
12103 < test -n "$LEX" || LEX=":"
9669 <
9670 < if test -z "$LEXLIB"
9671 < then
9672 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
9673 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
9674 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
9675 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9676 < else
9677 <  ac_check_lib_save_LIBS=$LIBS
9678 < LIBS="-lfl  $LIBS"
9679 < cat >conftest.$ac_ext <<_ACEOF
9680 < /* confdefs.h.  */
9681 < _ACEOF
9682 < cat confdefs.h >>conftest.$ac_ext
9683 < cat >>conftest.$ac_ext <<_ACEOF
9684 < /* end confdefs.h.  */
12101 >                fi
12102 >          esac
12103 >  fi
12104  
12105 < /* Override any gcc2 internal prototype to avoid an error.  */
12106 < #ifdef __cplusplus
12107 < extern "C"
9689 < #endif
9690 < /* We use char because int might match the return type of a gcc2
9691 <   builtin and then its argument prototype would still apply.  */
9692 < char yywrap ();
9693 < int
9694 < main ()
9695 < {
9696 < yywrap ();
9697 <  ;
9698 <  return 0;
9699 < }
9700 < _ACEOF
9701 < rm -f conftest.$ac_objext conftest$ac_exeext
9702 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9703 <  (eval $ac_link) 2>conftest.er1
9704 <  ac_status=$?
9705 <  grep -v '^ *+' conftest.er1 >conftest.err
9706 <  rm -f conftest.er1
9707 <  cat conftest.err >&5
9708 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9709 <  (exit $ac_status); } &&
9710 <         { ac_try='test -z "$ac_c_werror_flag"
9711 <                         || test ! -s conftest.err'
9712 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9713 <  (eval $ac_try) 2>&5
9714 <  ac_status=$?
9715 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9716 <  (exit $ac_status); }; } &&
9717 <         { ac_try='test -s conftest$ac_exeext'
9718 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9719 <  (eval $ac_try) 2>&5
9720 <  ac_status=$?
9721 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9722 <  (exit $ac_status); }; }; then
9723 <  ac_cv_lib_fl_yywrap=yes
9724 < else
9725 <  echo "$as_me: failed program was:" >&5
9726 < sed 's/^/| /' conftest.$ac_ext >&5
12105 >  if test -n "$CPU_FLAGS"; then
12106 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12107 >  fi
12108  
12109 < ac_cv_lib_fl_yywrap=no
12110 < fi
12111 < rm -f conftest.err conftest.$ac_objext \
12112 <      conftest$ac_exeext conftest.$ac_ext
12113 < LIBS=$ac_check_lib_save_LIBS
12114 < fi
12115 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
12116 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
12117 < if test $ac_cv_lib_fl_yywrap = yes; then
12118 <  LEXLIB="-lfl"
9738 < else
9739 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
9740 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
9741 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
9742 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9743 < else
9744 <  ac_check_lib_save_LIBS=$LIBS
9745 < LIBS="-ll  $LIBS"
9746 < cat >conftest.$ac_ext <<_ACEOF
9747 < /* confdefs.h.  */
9748 < _ACEOF
9749 < cat confdefs.h >>conftest.$ac_ext
9750 < cat >>conftest.$ac_ext <<_ACEOF
9751 < /* end confdefs.h.  */
12109 >  if test -z "$CXXFLAGS"; then
12110 >        echo ""
12111 >        echo "**********************************************************"
12112 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12113 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12114 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12115 >        echo "**********************************************************"
12116 >        echo ""
12117 >        CXXFLAGS="-O3"
12118 >  fi
12119  
9753 /* Override any gcc2 internal prototype to avoid an error.  */
9754 #ifdef __cplusplus
9755 extern "C"
9756 #endif
9757 /* We use char because int might match the return type of a gcc2
9758   builtin and then its argument prototype would still apply.  */
9759 char yywrap ();
9760 int
9761 main ()
9762 {
9763 yywrap ();
9764  ;
9765  return 0;
9766 }
9767 _ACEOF
9768 rm -f conftest.$ac_objext conftest$ac_exeext
9769 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9770  (eval $ac_link) 2>conftest.er1
9771  ac_status=$?
9772  grep -v '^ *+' conftest.er1 >conftest.err
9773  rm -f conftest.er1
9774  cat conftest.err >&5
9775  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9776  (exit $ac_status); } &&
9777         { ac_try='test -z "$ac_c_werror_flag"
9778                         || test ! -s conftest.err'
9779  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9780  (eval $ac_try) 2>&5
9781  ac_status=$?
9782  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9783  (exit $ac_status); }; } &&
9784         { ac_try='test -s conftest$ac_exeext'
9785  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9786  (eval $ac_try) 2>&5
9787  ac_status=$?
9788  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9789  (exit $ac_status); }; }; then
9790  ac_cv_lib_l_yywrap=yes
9791 else
9792  echo "$as_me: failed program was:" >&5
9793 sed 's/^/| /' conftest.$ac_ext >&5
12120  
9795 ac_cv_lib_l_yywrap=no
9796 fi
9797 rm -f conftest.err conftest.$ac_objext \
9798      conftest$ac_exeext conftest.$ac_ext
9799 LIBS=$ac_check_lib_save_LIBS
9800 fi
9801 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9802 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9803 if test $ac_cv_lib_l_yywrap = yes; then
9804  LEXLIB="-ll"
9805 fi
12121  
12122 < fi
12123 <
12124 < fi
9810 <
9811 < if test "x$LEX" != "x:"; then
9812 <  echo "$as_me:$LINENO: checking lex output file root" >&5
9813 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9814 < if test "${ac_cv_prog_lex_root+set}" = set; then
12122 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12123 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12124 > if test "${ac_guessed_cxxflags+set}" = set; then
12125    echo $ECHO_N "(cached) $ECHO_C" >&6
12126   else
12127 <  # The minimal lex program is just a single line: %%.  But some broken lexes
12128 < # (Solaris, I think it was) want two %% lines, so accommodate them.
12129 < cat >conftest.l <<_ACEOF
9820 < %%
9821 < %%
9822 < _ACEOF
9823 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9824 <  (eval $LEX conftest.l) 2>&5
9825 <  ac_status=$?
9826 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9827 <  (exit $ac_status); }
9828 < if test -f lex.yy.c; then
9829 <  ac_cv_prog_lex_root=lex.yy
9830 < elif test -f lexyy.c; then
9831 <  ac_cv_prog_lex_root=lexyy
12127 >  echo 'void f(){}' > conftest.cpp
12128 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12129 >        ac_guessed_cxxflags=yes
12130   else
12131 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9834 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9835 <   { (exit 1); exit 1; }; }
12131 >        ac_guessed_cxxflags=no
12132   fi
12133 < fi
9838 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9839 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9840 < rm -f conftest.l
9841 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12133 > rm -f conftest*
12134  
9843 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9844 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9845 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9846  echo $ECHO_N "(cached) $ECHO_C" >&6
9847 else
9848  # POSIX says lex can declare yytext either as a pointer or an array; the
9849 # default is implementation-dependent. Figure out which it is, since
9850 # not all implementations provide the %pointer and %array declarations.
9851 ac_cv_prog_lex_yytext_pointer=no
9852 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9853 ac_save_LIBS=$LIBS
9854 LIBS="$LIBS $LEXLIB"
9855 cat >conftest.$ac_ext <<_ACEOF
9856 `cat $LEX_OUTPUT_ROOT.c`
9857 _ACEOF
9858 rm -f conftest.$ac_objext conftest$ac_exeext
9859 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9860  (eval $ac_link) 2>conftest.er1
9861  ac_status=$?
9862  grep -v '^ *+' conftest.er1 >conftest.err
9863  rm -f conftest.er1
9864  cat conftest.err >&5
9865  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866  (exit $ac_status); } &&
9867         { ac_try='test -z "$ac_c_werror_flag"
9868                         || test ! -s conftest.err'
9869  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9870  (eval $ac_try) 2>&5
9871  ac_status=$?
9872  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9873  (exit $ac_status); }; } &&
9874         { ac_try='test -s conftest$ac_exeext'
9875  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9876  (eval $ac_try) 2>&5
9877  ac_status=$?
9878  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9879  (exit $ac_status); }; }; then
9880  ac_cv_prog_lex_yytext_pointer=yes
9881 else
9882  echo "$as_me: failed program was:" >&5
9883 sed 's/^/| /' conftest.$ac_ext >&5
9884
12135   fi
12136 < rm -f conftest.err conftest.$ac_objext \
12137 <      conftest$ac_exeext conftest.$ac_ext
12138 < LIBS=$ac_save_LIBS
12139 < rm -f "${LEX_OUTPUT_ROOT}.c"
12136 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12137 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12138 > if test "$ac_guessed_cxxflags" = yes; then
12139 >        :
12140  
12141 < fi
12142 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9893 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9894 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
9895 <
9896 < cat >>confdefs.h <<\_ACEOF
9897 < #define YYTEXT_POINTER 1
9898 < _ACEOF
12141 > else
12142 >        :
12143  
12144 < fi
12144 >        echo ""
12145 >        echo "**********************************************************"
12146 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12147 >        echo "* your compiler.                                         *"
12148 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12149 >        echo "**********************************************************"
12150 >        echo ""
12151 >        CXXFLAGS=""
12152  
12153   fi
12154  
9904   # Extract the first word of "perl", so it can be a program name with args.
9905 set dummy perl; ac_word=$2
9906 echo "$as_me:$LINENO: checking for $ac_word" >&5
9907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9908 if test "${ac_cv_path_PERLINTERP+set}" = set; then
9909  echo $ECHO_N "(cached) $ECHO_C" >&6
9910 else
9911  case $PERLINTERP in
9912  [\\/]* | ?:[\\/]*)
9913  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9914  ;;
9915  *)
9916  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9917 for as_dir in $PATH
9918 do
9919  IFS=$as_save_IFS
9920  test -z "$as_dir" && as_dir=.
9921  for ac_exec_ext in '' $ac_executable_extensions; do
9922  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9923    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9924    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9925    break 2
9926  fi
9927 done
9928 done
12155  
9930  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9931  ;;
9932 esac
12156   fi
9934 PERLINTERP=$ac_cv_path_PERLINTERP
12157  
12158 < if test -n "$PERLINTERP"; then
9937 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9938 < echo "${ECHO_T}$PERLINTERP" >&6
9939 < else
9940 <  echo "$as_me:$LINENO: result: no" >&5
9941 < echo "${ECHO_T}no" >&6
9942 < fi
9943 <
9944 <   ac_cv_path_perlinterp="$PERLINTERP"
9945 <   _sHpB='#!'
9946 <
9947 <
9948 < # Check whether --with-perl-shebang or --without-perl-shebang was given.
9949 < if test "${with_perl_shebang+set}" = set; then
9950 <  withval="$with_perl_shebang"
9951 <  opt_perl_shebang="$withval"
9952 < else
9953 <                opt_perl_shebang="not_set"
9954 < fi;
9955 <   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9956 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9957 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
9958 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9959 < else
9960 <   case "$opt_perl_shebang" in
9961 <                      not_set  ) ax_cv_opt_perl_shebang=''
9962 <                               ;;
9963 <                         *     )
9964 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9965 <                    esac
9966 <
9967 < fi
9968 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9969 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9970 <   if test "A$ax_cv_opt_perl_shebang" != "A"
9971 <     then
9972 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9973 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9974 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9975 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
9976 <
9977 < # Automatic detection of sharpbang formula starts here
9978 <     else
9979 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
9980 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9981 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9982 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9983 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9984 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9985 < else
9986 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9987 <        if test "x$_somian_kspb_perl" == x
9988 <          then _somian_ksbp_warn_empty='durnit'
9989 <          else
9990 <          case "A$_somian_kspb_perl" in
9991 <                 A#!*perl* )
9992 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9993 <                        ;;
9994 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9995 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9996 <          esac
9997 <        fi
9998 <
9999 < fi
10000 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
10001 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
10002 < # The above prints Checking ... result message to user.
10003 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
10004 <
10005 <    if test A${_somian_ksbp_warn_empty+set} == Aset
10006 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
10007 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
10008 <    fi
10009 < # Inform user after printing result value
10010 <    if test A${_somian_ksbp_warn_defau+set} == Aset
10011 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
10012 < echo "$as_me: Maybe Not good -" >&6;}
10013 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
10014 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
10015 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
10016 < echo "$as_me: OK Good result - " >&6;}
10017 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
10018 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
10019 <    fi
10020 <  fi
10021 <
10022 < # Extract the first word of "ar", so it can be a program name with args.
10023 < set dummy ar; ac_word=$2
10024 < echo "$as_me:$LINENO: checking for $ac_word" >&5
10025 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10026 < if test "${ac_cv_prog_AR+set}" = set; then
10027 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10028 < else
10029 <  if test -n "$AR"; then
10030 <  ac_cv_prog_AR="$AR" # Let the user override the test.
10031 < else
10032 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10033 < for as_dir in $PATH
10034 < do
10035 <  IFS=$as_save_IFS
10036 <  test -z "$as_dir" && as_dir=.
10037 <  for ac_exec_ext in '' $ac_executable_extensions; do
10038 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10039 <    ac_cv_prog_AR="ar"
10040 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10041 <    break 2
10042 <  fi
10043 < done
10044 < done
10045 <
10046 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
10047 < fi
10048 < fi
10049 < AR=$ac_cv_prog_AR
10050 < if test -n "$AR"; then
10051 <  echo "$as_me:$LINENO: result: $AR" >&5
10052 < echo "${ECHO_T}$AR" >&6
10053 < else
10054 <  echo "$as_me:$LINENO: result: no" >&5
10055 < echo "${ECHO_T}no" >&6
10056 < fi
10057 <
10058 < if test "$AR" = "NONE"; then
10059 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
10060 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
10061 <   { (exit 1); exit 1; }; }
10062 <  cat >confcache <<\_ACEOF
10063 < # This file is a shell script that caches the results of configure
10064 < # tests run on this system so they can be shared between configure
10065 < # scripts and configure runs, see configure's option --config-cache.
10066 < # It is not useful on other systems.  If it contains results you don't
10067 < # want to keep, you may remove or edit it.
10068 < #
10069 < # config.status only pays attention to the cache file if you give it
10070 < # the --recheck option to rerun configure.
10071 < #
10072 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
10073 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
10074 < # following values.
10075 <
10076 < _ACEOF
10077 <
10078 < # The following way of writing the cache mishandles newlines in values,
10079 < # but we know of no workaround that is simple, portable, and efficient.
10080 < # So, don't put newlines in cache variables' values.
10081 < # Ultrix sh set writes to stderr and can't be redirected directly,
10082 < # and sets the high bit in the cache file unless we assign to the vars.
10083 < {
10084 <  (set) 2>&1 |
10085 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
10086 <    *ac_space=\ *)
10087 <      # `set' does not quote correctly, so add quotes (double-quote
10088 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
10089 <      sed -n \
10090 <        "s/'/'\\\\''/g;
10091 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
10092 <      ;;
10093 <    *)
10094 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
10095 <      sed -n \
10096 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
10097 <      ;;
10098 <    esac;
10099 < } |
10100 <  sed '
10101 <     t clear
10102 <     : clear
10103 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
10104 <     t end
10105 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
10106 <     : end' >>confcache
10107 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
10108 <  if test -w $cache_file; then
10109 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
10110 <    cat confcache >$cache_file
10111 <  else
10112 <    echo "not updating unwritable cache $cache_file"
10113 <  fi
10114 < fi
10115 < rm -f confcache
10116 <  exit 1
10117 < fi
10118 <
10119 < # Extract the first word of "ps", so it can be a program name with args.
10120 < set dummy ps; ac_word=$2
10121 < echo "$as_me:$LINENO: checking for $ac_word" >&5
10122 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10123 < if test "${ac_cv_path_PS+set}" = set; then
10124 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10125 < else
10126 <  case $PS in
10127 <  [\\/]* | ?:[\\/]*)
10128 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
10129 <  ;;
10130 <  *)
10131 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 < for as_dir in $PATH
10133 < do
10134 <  IFS=$as_save_IFS
10135 <  test -z "$as_dir" && as_dir=.
10136 <  for ac_exec_ext in '' $ac_executable_extensions; do
10137 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
10139 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10140 <    break 2
10141 <  fi
10142 < done
10143 < done
10144 <
10145 <  ;;
12158 >     ;;
12159   esac
10147 fi
10148 PS=$ac_cv_path_PS
12160  
10150 if test -n "$PS"; then
10151  echo "$as_me:$LINENO: result: $PS" >&5
10152 echo "${ECHO_T}$PS" >&6
10153 else
10154  echo "$as_me:$LINENO: result: no" >&5
10155 echo "${ECHO_T}no" >&6
10156 fi
12161  
10158 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
10159 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
10160 if test "${ac_cv_prog_ps_syntax+set}" = set; then
10161  echo $ECHO_N "(cached) $ECHO_C" >&6
10162 else
10163
10164        if $PS ax -o rss > /dev/null 2>&1; then
10165                ac_cv_prog_ps_ax=yes
10166        else
10167                ac_cv_prog_ps_ax=no
10168        fi
10169        if $PS -ef -o rss > /dev/null 2>&1; then
10170                ac_cv_prog_ps_ef=yes
10171        else
10172                ac_cv_prog_ps_ef=no
10173        fi
10174        if test "$ac_cv_prog_ps_ax" = yes; then
10175                ac_cv_prog_ps_syntax=BSD
10176        else
10177                if test "$ac_cv_prog_ps_ef" = yes; then
10178                        ac_cv_prog_ps_syntax=POSIX
10179                else
10180                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
10181 echo "$as_me: error: Could not determine ps syntax" >&2;}
10182   { (exit 1); exit 1; }; }
10183                fi
10184        fi
10185
10186 fi
10187 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
10188 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
10189
10190
10191 cat >>confdefs.h <<_ACEOF
10192 #define PSCOMMAND $PS
10193 _ACEOF
10194
10195
12162   cat >>confdefs.h <<\_ACEOF
12163   #define OBAPI
12164   _ACEOF
12165  
12166  
12167  
10202 if test "$ac_cv_prog_ps_syntax" = BSD; then
12168  
10204 cat >>confdefs.h <<\_ACEOF
10205 #define PSTYPE_IS_BSD 1
10206 _ACEOF
10207
10208 else
10209   if test "$ac_cv_prog_ps_syntax" = POSIX; then
10210
10211 cat >>confdefs.h <<\_ACEOF
10212 #define PSTYPE_IS_POSIX 1
10213 _ACEOF
10214
10215   else
10216       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
10217 echo "$as_me: error: Unknown ps syntax type!" >&2;}
10218   { (exit 1); exit 1; }; }
10219   fi
10220 fi
10221
10222
12169   # Check whether --with-mpi or --without-mpi was given.
12170   if test "${with_mpi+set}" = set; then
12171    withval="$with_mpi"
# Line 10275 | Line 12221 | cat >conftest.f90 <<EOF
12221   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
12222   have_mpif_h=0
12223   rm -f conftest*
12224 < cat >conftest.f90 <<EOF
12224 > cat >conftest.$ac_ext <<EOF
12225   program main
12226     include 'mpif.h'
12227   end
12228   EOF
12229 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
12229 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
12230          echo "$as_me:$LINENO: result: yes" >&5
12231   echo "${ECHO_T}yes" >&6
12232          MPI_F90_INC="$MPI_INC_DIR"
# Line 10334 | Line 12280 | int
12280   /* We use char because int might match the return type of a gcc2
12281     builtin and then its argument prototype would still apply.  */
12282   char MPI_Init ();
12283 + #ifdef FC_DUMMY_MAIN
12284 + #ifndef FC_DUMMY_MAIN_EQ_F77
12285 + #  ifdef __cplusplus
12286 +     extern "C"
12287 + #  endif
12288 +   int FC_DUMMY_MAIN() { return 1; }
12289 + #endif
12290 + #endif
12291   int
12292   main ()
12293   {
# Line 10404 | Line 12358 | int
12358   /* We use char because int might match the return type of a gcc2
12359     builtin and then its argument prototype would still apply.  */
12360   char MPI_Init ();
12361 + #ifdef FC_DUMMY_MAIN
12362 + #ifndef FC_DUMMY_MAIN_EQ_F77
12363 + #  ifdef __cplusplus
12364 +     extern "C"
12365 + #  endif
12366 +   int FC_DUMMY_MAIN() { return 1; }
12367 + #endif
12368 + #endif
12369   int
12370   main ()
12371   {
# Line 10475 | Line 12437 | int
12437   /* We use char because int might match the return type of a gcc2
12438     builtin and then its argument prototype would still apply.  */
12439   char MPI_Init ();
12440 + #ifdef FC_DUMMY_MAIN
12441 + #ifndef FC_DUMMY_MAIN_EQ_F77
12442 + #  ifdef __cplusplus
12443 +     extern "C"
12444 + #  endif
12445 +   int FC_DUMMY_MAIN() { return 1; }
12446 + #endif
12447 + #endif
12448   int
12449   main ()
12450   {
# Line 10546 | Line 12516 | int
12516   /* We use char because int might match the return type of a gcc2
12517     builtin and then its argument prototype would still apply.  */
12518   char MPI_Init ();
12519 + #ifdef FC_DUMMY_MAIN
12520 + #ifndef FC_DUMMY_MAIN_EQ_F77
12521 + #  ifdef __cplusplus
12522 +     extern "C"
12523 + #  endif
12524 +   int FC_DUMMY_MAIN() { return 1; }
12525 + #endif
12526 + #endif
12527   int
12528   main ()
12529   {
# Line 10618 | Line 12596 | int
12596   /* We use char because int might match the return type of a gcc2
12597     builtin and then its argument prototype would still apply.  */
12598   char MPI_Init ();
12599 + #ifdef FC_DUMMY_MAIN
12600 + #ifndef FC_DUMMY_MAIN_EQ_F77
12601 + #  ifdef __cplusplus
12602 +     extern "C"
12603 + #  endif
12604 +   int FC_DUMMY_MAIN() { return 1; }
12605 + #endif
12606 + #endif
12607   int
12608   main ()
12609   {
# Line 10694 | Line 12680 | fi
12680  
12681  
12682  
10697
12683   USE_CGAL=no
12684   cgal_makefile=auto
12685  
# Line 11036 | Line 13021 | int
13021   cat >>conftest.$ac_ext <<_ACEOF
13022   /* end confdefs.h.  */
13023   #include <CGAL/Cartesian.h>
13024 + #ifdef FC_DUMMY_MAIN
13025 + #ifndef FC_DUMMY_MAIN_EQ_F77
13026 + #  ifdef __cplusplus
13027 +     extern "C"
13028 + #  endif
13029 +   int FC_DUMMY_MAIN() { return 1; }
13030 + #endif
13031 + #endif
13032   int
13033   main ()
13034   {
# Line 11276 | Line 13269 | fi
13269   else
13270          enable_dot=yes
13271   fi
11279
11280
11281
11282
11283
11284
11285
11286 OBJEXT=".$OBJEXT"
11287
11288 OOPSE=oopse
11289
11290 if test "x${prefix}" = "xNONE"
11291 then
11292  OOPSE_HOME=${ac_default_prefix}/oopse
11293 else
11294  OOPSE_HOME=${prefix}/oopse
11295 fi
11296 # Check whether --enable-oopse-home or --disable-oopse-home was given.
11297 if test "${enable_oopse_home+set}" = set; then
11298  enableval="$enable_oopse_home"
11299  OOPSE_HOME="${enableval}"
11300 fi;
11301
11302 case "x$INSTALL" in
11303   x/*) ;;
11304   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
11305 esac
11306
11307 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
13272  
11309 CFLAGS=${CFLAGS-""}
11310 CXXFLAGS=${CXXFLAGS-""}
11311 CPPFLAGS=${CPPFLAGS-""}
11312 FFLAGS=${FFLAGS-""}
11313 F90FLAGS=${F90FLAGS-""}
11314 LDFLAGS=${LDFLAGS-""}
11315 DEBUG=${DEBUG-"-g"}
13273  
11317 case $debug in
11318  1)
11319     FFLAGS="$DEBUG $FFLAGS"
11320     F90FLAGS="$DEBUG $F90FLAGS"
11321     ;;
11322  *)
11323     ;;
11324 esac
13274  
13275  
13276  
# Line 11339 | Line 13288 | esac
13288  
13289  
13290  
11342
11343          ac_config_headers="$ac_config_headers src/config.h"
11344
13291                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
13292  
13293  
# Line 11707 | Line 13653 | This file was extended by OOPSE $as_me 2.0, which was
13653   } >&5
13654   cat >&5 <<_CSEOF
13655  
13656 < This file was extended by OOPSE $as_me 2.0, which was
13656 > This file was extended by OOPSE $as_me 3.0, which was
13657   generated by GNU Autoconf 2.59.  Invocation command line was
13658  
13659    CONFIG_FILES    = $CONFIG_FILES
# Line 11770 | Line 13716 | OOPSE config.status 2.0
13716  
13717   cat >>$CONFIG_STATUS <<_ACEOF
13718   ac_cs_version="\\
13719 < OOPSE config.status 2.0
13719 > OOPSE config.status 3.0
13720   configured by $0, generated by GNU Autoconf 2.59,
13721    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13722  
# Line 11964 | Line 13910 | s,@PROGNAME@,$PROGNAME,;t t
13910   s,@ECHO_N@,$ECHO_N,;t t
13911   s,@ECHO_T@,$ECHO_T,;t t
13912   s,@LIBS@,$LIBS,;t t
11967 s,@PROGNAME@,$PROGNAME,;t t
11968 s,@debug@,$debug,;t t
13913   s,@build@,$build,;t t
13914   s,@build_cpu@,$build_cpu,;t t
13915   s,@build_vendor@,$build_vendor,;t t
# Line 11974 | Line 13918 | s,@CC@,$CC,;t t
13918   s,@host_cpu@,$host_cpu,;t t
13919   s,@host_vendor@,$host_vendor,;t t
13920   s,@host_os@,$host_os,;t t
13921 < s,@CC@,$CC,;t t
13922 < s,@CFLAGS@,$CFLAGS,;t t
13921 > s,@PROGNAME@,$PROGNAME,;t t
13922 > s,@debug@,$debug,;t t
13923 > s,@CXX@,$CXX,;t t
13924 > s,@CXXFLAGS@,$CXXFLAGS,;t t
13925   s,@LDFLAGS@,$LDFLAGS,;t t
13926   s,@CPPFLAGS@,$CPPFLAGS,;t t
13927 < s,@ac_ct_CC@,$ac_ct_CC,;t t
13927 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13928   s,@EXEEXT@,$EXEEXT,;t t
13929   s,@OBJEXT@,$OBJEXT,;t t
13930 < s,@CXX@,$CXX,;t t
13931 < s,@CXXFLAGS@,$CXXFLAGS,;t t
13932 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13930 > s,@CC@,$CC,;t t
13931 > s,@CFLAGS@,$CFLAGS,;t t
13932 > s,@ac_ct_CC@,$ac_ct_CC,;t t
13933 > s,@FC@,$FC,;t t
13934 > s,@FCFLAGS@,$FCFLAGS,;t t
13935 > s,@ac_ct_FC@,$ac_ct_FC,;t t
13936   s,@CPP@,$CPP,;t t
13937   s,@EGREP@,$EGREP,;t t
11989 s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11990 s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11991 s,@F90@,$F90,;t t
11992 s,@F90FLAGS@,$F90FLAGS,;t t
11993 s,@ac_ct_F90@,$ac_ct_F90,;t t
11994 s,@PREPFLAG@,$PREPFLAG,;t t
11995 s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11996 s,@F90LIBS@,$F90LIBS,;t t
11997 s,@F90_FUNC@,$F90_FUNC,;t t
11998 s,@F90_FUNC_@,$F90_FUNC_,;t t
11999 s,@MOD@,$MOD,;t t
12000 s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
12001 s,@MODDIRFLAG@,$MODDIRFLAG,;t t
12002 s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
12003 s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
12004 s,@CXXCPP@,$CXXCPP,;t t
12005 s,@LIBOBJS@,$LIBOBJS,;t t
12006 s,@__func__@,$__func__,;t t
12007 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12008 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12009 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13938   s,@LN_S@,$LN_S,;t t
13939   s,@SET_MAKE@,$SET_MAKE,;t t
13940   s,@RANLIB@,$RANLIB,;t t
13941   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
12014 s,@YACC@,$YACC,;t t
12015 s,@LEX@,$LEX,;t t
12016 s,@LEXLIB@,$LEXLIB,;t t
12017 s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
13942   s,@PERLINTERP@,$PERLINTERP,;t t
13943   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
13944 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13945 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13946 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13947   s,@AR@,$AR,;t t
13948   s,@PS@,$PS,;t t
13949 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
13950 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
13951 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
13952 + s,@FCLIBS@,$FCLIBS,;t t
13953 + s,@FC_FUNC@,$FC_FUNC,;t t
13954 + s,@FC_FUNC_@,$FC_FUNC_,;t t
13955 + s,@MOD@,$MOD,;t t
13956 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
13957 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
13958 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
13959 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
13960 + s,@LIBOBJS@,$LIBOBJS,;t t
13961 + s,@POW_LIB@,$POW_LIB,;t t
13962 + s,@CXXCPP@,$CXXCPP,;t t
13963 + s,@__func__@,$__func__,;t t
13964   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
13965   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
13966   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 12043 | Line 13985 | s,@FFLAGS@,$FFLAGS,;t t
13985   s,@OOPSE@,$OOPSE,;t t
13986   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
13987   s,@SUBDIRS@,$SUBDIRS,;t t
12046 s,@FFLAGS@,$FFLAGS,;t t
13988   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13989   CEOF
13990  
# Line 12681 | Line 14622 | fi
14622    $ac_cs_success || { (exit 1); exit 1; }
14623   fi
14624  
14625 +
14626 +

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines