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

Comparing trunk/configure (file contents):
Revision 803 by gezelter, Thu Dec 8 22:04:30 2005 UTC vs.
Revision 957 by gezelter, Tue May 16 20:38:23 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX CPP EGREP OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 < ac_env_CC_set=${CC+set}
757 < ac_env_CC_value=$CC
758 < ac_cv_env_CC_set=${CC+set}
759 < ac_cv_env_CC_value=$CC
760 < ac_env_CFLAGS_set=${CFLAGS+set}
761 < ac_env_CFLAGS_value=$CFLAGS
762 < ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 < ac_cv_env_CFLAGS_value=$CFLAGS
756 > ac_env_CXX_set=${CXX+set}
757 > ac_env_CXX_value=$CXX
758 > ac_cv_env_CXX_set=${CXX+set}
759 > ac_cv_env_CXX_value=$CXX
760 > ac_env_CXXFLAGS_set=${CXXFLAGS+set}
761 > ac_env_CXXFLAGS_value=$CXXFLAGS
762 > ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763 > ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764   ac_env_LDFLAGS_set=${LDFLAGS+set}
765   ac_env_LDFLAGS_value=$LDFLAGS
766   ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
# Line 769 | Line 769 | ac_cv_env_CPPFLAGS_value=$CPPFLAGS
769   ac_env_CPPFLAGS_value=$CPPFLAGS
770   ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771   ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 < ac_env_CXX_set=${CXX+set}
773 < ac_env_CXX_value=$CXX
774 < ac_cv_env_CXX_set=${CXX+set}
775 < ac_cv_env_CXX_value=$CXX
776 < ac_env_CXXFLAGS_set=${CXXFLAGS+set}
777 < ac_env_CXXFLAGS_value=$CXXFLAGS
778 < ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
779 < ac_cv_env_CXXFLAGS_value=$CXXFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 ac_env_F90_set=${F90+set}
785 ac_env_F90_value=$F90
786 ac_cv_env_F90_set=${F90+set}
787 ac_cv_env_F90_value=$F90
788 ac_env_F90FLAGS_set=${F90FLAGS+set}
789 ac_env_F90FLAGS_value=$F90FLAGS
790 ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884    --with-zlib=DIR root directory path of zlib installation defaults to
885                      /usr/local or /usr if not found in /usr/local
886    --without-zlib to disable zlib usage completely
887 <  --with-perl-shebang     override what perl thinks is the way for the kernel
888 <                          to start it (seldom needed)
887 >  --with-fftw=DIR         root directory path of fftw installation (defaults
888 >                          to /usr/local or /usr if not found in /usr/local)
889    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
890    --with-cgal-makefile=FILE  CGAL makefile that should be used
891  
892   Some influential environment variables:
893 <  CC          C compiler command
894 <  CFLAGS      C compiler flags
893 >  CXX         C++ compiler command
894 >  CXXFLAGS    C++ compiler flags
895    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
896                nonstandard directory <lib dir>
897    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
898                headers in a nonstandard directory <include dir>
899 <  CXX         C++ compiler command
900 <  CXXFLAGS    C++ compiler flags
899 >  CC          C compiler command
900 >  CFLAGS      C compiler flags
901 >  FC          Fortran compiler command
902 >  FCFLAGS     Fortran compiler flags
903    CPP         C preprocessor
900  F90         Fortran 90 compiler command
901  F90FLAGS    Fortran 90 compiler flags
904    CXXCPP      C++ preprocessor
905  
906   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1002 | if $ac_init_version; then
1002   test -n "$ac_init_help" && exit 0
1003   if $ac_init_version; then
1004    cat <<\_ACEOF
1005 < OOPSE configure 2.0
1005 > OOPSE configure 3.0
1006   generated by GNU Autoconf 2.59
1007  
1008   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1016 | running configure, to aid debugging if configure makes
1016   This file contains any messages produced by compilers while
1017   running configure, to aid debugging if configure makes a mistake.
1018  
1019 < It was created by OOPSE $as_me 2.0, which was
1019 > It was created by OOPSE $as_me 3.0, which was
1020   generated by GNU Autoconf 2.59.  Invocation command line was
1021  
1022    $ $0 $@
# Line 1376 | Line 1378 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1378   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1379  
1380  
1381 < # This file is part of Autoconf.                       -*- Autoconf -*-
1380 < # Programming languages support.
1381 < # Copyright 2000, 2001
1382 < # Free Software Foundation, Inc.
1383 < #
1384 < # This program is free software; you can redistribute it and/or modify
1385 < # it under the terms of the GNU General Public License as published by
1386 < # the Free Software Foundation; either version 2, or (at your option)
1387 < # any later version.
1388 < #
1389 < # This program is distributed in the hope that it will be useful,
1390 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 < # GNU General Public License for more details.
1393 < #
1394 < # You should have received a copy of the GNU General Public License
1395 < # along with this program; if not, write to the Free Software
1396 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 < # 02111-1307, USA.
1398 < #
1399 < # As a special exception, the Free Software Foundation gives unlimited
1400 < # permission to copy, distribute and modify the configure scripts that
1401 < # are the output of Autoconf.  You need not follow the terms of the GNU
1402 < # General Public License when using or distributing such scripts, even
1403 < # though portions of the text of Autoconf appear in them.  The GNU
1404 < # General Public License (GPL) does govern all other use of the material
1405 < # that constitutes the Autoconf program.
1406 < #
1407 < # Certain portions of the Autoconf source text are designed to be copied
1408 < # (in certain cases, depending on the input) into the output of
1409 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 < # source text consists of comments plus executable code that decides which
1411 < # of the data portions to output in any given case.  We call these
1412 < # comments and executable code the "non-data" portions.  Autoconf never
1413 < # copies any of the non-data portions into its output.
1414 < #
1415 < # This special exception to the GPL applies to versions of Autoconf
1416 < # released by the Free Software Foundation.  When you make and
1417 < # distribute a modified version of Autoconf, you may extend this special
1418 < # exception to the GPL to apply to your modified version as well, *unless*
1419 < # your modified version has the potential to copy into its output some
1420 < # of the text that was the non-data portion of the version that you started
1421 < # with.  (In other words, unless your change moves or copies text from
1422 < # the non-data portions to the data portions.)  If your modification has
1423 < # such potential, you must delete any notice of this special exception
1424 < # to the GPL from your modified version.
1425 < #
1426 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 < # many others).
1381 >          ac_config_headers="$ac_config_headers src/config.h"
1382  
1383  
1430 # Table of Contents:
1431 #
1432 # 1. Language selection
1433 #    and routines to produce programs in a given language.
1434 #  a. Fortran 77 (to be moved from aclang.m4)
1435 #  b. Fortran 90
1436 #  c. Fortran 95
1437 #
1438 # 2. Producing programs in a given language.
1439 #  a. Fortran 77 (to be moved from aclang.m4)
1440 #  b. Fortran 90
1441 #  c. Fortran 95
1442 #
1443 # 3. Looking for a compiler
1444 #    And possibly the associated preprocessor.
1445 #  a. Fortran 77 (to be moved from aclang.m4)
1446 #  b. Fortran 90
1447 #  c. Fortran 95
1448 #
1449 # 4. Compilers' characteristics.
1450 #  a. Fortran 77 (to be moved from aclang.m4)
1451 #  b. Fortran 90
1452 #  c. Fortran 95
1384  
1454 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 # ---------------------------------------------------------------------------
1456 #
1457 # Processing the elements of a list is tedious in shell programming,
1458 # as lists tend to be implemented as space delimited strings.
1459 #
1460 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 # if ELEMENT is a member of LIST, otherwise it executes
1462 # ACTION-IF-NOT-FOUND.
1463 # _AC_LIST_MEMBER_IF
1385  
1386  
1387  
1467 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 # -------------------------------------------------
1469 #
1470 # Specifying options to the compiler (whether it be the C, C++ or
1471 # Fortran 77 compiler) that are meant for the linker is compiler
1472 # dependent.  This macro lets you give options to the compiler that
1473 # are meant for the linker in a portable, compiler-independent way.
1474 #
1475 # This macro take two arguments, a list of linker options that the
1476 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 # appended to the shell variable in a compiler-dependent way.
1479 #
1480 # For example, if the selected language is C, then this:
1481 #
1482 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 #
1484 # will expand into this if the selected C compiler is gcc:
1485 #
1486 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 #
1488 # otherwise, it will expand into this:
1489 #
1490 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 #
1492 # You are encouraged to add support for compilers that this macro
1493 # doesn't currently support.
1494 # FIXME: Get rid of this macro.
1495 # _AC_LINKER_OPTION
1388  
1389  
1390  
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1391  
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
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 # --------------------------------
1559
1560
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1392  
1393  
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1394  
1395  
1396  
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1397  
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1398  
1399  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1400  
1401  
1402  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1403  
1404  
1405  
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
1406  
1407  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1408  
1409  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1410  
1411  
1412  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1413  
1414  
1415  
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
1416  
1417  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1418  
1419  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1420  
1421  
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
1422  
1423  
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
1424  
1425  
1672 # AC_F90_LIBRARY_LDFLAGS
1673 # ----------------------
1426   #
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.
1427   #
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.
1428   #
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
1429  
1430  
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
1431  
1717 # The replacement is empty.
1432  
1433  
1434 + # AC_F90_MODULE_NAMES
1435 + # -------------------
1436 + #
1437 + # Figure out how the Fortran 90 compiler constructs module file names
1438 + #
1439 + # AC_F90_MODULE_NAMES
1440  
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
1441  
1442  
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
1443  
1444  
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1445  
1446  
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
1447  
1448  
1754 # _AC_PROG_F95_V
1755 # --------------
1756 #
1757 # Determine the flag that causes the Fortran 95 compiler to print
1758 # information of library and object files (normally -v)
1759 # Needed for AC_F95_LIBRARY_FLAGS
1760 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 # _AC_PROG_F95_V
1449  
1450  
1764 # AC_F95_LIBRARY_LDFLAGS
1765 # ----------------------
1766 #
1767 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 # intrinsic and run-time libraries that are required to successfully
1769 # link a Fortran 95 program or shared library.  The output variable
1770 # F95LIBS is set to these flags.
1771 #
1772 # This macro is intended to be used in those situations when it is
1773 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 # program or shared library.
1775 #
1776 # For example, if object files from a C++ and Fortran 95 compiler must
1777 # be linked together, then the C++ compiler/linker must be used for
1778 # linking (since special C++-ish things need to happen at link time
1779 # like calling global constructors, instantiating templates, enabling
1780 # exception support, etc.).
1781 #
1782 # However, the Fortran 95 intrinsic and run-time libraries must be
1783 # linked in as well, but the C++ compiler/linker doesn't know how to
1784 # add these Fortran 95 libraries.  Hence, the macro
1785 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 # libraries.
1787 #
1788 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 # AC_F95_LIBRARY_LDFLAGS
1451  
1452  
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
1453  
1809 # The replacement is empty.
1454  
1455  
1456  
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
1457  
1458  
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
1459  
1829 # AC_F90_MODULE_NAMES
1830 # -------------------
1831 #
1832 # Figure out how the Fortran 90 compiler constructs module file names
1833 #
1834 # AC_F90_MODULE_NAMES
1460  
1461  
1462  
# Line 1885 | Line 1510 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1510  
1511  
1512  
1888 #
1889 #
1890 #
1513  
1514  
1515  
# Line 1896 | Line 1518 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1518  
1519  
1520  
1899 # set program name
1900 PROGNAME="oopse"
1521  
1522  
1903 # there are two ways to do debugging.  One with the --enable-debug flag
1904 # and one using the DEBUG environment variable
1523  
1906 debug=0
1907 # Check whether --enable-debug or --disable-debug was given.
1908 if test "${enable_debug+set}" = set; then
1909  enableval="$enable_debug"
1910  debug=1
1911 fi;
1912 if test "${DEBUG}"; then
1524  
1914 cat >>confdefs.h <<\_ACEOF
1915 #define debug 1
1916 _ACEOF
1525  
1918  msg="$msg, debug mode"
1919 fi
1526  
1527  
1528   # who am i
# Line 1977 | Line 1583 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1583  
1584  
1585  
1586 < ac_ext=c
1587 < ac_cpp='$CPP $CPPFLAGS'
1588 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1589 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1590 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1586 > # set program name
1587 > PROGNAME="oopse"
1588 >
1589 >
1590 >
1591 >
1592 > OBJEXT=".$OBJEXT"
1593 >
1594 > OOPSE=oopse
1595 >
1596 > if test "x${prefix}" = "xNONE"
1597 > then
1598 >  OOPSE_HOME=${ac_default_prefix}/oopse
1599 > else
1600 >  OOPSE_HOME=${prefix}/oopse
1601 > fi
1602 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1603 > if test "${enable_oopse_home+set}" = set; then
1604 >  enableval="$enable_oopse_home"
1605 >  OOPSE_HOME="${enableval}"
1606 > fi;
1607 >
1608 > # there are two ways to do debugging.  One with the --enable-debug flag
1609 > # and one using the DEBUG environment variable
1610 >
1611 > debug=0
1612 > # Check whether --enable-debug or --disable-debug was given.
1613 > if test "${enable_debug+set}" = set; then
1614 >  enableval="$enable_debug"
1615 >  debug=1
1616 > fi;
1617 > if test "${DEBUG}"; then
1618 >
1619 > cat >>confdefs.h <<\_ACEOF
1620 > #define debug 1
1621 > _ACEOF
1622 >
1623 >  msg="$msg, debug mode"
1624 > fi
1625 >
1626 >
1627 > # Checks for programs.
1628 > ac_ext=cc
1629 > ac_cpp='$CXXCPP $CPPFLAGS'
1630 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1631 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1632 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1633   if test -n "$ac_tool_prefix"; then
1634 <  for ac_prog in pathcc icc xlc gcc cc
1634 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1635    do
1636      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1637   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1638   echo "$as_me:$LINENO: checking for $ac_word" >&5
1639   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1640 < if test "${ac_cv_prog_CC+set}" = set; then
1640 > if test "${ac_cv_prog_CXX+set}" = set; then
1641    echo $ECHO_N "(cached) $ECHO_C" >&6
1642   else
1643 <  if test -n "$CC"; then
1644 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1643 >  if test -n "$CXX"; then
1644 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1645   else
1646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1647   for as_dir in $PATH
# Line 2002 | Line 1650 | do
1650    test -z "$as_dir" && as_dir=.
1651    for ac_exec_ext in '' $ac_executable_extensions; do
1652    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1653 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1653 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1654      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1655      break 2
1656    fi
# Line 2011 | Line 1659 | fi
1659  
1660   fi
1661   fi
1662 < CC=$ac_cv_prog_CC
1663 < if test -n "$CC"; then
1664 <  echo "$as_me:$LINENO: result: $CC" >&5
1665 < echo "${ECHO_T}$CC" >&6
1662 > CXX=$ac_cv_prog_CXX
1663 > if test -n "$CXX"; then
1664 >  echo "$as_me:$LINENO: result: $CXX" >&5
1665 > echo "${ECHO_T}$CXX" >&6
1666   else
1667    echo "$as_me:$LINENO: result: no" >&5
1668   echo "${ECHO_T}no" >&6
1669   fi
1670  
1671 <    test -n "$CC" && break
1671 >    test -n "$CXX" && break
1672    done
1673   fi
1674 < if test -z "$CC"; then
1675 <  ac_ct_CC=$CC
1676 <  for ac_prog in pathcc icc xlc gcc cc
1674 > if test -z "$CXX"; then
1675 >  ac_ct_CXX=$CXX
1676 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1677   do
1678    # Extract the first word of "$ac_prog", so it can be a program name with args.
1679   set dummy $ac_prog; ac_word=$2
1680   echo "$as_me:$LINENO: checking for $ac_word" >&5
1681   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1682 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1682 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1683    echo $ECHO_N "(cached) $ECHO_C" >&6
1684   else
1685 <  if test -n "$ac_ct_CC"; then
1686 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1685 >  if test -n "$ac_ct_CXX"; then
1686 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1687   else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689   for as_dir in $PATH
# Line 2044 | Line 1692 | do
1692    test -z "$as_dir" && as_dir=.
1693    for ac_exec_ext in '' $ac_executable_extensions; do
1694    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1695 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1695 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1696      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1697      break 2
1698    fi
# Line 2053 | Line 1701 | fi
1701  
1702   fi
1703   fi
1704 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1705 < if test -n "$ac_ct_CC"; then
1706 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1707 < echo "${ECHO_T}$ac_ct_CC" >&6
1704 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1705 > if test -n "$ac_ct_CXX"; then
1706 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1707 > echo "${ECHO_T}$ac_ct_CXX" >&6
1708   else
1709    echo "$as_me:$LINENO: result: no" >&5
1710   echo "${ECHO_T}no" >&6
1711   fi
1712  
1713 <  test -n "$ac_ct_CC" && break
1713 >  test -n "$ac_ct_CXX" && break
1714   done
1715 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1716  
1717 <  CC=$ac_ct_CC
1717 >  CXX=$ac_ct_CXX
1718   fi
1719  
1720  
2072 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2073 See \`config.log' for more details." >&5
2074 echo "$as_me: error: no acceptable C compiler found in \$PATH
2075 See \`config.log' for more details." >&2;}
2076   { (exit 1); exit 1; }; }
2077
1721   # Provide some information about the compiler.
1722   echo "$as_me:$LINENO:" \
1723 <     "checking for C compiler version" >&5
1723 >     "checking for C++ compiler version" >&5
1724   ac_compiler=`set X $ac_compile; echo $2`
1725   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1726    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2115 | Line 1758 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1758   # Try to create an executable without -o first, disregard a.out.
1759   # It will help us diagnose broken compilers, and finding out an intuition
1760   # of exeext.
1761 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1762 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1761 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1762 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1763   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1764   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1765    (eval $ac_link_default) 2>&5
# Line 2159 | Line 1802 | sed 's/^/| /' conftest.$ac_ext >&5
1802    echo "$as_me: failed program was:" >&5
1803   sed 's/^/| /' conftest.$ac_ext >&5
1804  
1805 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1805 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1806   See \`config.log' for more details." >&5
1807 < echo "$as_me: error: C compiler cannot create executables
1807 > echo "$as_me: error: C++ compiler cannot create executables
1808   See \`config.log' for more details." >&2;}
1809     { (exit 77); exit 77; }; }
1810   fi
# Line 2172 | Line 1815 | echo "${ECHO_T}$ac_file" >&6
1815  
1816   # Check the compiler produces executables we can run.  If not, either
1817   # the compiler is broken, or we cross compile.
1818 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1819 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1818 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1819 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1820   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1821   # If not cross compiling, check that we can run a simple program.
1822   if test "$cross_compiling" != yes; then
# Line 2188 | Line 1831 | if test "$cross_compiling" != yes; then
1831      if test "$cross_compiling" = maybe; then
1832          cross_compiling=yes
1833      else
1834 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1834 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1835   If you meant to cross compile, use \`--host'.
1836   See \`config.log' for more details." >&5
1837 < echo "$as_me: error: cannot run C compiled programs.
1837 > echo "$as_me: error: cannot run C++ compiled programs.
1838   If you meant to cross compile, use \`--host'.
1839   See \`config.log' for more details." >&2;}
1840     { (exit 1); exit 1; }; }
# Line 2296 | Line 1939 | ac_objext=$OBJEXT
1939   echo "${ECHO_T}$ac_cv_objext" >&6
1940   OBJEXT=$ac_cv_objext
1941   ac_objext=$OBJEXT
1942 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1943 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1944 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1945 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1946 + else
1947 +  cat >conftest.$ac_ext <<_ACEOF
1948 + /* confdefs.h.  */
1949 + _ACEOF
1950 + cat confdefs.h >>conftest.$ac_ext
1951 + cat >>conftest.$ac_ext <<_ACEOF
1952 + /* end confdefs.h.  */
1953 +
1954 + int
1955 + main ()
1956 + {
1957 + #ifndef __GNUC__
1958 +       choke me
1959 + #endif
1960 +
1961 +  ;
1962 +  return 0;
1963 + }
1964 + _ACEOF
1965 + rm -f conftest.$ac_objext
1966 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1967 +  (eval $ac_compile) 2>conftest.er1
1968 +  ac_status=$?
1969 +  grep -v '^ *+' conftest.er1 >conftest.err
1970 +  rm -f conftest.er1
1971 +  cat conftest.err >&5
1972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973 +  (exit $ac_status); } &&
1974 +         { ac_try='test -z "$ac_cxx_werror_flag"
1975 +                         || test ! -s conftest.err'
1976 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1977 +  (eval $ac_try) 2>&5
1978 +  ac_status=$?
1979 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1980 +  (exit $ac_status); }; } &&
1981 +         { ac_try='test -s conftest.$ac_objext'
1982 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1983 +  (eval $ac_try) 2>&5
1984 +  ac_status=$?
1985 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986 +  (exit $ac_status); }; }; then
1987 +  ac_compiler_gnu=yes
1988 + else
1989 +  echo "$as_me: failed program was:" >&5
1990 + sed 's/^/| /' conftest.$ac_ext >&5
1991 +
1992 + ac_compiler_gnu=no
1993 + fi
1994 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1996 +
1997 + fi
1998 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1999 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2000 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2001 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2002 + ac_save_CXXFLAGS=$CXXFLAGS
2003 + CXXFLAGS="-g"
2004 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2005 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2006 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2007 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2008 + else
2009 +  cat >conftest.$ac_ext <<_ACEOF
2010 + /* confdefs.h.  */
2011 + _ACEOF
2012 + cat confdefs.h >>conftest.$ac_ext
2013 + cat >>conftest.$ac_ext <<_ACEOF
2014 + /* end confdefs.h.  */
2015 +
2016 + int
2017 + main ()
2018 + {
2019 +
2020 +  ;
2021 +  return 0;
2022 + }
2023 + _ACEOF
2024 + rm -f conftest.$ac_objext
2025 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2026 +  (eval $ac_compile) 2>conftest.er1
2027 +  ac_status=$?
2028 +  grep -v '^ *+' conftest.er1 >conftest.err
2029 +  rm -f conftest.er1
2030 +  cat conftest.err >&5
2031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2032 +  (exit $ac_status); } &&
2033 +         { ac_try='test -z "$ac_cxx_werror_flag"
2034 +                         || test ! -s conftest.err'
2035 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2036 +  (eval $ac_try) 2>&5
2037 +  ac_status=$?
2038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2039 +  (exit $ac_status); }; } &&
2040 +         { ac_try='test -s conftest.$ac_objext'
2041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2042 +  (eval $ac_try) 2>&5
2043 +  ac_status=$?
2044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045 +  (exit $ac_status); }; }; then
2046 +  ac_cv_prog_cxx_g=yes
2047 + else
2048 +  echo "$as_me: failed program was:" >&5
2049 + sed 's/^/| /' conftest.$ac_ext >&5
2050 +
2051 + ac_cv_prog_cxx_g=no
2052 + fi
2053 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2054 + fi
2055 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2056 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2057 + if test "$ac_test_CXXFLAGS" = set; then
2058 +  CXXFLAGS=$ac_save_CXXFLAGS
2059 + elif test $ac_cv_prog_cxx_g = yes; then
2060 +  if test "$GXX" = yes; then
2061 +    CXXFLAGS="-g -O2"
2062 +  else
2063 +    CXXFLAGS="-g"
2064 +  fi
2065 + else
2066 +  if test "$GXX" = yes; then
2067 +    CXXFLAGS="-O2"
2068 +  else
2069 +    CXXFLAGS=
2070 +  fi
2071 + fi
2072 + for ac_declaration in \
2073 +   '' \
2074 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2075 +   'extern "C" void std::exit (int); using std::exit;' \
2076 +   'extern "C" void exit (int) throw ();' \
2077 +   'extern "C" void exit (int);' \
2078 +   'void exit (int);'
2079 + do
2080 +  cat >conftest.$ac_ext <<_ACEOF
2081 + /* confdefs.h.  */
2082 + _ACEOF
2083 + cat confdefs.h >>conftest.$ac_ext
2084 + cat >>conftest.$ac_ext <<_ACEOF
2085 + /* end confdefs.h.  */
2086 + $ac_declaration
2087 + #include <stdlib.h>
2088 + int
2089 + main ()
2090 + {
2091 + exit (42);
2092 +  ;
2093 +  return 0;
2094 + }
2095 + _ACEOF
2096 + rm -f conftest.$ac_objext
2097 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2098 +  (eval $ac_compile) 2>conftest.er1
2099 +  ac_status=$?
2100 +  grep -v '^ *+' conftest.er1 >conftest.err
2101 +  rm -f conftest.er1
2102 +  cat conftest.err >&5
2103 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104 +  (exit $ac_status); } &&
2105 +         { ac_try='test -z "$ac_cxx_werror_flag"
2106 +                         || test ! -s conftest.err'
2107 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108 +  (eval $ac_try) 2>&5
2109 +  ac_status=$?
2110 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2111 +  (exit $ac_status); }; } &&
2112 +         { ac_try='test -s conftest.$ac_objext'
2113 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2114 +  (eval $ac_try) 2>&5
2115 +  ac_status=$?
2116 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2117 +  (exit $ac_status); }; }; then
2118 +  :
2119 + else
2120 +  echo "$as_me: failed program was:" >&5
2121 + sed 's/^/| /' conftest.$ac_ext >&5
2122 +
2123 + continue
2124 + fi
2125 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2126 +  cat >conftest.$ac_ext <<_ACEOF
2127 + /* confdefs.h.  */
2128 + _ACEOF
2129 + cat confdefs.h >>conftest.$ac_ext
2130 + cat >>conftest.$ac_ext <<_ACEOF
2131 + /* end confdefs.h.  */
2132 + $ac_declaration
2133 + int
2134 + main ()
2135 + {
2136 + exit (42);
2137 +  ;
2138 +  return 0;
2139 + }
2140 + _ACEOF
2141 + rm -f conftest.$ac_objext
2142 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2143 +  (eval $ac_compile) 2>conftest.er1
2144 +  ac_status=$?
2145 +  grep -v '^ *+' conftest.er1 >conftest.err
2146 +  rm -f conftest.er1
2147 +  cat conftest.err >&5
2148 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2149 +  (exit $ac_status); } &&
2150 +         { ac_try='test -z "$ac_cxx_werror_flag"
2151 +                         || test ! -s conftest.err'
2152 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2153 +  (eval $ac_try) 2>&5
2154 +  ac_status=$?
2155 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2156 +  (exit $ac_status); }; } &&
2157 +         { ac_try='test -s conftest.$ac_objext'
2158 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2159 +  (eval $ac_try) 2>&5
2160 +  ac_status=$?
2161 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2162 +  (exit $ac_status); }; }; then
2163 +  break
2164 + else
2165 +  echo "$as_me: failed program was:" >&5
2166 + sed 's/^/| /' conftest.$ac_ext >&5
2167 +
2168 + fi
2169 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2170 + done
2171 + rm -f conftest*
2172 + if test -n "$ac_declaration"; then
2173 +  echo '#ifdef __cplusplus' >>confdefs.h
2174 +  echo $ac_declaration      >>confdefs.h
2175 +  echo '#endif'             >>confdefs.h
2176 + fi
2177 +
2178 + ac_ext=c
2179 + ac_cpp='$CPP $CPPFLAGS'
2180 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2181 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2182 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2183 +
2184 + ac_ext=c
2185 + ac_cpp='$CPP $CPPFLAGS'
2186 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2187 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2188 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2189 + if test -n "$ac_tool_prefix"; then
2190 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2191 +  do
2192 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2193 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2194 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2195 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2196 + if test "${ac_cv_prog_CC+set}" = set; then
2197 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2198 + else
2199 +  if test -n "$CC"; then
2200 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2201 + else
2202 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2203 + for as_dir in $PATH
2204 + do
2205 +  IFS=$as_save_IFS
2206 +  test -z "$as_dir" && as_dir=.
2207 +  for ac_exec_ext in '' $ac_executable_extensions; do
2208 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2209 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2210 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2211 +    break 2
2212 +  fi
2213 + done
2214 + done
2215 +
2216 + fi
2217 + fi
2218 + CC=$ac_cv_prog_CC
2219 + if test -n "$CC"; then
2220 +  echo "$as_me:$LINENO: result: $CC" >&5
2221 + echo "${ECHO_T}$CC" >&6
2222 + else
2223 +  echo "$as_me:$LINENO: result: no" >&5
2224 + echo "${ECHO_T}no" >&6
2225 + fi
2226 +
2227 +    test -n "$CC" && break
2228 +  done
2229 + fi
2230 + if test -z "$CC"; then
2231 +  ac_ct_CC=$CC
2232 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2233 + do
2234 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2235 + set dummy $ac_prog; ac_word=$2
2236 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2237 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2238 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2239 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2240 + else
2241 +  if test -n "$ac_ct_CC"; then
2242 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2243 + else
2244 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2245 + for as_dir in $PATH
2246 + do
2247 +  IFS=$as_save_IFS
2248 +  test -z "$as_dir" && as_dir=.
2249 +  for ac_exec_ext in '' $ac_executable_extensions; do
2250 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2251 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2252 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2253 +    break 2
2254 +  fi
2255 + done
2256 + done
2257 +
2258 + fi
2259 + fi
2260 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2261 + if test -n "$ac_ct_CC"; then
2262 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2263 + echo "${ECHO_T}$ac_ct_CC" >&6
2264 + else
2265 +  echo "$as_me:$LINENO: result: no" >&5
2266 + echo "${ECHO_T}no" >&6
2267 + fi
2268 +
2269 +  test -n "$ac_ct_CC" && break
2270 + done
2271 +
2272 +  CC=$ac_ct_CC
2273 + fi
2274 +
2275 +
2276 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2277 + See \`config.log' for more details." >&5
2278 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2279 + See \`config.log' for more details." >&2;}
2280 +   { (exit 1); exit 1; }; }
2281 +
2282 + # Provide some information about the compiler.
2283 + echo "$as_me:$LINENO:" \
2284 +     "checking for C compiler version" >&5
2285 + ac_compiler=`set X $ac_compile; echo $2`
2286 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2287 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2288 +  ac_status=$?
2289 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2290 +  (exit $ac_status); }
2291 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2292 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2293 +  ac_status=$?
2294 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2295 +  (exit $ac_status); }
2296 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2297 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2298 +  ac_status=$?
2299 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2300 +  (exit $ac_status); }
2301 +
2302   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2303   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2304   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2690 | Line 2693 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2693   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2694   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2695  
2696 <
2697 < ac_ext=cc
2698 < ac_cpp='$CXXCPP $CPPFLAGS'
2699 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2697 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2698 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2696 > ac_ext=${FC_SRCEXT-f}
2697 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2698 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2699 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2700   if test -n "$ac_tool_prefix"; then
2701 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2701 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2702    do
2703      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2704   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2705   echo "$as_me:$LINENO: checking for $ac_word" >&5
2706   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2707 < if test "${ac_cv_prog_CXX+set}" = set; then
2707 > if test "${ac_cv_prog_FC+set}" = set; then
2708    echo $ECHO_N "(cached) $ECHO_C" >&6
2709   else
2710 <  if test -n "$CXX"; then
2711 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2710 >  if test -n "$FC"; then
2711 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2712   else
2713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2714   for as_dir in $PATH
# Line 2716 | Line 2717 | do
2717    test -z "$as_dir" && as_dir=.
2718    for ac_exec_ext in '' $ac_executable_extensions; do
2719    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2720 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2720 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2721      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2722      break 2
2723    fi
# Line 2725 | Line 2726 | fi
2726  
2727   fi
2728   fi
2729 < CXX=$ac_cv_prog_CXX
2730 < if test -n "$CXX"; then
2731 <  echo "$as_me:$LINENO: result: $CXX" >&5
2732 < echo "${ECHO_T}$CXX" >&6
2729 > FC=$ac_cv_prog_FC
2730 > if test -n "$FC"; then
2731 >  echo "$as_me:$LINENO: result: $FC" >&5
2732 > echo "${ECHO_T}$FC" >&6
2733   else
2734    echo "$as_me:$LINENO: result: no" >&5
2735   echo "${ECHO_T}no" >&6
2736   fi
2737  
2738 <    test -n "$CXX" && break
2738 >    test -n "$FC" && break
2739    done
2740   fi
2741 < if test -z "$CXX"; then
2742 <  ac_ct_CXX=$CXX
2743 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2741 > if test -z "$FC"; then
2742 >  ac_ct_FC=$FC
2743 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2744   do
2745    # Extract the first word of "$ac_prog", so it can be a program name with args.
2746   set dummy $ac_prog; ac_word=$2
2747   echo "$as_me:$LINENO: checking for $ac_word" >&5
2748   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2749 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2749 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2750    echo $ECHO_N "(cached) $ECHO_C" >&6
2751   else
2752 <  if test -n "$ac_ct_CXX"; then
2753 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2752 >  if test -n "$ac_ct_FC"; then
2753 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2754   else
2755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2756   for as_dir in $PATH
# Line 2758 | Line 2759 | do
2759    test -z "$as_dir" && as_dir=.
2760    for ac_exec_ext in '' $ac_executable_extensions; do
2761    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2762 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2762 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2763      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2764      break 2
2765    fi
# Line 2767 | Line 2768 | fi
2768  
2769   fi
2770   fi
2771 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2772 < if test -n "$ac_ct_CXX"; then
2773 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2774 < echo "${ECHO_T}$ac_ct_CXX" >&6
2771 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2772 > if test -n "$ac_ct_FC"; then
2773 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2774 > echo "${ECHO_T}$ac_ct_FC" >&6
2775   else
2776    echo "$as_me:$LINENO: result: no" >&5
2777   echo "${ECHO_T}no" >&6
2778   fi
2779  
2780 <  test -n "$ac_ct_CXX" && break
2780 >  test -n "$ac_ct_FC" && break
2781   done
2781 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2782  
2783 <  CXX=$ac_ct_CXX
2783 >  FC=$ac_ct_FC
2784   fi
2785  
2786  
2787   # Provide some information about the compiler.
2788 < echo "$as_me:$LINENO:" \
2789 <     "checking for C++ compiler version" >&5
2788 > echo "$as_me:2788:" \
2789 >     "checking for Fortran compiler version" >&5
2790   ac_compiler=`set X $ac_compile; echo $2`
2791   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2792    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2803 | Line 2803 | ac_compiler=`set X $ac_compile; echo $2`
2803    ac_status=$?
2804    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2805    (exit $ac_status); }
2806 + rm -f a.out
2807  
2808 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2809 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2810 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2808 > # If we don't use `.F' as extension, the preprocessor is not run on the
2809 > # input file.  (Note that this only needs to work for GNU compilers.)
2810 > ac_save_ext=$ac_ext
2811 > ac_ext=F
2812 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2813 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2814 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2815    echo $ECHO_N "(cached) $ECHO_C" >&6
2816   else
2817    cat >conftest.$ac_ext <<_ACEOF
2818 < /* confdefs.h.  */
2814 < _ACEOF
2815 < cat confdefs.h >>conftest.$ac_ext
2816 < cat >>conftest.$ac_ext <<_ACEOF
2817 < /* end confdefs.h.  */
2818 <
2819 < int
2820 < main ()
2821 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2827 <  return 0;
2828 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2836 | Line 2831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2831    cat conftest.err >&5
2832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833    (exit $ac_status); } &&
2834 <         { ac_try='test -z "$ac_cxx_werror_flag"
2834 >         { ac_try='test -z "$ac_fc_werror_flag"
2835                           || test ! -s conftest.err'
2836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837    (eval $ac_try) 2>&5
# Line 2857 | Line 2852 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2852   ac_compiler_gnu=no
2853   fi
2854   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2855 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2855 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2856  
2857   fi
2858 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2859 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2860 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2861 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2862 < ac_save_CXXFLAGS=$CXXFLAGS
2863 < CXXFLAGS="-g"
2864 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2865 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2866 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2858 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2859 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2860 > ac_ext=$ac_save_ext
2861 > ac_test_FFLAGS=${FCFLAGS+set}
2862 > ac_save_FFLAGS=$FCFLAGS
2863 > FCFLAGS=
2864 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2865 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2866 > if test "${ac_cv_prog_fc_g+set}" = set; then
2867    echo $ECHO_N "(cached) $ECHO_C" >&6
2868   else
2869 <  cat >conftest.$ac_ext <<_ACEOF
2870 < /* confdefs.h.  */
2871 < _ACEOF
2877 < cat confdefs.h >>conftest.$ac_ext
2878 < cat >>conftest.$ac_ext <<_ACEOF
2879 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2882 < main ()
2883 < {
2884 <
2885 <  ;
2886 <  return 0;
2887 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2895 | Line 2881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2881    cat conftest.err >&5
2882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883    (exit $ac_status); } &&
2884 <         { ac_try='test -z "$ac_cxx_werror_flag"
2884 >         { ac_try='test -z "$ac_fc_werror_flag"
2885                           || test ! -s conftest.err'
2886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2887    (eval $ac_try) 2>&5
# Line 2908 | Line 2894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2894    ac_status=$?
2895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2896    (exit $ac_status); }; }; then
2897 <  ac_cv_prog_cxx_g=yes
2897 >  ac_cv_prog_fc_g=yes
2898   else
2899    echo "$as_me: failed program was:" >&5
2900   sed 's/^/| /' conftest.$ac_ext >&5
2901  
2902 < ac_cv_prog_cxx_g=no
2902 > ac_cv_prog_fc_g=no
2903   fi
2904   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2905 +
2906   fi
2907 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2908 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2909 < if test "$ac_test_CXXFLAGS" = set; then
2910 <  CXXFLAGS=$ac_save_CXXFLAGS
2911 < elif test $ac_cv_prog_cxx_g = yes; then
2912 <  if test "$GXX" = yes; then
2913 <    CXXFLAGS="-g -O2"
2907 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2908 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2909 > if test "$ac_test_FFLAGS" = set; then
2910 >  FCFLAGS=$ac_save_FFLAGS
2911 > elif test $ac_cv_prog_fc_g = yes; then
2912 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2913 >    FCFLAGS="-g -O2"
2914    else
2915 <    CXXFLAGS="-g"
2915 >    FCFLAGS="-g"
2916    fi
2917   else
2918 <  if test "$GXX" = yes; then
2919 <    CXXFLAGS="-O2"
2918 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2919 >    FCFLAGS="-O2"
2920    else
2921 <    CXXFLAGS=
2921 >    FCFLAGS=
2922    fi
2936 fi
2937 for ac_declaration in \
2938   '' \
2939   'extern "C" void std::exit (int) throw (); using std::exit;' \
2940   'extern "C" void std::exit (int); using std::exit;' \
2941   'extern "C" void exit (int) throw ();' \
2942   'extern "C" void exit (int);' \
2943   'void exit (int);'
2944 do
2945  cat >conftest.$ac_ext <<_ACEOF
2946 /* confdefs.h.  */
2947 _ACEOF
2948 cat confdefs.h >>conftest.$ac_ext
2949 cat >>conftest.$ac_ext <<_ACEOF
2950 /* end confdefs.h.  */
2951 $ac_declaration
2952 #include <stdlib.h>
2953 int
2954 main ()
2955 {
2956 exit (42);
2957  ;
2958  return 0;
2959 }
2960 _ACEOF
2961 rm -f conftest.$ac_objext
2962 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2963  (eval $ac_compile) 2>conftest.er1
2964  ac_status=$?
2965  grep -v '^ *+' conftest.er1 >conftest.err
2966  rm -f conftest.er1
2967  cat conftest.err >&5
2968  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2969  (exit $ac_status); } &&
2970         { ac_try='test -z "$ac_cxx_werror_flag"
2971                         || test ! -s conftest.err'
2972  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2973  (eval $ac_try) 2>&5
2974  ac_status=$?
2975  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2976  (exit $ac_status); }; } &&
2977         { ac_try='test -s conftest.$ac_objext'
2978  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2979  (eval $ac_try) 2>&5
2980  ac_status=$?
2981  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2982  (exit $ac_status); }; }; then
2983  :
2984 else
2985  echo "$as_me: failed program was:" >&5
2986 sed 's/^/| /' conftest.$ac_ext >&5
2987
2988 continue
2989 fi
2990 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2991  cat >conftest.$ac_ext <<_ACEOF
2992 /* confdefs.h.  */
2993 _ACEOF
2994 cat confdefs.h >>conftest.$ac_ext
2995 cat >>conftest.$ac_ext <<_ACEOF
2996 /* end confdefs.h.  */
2997 $ac_declaration
2998 int
2999 main ()
3000 {
3001 exit (42);
3002  ;
3003  return 0;
3004 }
3005 _ACEOF
3006 rm -f conftest.$ac_objext
3007 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3008  (eval $ac_compile) 2>conftest.er1
3009  ac_status=$?
3010  grep -v '^ *+' conftest.er1 >conftest.err
3011  rm -f conftest.er1
3012  cat conftest.err >&5
3013  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3014  (exit $ac_status); } &&
3015         { ac_try='test -z "$ac_cxx_werror_flag"
3016                         || test ! -s conftest.err'
3017  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3018  (eval $ac_try) 2>&5
3019  ac_status=$?
3020  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3021  (exit $ac_status); }; } &&
3022         { ac_try='test -s conftest.$ac_objext'
3023  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3024  (eval $ac_try) 2>&5
3025  ac_status=$?
3026  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3027  (exit $ac_status); }; }; then
3028  break
3029 else
3030  echo "$as_me: failed program was:" >&5
3031 sed 's/^/| /' conftest.$ac_ext >&5
3032
3033 fi
3034 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3035 done
3036 rm -f conftest*
3037 if test -n "$ac_declaration"; then
3038  echo '#ifdef __cplusplus' >>confdefs.h
3039  echo $ac_declaration      >>confdefs.h
3040  echo '#endif'             >>confdefs.h
2923   fi
2924  
2925   ac_ext=c
# Line 3045 | Line 2927 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2927   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2928   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2929   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3048
2930  
2931   ac_ext=c
2932   ac_cpp='$CPP $CPPFLAGS'
# Line 3281 | Line 3162 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3162   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3163   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3164  
3284
3165   echo "$as_me:$LINENO: checking for egrep" >&5
3166   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3167   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3297 | Line 3177 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3177   EGREP=$ac_cv_prog_egrep
3178  
3179  
3180 + echo "$as_me:$LINENO: checking whether ln -s works" >&5
3181 + echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3182 + LN_S=$as_ln_s
3183 + if test "$LN_S" = "ln -s"; then
3184 +  echo "$as_me:$LINENO: result: yes" >&5
3185 + echo "${ECHO_T}yes" >&6
3186 + else
3187 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3188 + echo "${ECHO_T}no, using $LN_S" >&6
3189 + fi
3190  
3191 < OOPSE_TEMPLATE_FLAGS=""
3192 < if test $ac_cv_cxx_compiler_gnu = no; then
3193 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3194 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3195 <  echo 'void f(){}' > conftest.cc
3196 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3197 <    echo "$as_me:$LINENO: result: yes" >&5
3191 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3192 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3193 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3194 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3196 > else
3197 >  cat >conftest.make <<\_ACEOF
3198 > all:
3199 >        @echo 'ac_maketemp="$(MAKE)"'
3200 > _ACEOF
3201 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3202 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3203 > if test -n "$ac_maketemp"; then
3204 >  eval ac_cv_prog_make_${ac_make}_set=yes
3205 > else
3206 >  eval ac_cv_prog_make_${ac_make}_set=no
3207 > fi
3208 > rm -f conftest.make
3209 > fi
3210 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3211 >  echo "$as_me:$LINENO: result: yes" >&5
3212   echo "${ECHO_T}yes" >&6
3213 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3216 < echo "${ECHO_T}no" >&6
3213 >  SET_MAKE=
3214 > else
3215 >  echo "$as_me:$LINENO: result: no" >&5
3216 > echo "${ECHO_T}no" >&6
3217 >  SET_MAKE="MAKE=${MAKE-make}"
3218 > fi
3219 >
3220 > if test -n "$ac_tool_prefix"; then
3221 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3222 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3223 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3226 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3227 > else
3228 >  if test -n "$RANLIB"; then
3229 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3230 > else
3231 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 > for as_dir in $PATH
3233 > do
3234 >  IFS=$as_save_IFS
3235 >  test -z "$as_dir" && as_dir=.
3236 >  for ac_exec_ext in '' $ac_executable_extensions; do
3237 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3239 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240 >    break 2
3241    fi
3242 <  rm -f conftest*
3243 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3244 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3245 <  echo 'void f(){}' > conftest.cc
3246 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3247 <    echo "$as_me:$LINENO: result: yes" >&5
3248 < echo "${ECHO_T}yes" >&6
3249 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3250 <  else
3251 <    echo "$as_me:$LINENO: result: no" >&5
3242 > done
3243 > done
3244 >
3245 > fi
3246 > fi
3247 > RANLIB=$ac_cv_prog_RANLIB
3248 > if test -n "$RANLIB"; then
3249 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3250 > echo "${ECHO_T}$RANLIB" >&6
3251 > else
3252 >  echo "$as_me:$LINENO: result: no" >&5
3253   echo "${ECHO_T}no" >&6
3254 + fi
3255 +
3256 + fi
3257 + if test -z "$ac_cv_prog_RANLIB"; then
3258 +  ac_ct_RANLIB=$RANLIB
3259 +  # Extract the first word of "ranlib", so it can be a program name with args.
3260 + set dummy ranlib; ac_word=$2
3261 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3262 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3263 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3264 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3265 + else
3266 +  if test -n "$ac_ct_RANLIB"; then
3267 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3268 + else
3269 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3270 + for as_dir in $PATH
3271 + do
3272 +  IFS=$as_save_IFS
3273 +  test -z "$as_dir" && as_dir=.
3274 +  for ac_exec_ext in '' $ac_executable_extensions; do
3275 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3276 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3277 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3278 +    break 2
3279    fi
3280 <  rm -f conftest*
3281 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3282 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3283 <  echo 'void f(){}' > conftest.cc
3284 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3285 <    echo "$as_me:$LINENO: result: yes" >&5
3286 < echo "${ECHO_T}yes" >&6
3287 <    OOPSE_TEMPLATE_FLAGS="-pto"
3288 <  else
3289 <    echo "$as_me:$LINENO: result: no" >&5
3280 > done
3281 > done
3282 >
3283 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284 > fi
3285 > fi
3286 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3287 > if test -n "$ac_ct_RANLIB"; then
3288 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3289 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3290 > else
3291 >  echo "$as_me:$LINENO: result: no" >&5
3292   echo "${ECHO_T}no" >&6
3293 + fi
3294 +
3295 +  RANLIB=$ac_ct_RANLIB
3296 + else
3297 +  RANLIB="$ac_cv_prog_RANLIB"
3298 + fi
3299 +
3300 +
3301 +   # Extract the first word of "perl", so it can be a program name with args.
3302 + set dummy perl; ac_word=$2
3303 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3304 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3305 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3306 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3307 + else
3308 +  case $PERLINTERP in
3309 +  [\\/]* | ?:[\\/]*)
3310 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3311 +  ;;
3312 +  *)
3313 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3314 + for as_dir in $PATH
3315 + do
3316 +  IFS=$as_save_IFS
3317 +  test -z "$as_dir" && as_dir=.
3318 +  for ac_exec_ext in '' $ac_executable_extensions; do
3319 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3320 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3321 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3322 +    break 2
3323    fi
3324 <  rm -f conftest*
3325 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3340 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3341 <  echo 'void f(){}' > conftest.cc
3342 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3343 <    echo "$as_me:$LINENO: result: yes" >&5
3344 < echo "${ECHO_T}yes" >&6
3324 > done
3325 > done
3326  
3327 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3328 +  ;;
3329 + esac
3330 + fi
3331 + PERLINTERP=$ac_cv_path_PERLINTERP
3332  
3333 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3334 <  else
3335 <    echo "$as_me:$LINENO: result: no" >&5
3333 > if test -n "$PERLINTERP"; then
3334 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3335 > echo "${ECHO_T}$PERLINTERP" >&6
3336 > else
3337 >  echo "$as_me:$LINENO: result: no" >&5
3338   echo "${ECHO_T}no" >&6
3339 + fi
3340 +
3341 +   ac_cv_path_perlinterp="$PERLINTERP"
3342 +   _sHpB='#!'
3343 +
3344 +
3345 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3346 + if test "${with_perl_shebang+set}" = set; then
3347 +  withval="$with_perl_shebang"
3348 +  opt_perl_shebang="$withval"
3349 + else
3350 +                opt_perl_shebang="not_set"
3351 + fi;
3352 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3353 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3354 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3356 + else
3357 +   case "$opt_perl_shebang" in
3358 +                      not_set  ) ax_cv_opt_perl_shebang=''
3359 +                               ;;
3360 +                         *     )
3361 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3362 +                    esac
3363 +
3364 + fi
3365 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3366 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3367 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3368 +     then
3369 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3370 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3371 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3372 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3373 +
3374 + # Automatic detection of sharpbang formula starts here
3375 +     else
3376 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3377 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3378 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3379 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3380 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3381 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3382 + else
3383 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3384 +        if test "x$_somian_kspb_perl" == x
3385 +          then _somian_ksbp_warn_empty='durnit'
3386 +          else
3387 +          case "A$_somian_kspb_perl" in
3388 +                 A#!*perl* )
3389 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3390 +                        ;;
3391 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3392 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3393 +          esac
3394 +        fi
3395 +
3396 + fi
3397 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3398 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3399 + # The above prints Checking ... result message to user.
3400 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3401 +
3402 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3403 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3404 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3405 +    fi
3406 + # Inform user after printing result value
3407 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3408 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3409 + echo "$as_me: Maybe Not good -" >&6;}
3410 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3411 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3412 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3413 + echo "$as_me: OK Good result - " >&6;}
3414 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3415 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3416 +    fi
3417    fi
3418 +
3419 + # Find a good install program.  We prefer a C program (faster),
3420 + # so one script is as good as another.  But avoid the broken or
3421 + # incompatible versions:
3422 + # SysV /etc/install, /usr/sbin/install
3423 + # SunOS /usr/etc/install
3424 + # IRIX /sbin/install
3425 + # AIX /bin/install
3426 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3427 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3428 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3429 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3430 + # OS/2's system install, which has a completely different semantic
3431 + # ./install, which can be erroneously created by make from ./install.sh.
3432 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3433 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3434 + if test -z "$INSTALL"; then
3435 + if test "${ac_cv_path_install+set}" = set; then
3436 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3437 + else
3438 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3439 + for as_dir in $PATH
3440 + do
3441 +  IFS=$as_save_IFS
3442 +  test -z "$as_dir" && as_dir=.
3443 +  # Account for people who put trailing slashes in PATH elements.
3444 + case $as_dir/ in
3445 +  ./ | .// | /cC/* | \
3446 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3447 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3448 +  /usr/ucb/* ) ;;
3449 +  *)
3450 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3451 +    # Don't use installbsd from OSF since it installs stuff as root
3452 +    # by default.
3453 +    for ac_prog in ginstall scoinst install; do
3454 +      for ac_exec_ext in '' $ac_executable_extensions; do
3455 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3456 +          if test $ac_prog = install &&
3457 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3458 +            # AIX install.  It has an incompatible calling convention.
3459 +            :
3460 +          elif test $ac_prog = install &&
3461 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3462 +            # program-specific install script used by HP pwplus--don't use.
3463 +            :
3464 +          else
3465 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3466 +            break 3
3467 +          fi
3468 +        fi
3469 +      done
3470 +    done
3471 +    ;;
3472 + esac
3473 + done
3474 +
3475 +
3476   fi
3477 +  if test "${ac_cv_path_install+set}" = set; then
3478 +    INSTALL=$ac_cv_path_install
3479 +  else
3480 +    # As a last resort, use the slow shell script.  We don't cache a
3481 +    # path for INSTALL within a source directory, because that will
3482 +    # break other packages using the cache if that directory is
3483 +    # removed, or if the path is relative.
3484 +    INSTALL=$ac_install_sh
3485 +  fi
3486 + fi
3487 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3488 + echo "${ECHO_T}$INSTALL" >&6
3489  
3490 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3491 + # It thinks the first close brace ends the variable substitution.
3492 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3493  
3494 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3495  
3496 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3497  
3498 < ac_ext=f90
3499 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3500 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3501 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3502 < if test -n "$ac_tool_prefix"; then
3503 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3504 <  do
3364 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3365 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3498 > case "x$INSTALL" in
3499 >   x/*) ;;
3500 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3501 > esac
3502 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3503 > # Extract the first word of "ar", so it can be a program name with args.
3504 > set dummy ar; ac_word=$2
3505   echo "$as_me:$LINENO: checking for $ac_word" >&5
3506   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3507 < if test "${ac_cv_prog_F90+set}" = set; then
3507 > if test "${ac_cv_prog_AR+set}" = set; then
3508    echo $ECHO_N "(cached) $ECHO_C" >&6
3509   else
3510 <  if test -n "$F90"; then
3511 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3510 >  if test -n "$AR"; then
3511 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3512   else
3513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3514   for as_dir in $PATH
# Line 3378 | Line 3517 | do
3517    test -z "$as_dir" && as_dir=.
3518    for ac_exec_ext in '' $ac_executable_extensions; do
3519    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3520 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3520 >    ac_cv_prog_AR="ar"
3521      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3522      break 2
3523    fi
3524   done
3525   done
3526  
3527 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3528   fi
3529   fi
3530 < F90=$ac_cv_prog_F90
3531 < if test -n "$F90"; then
3532 <  echo "$as_me:$LINENO: result: $F90" >&5
3533 < echo "${ECHO_T}$F90" >&6
3530 > AR=$ac_cv_prog_AR
3531 > if test -n "$AR"; then
3532 >  echo "$as_me:$LINENO: result: $AR" >&5
3533 > echo "${ECHO_T}$AR" >&6
3534   else
3535    echo "$as_me:$LINENO: result: no" >&5
3536   echo "${ECHO_T}no" >&6
3537   fi
3538  
3539 <    test -n "$F90" && break
3540 <  done
3539 > if test "$AR" = "NONE"; then
3540 >  cat >confcache <<\_ACEOF
3541 > # This file is a shell script that caches the results of configure
3542 > # tests run on this system so they can be shared between configure
3543 > # scripts and configure runs, see configure's option --config-cache.
3544 > # It is not useful on other systems.  If it contains results you don't
3545 > # want to keep, you may remove or edit it.
3546 > #
3547 > # config.status only pays attention to the cache file if you give it
3548 > # the --recheck option to rerun configure.
3549 > #
3550 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3551 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3552 > # following values.
3553 >
3554 > _ACEOF
3555 >
3556 > # The following way of writing the cache mishandles newlines in values,
3557 > # but we know of no workaround that is simple, portable, and efficient.
3558 > # So, don't put newlines in cache variables' values.
3559 > # Ultrix sh set writes to stderr and can't be redirected directly,
3560 > # and sets the high bit in the cache file unless we assign to the vars.
3561 > {
3562 >  (set) 2>&1 |
3563 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3564 >    *ac_space=\ *)
3565 >      # `set' does not quote correctly, so add quotes (double-quote
3566 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3567 >      sed -n \
3568 >        "s/'/'\\\\''/g;
3569 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3570 >      ;;
3571 >    *)
3572 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3573 >      sed -n \
3574 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3575 >      ;;
3576 >    esac;
3577 > } |
3578 >  sed '
3579 >     t clear
3580 >     : clear
3581 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3582 >     t end
3583 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3584 >     : end' >>confcache
3585 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3586 >  if test -w $cache_file; then
3587 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3588 >    cat confcache >$cache_file
3589 >  else
3590 >    echo "not updating unwritable cache $cache_file"
3591 >  fi
3592   fi
3593 < if test -z "$F90"; then
3594 <  ac_ct_F90=$F90
3595 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3596 < do
3597 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3407 < set dummy $ac_prog; ac_word=$2
3593 > rm -f confcache
3594 >  exit 1
3595 > fi
3596 > # Extract the first word of "ps", so it can be a program name with args.
3597 > set dummy ps; ac_word=$2
3598   echo "$as_me:$LINENO: checking for $ac_word" >&5
3599   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3600 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3600 > if test "${ac_cv_path_PS+set}" = set; then
3601    echo $ECHO_N "(cached) $ECHO_C" >&6
3602   else
3603 <  if test -n "$ac_ct_F90"; then
3604 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3605 < else
3606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3603 >  case $PS in
3604 >  [\\/]* | ?:[\\/]*)
3605 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3606 >  ;;
3607 >  *)
3608 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3609   for as_dir in $PATH
3610   do
3611    IFS=$as_save_IFS
3612    test -z "$as_dir" && as_dir=.
3613    for ac_exec_ext in '' $ac_executable_extensions; do
3614    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3615 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3615 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3616      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3617      break 2
3618    fi
3619   done
3620   done
3621  
3622 +  ;;
3623 + esac
3624   fi
3625 < fi
3626 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3627 < if test -n "$ac_ct_F90"; then
3628 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3629 < echo "${ECHO_T}$ac_ct_F90" >&6
3625 > PS=$ac_cv_path_PS
3626 >
3627 > if test -n "$PS"; then
3628 >  echo "$as_me:$LINENO: result: $PS" >&5
3629 > echo "${ECHO_T}$PS" >&6
3630   else
3631    echo "$as_me:$LINENO: result: no" >&5
3632   echo "${ECHO_T}no" >&6
3633   fi
3634  
3635 <  test -n "$ac_ct_F90" && break
3636 < done
3635 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3636 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3637 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3639 > else
3640  
3641 <  F90=$ac_ct_F90
3641 >        if $PS ax -o rss > /dev/null 2>&1; then
3642 >                ac_cv_prog_ps_ax=yes
3643 >        else
3644 >                ac_cv_prog_ps_ax=no
3645 >        fi
3646 >        if $PS -ef -o rss > /dev/null 2>&1; then
3647 >                ac_cv_prog_ps_ef=yes
3648 >        else
3649 >                ac_cv_prog_ps_ef=no
3650 >        fi
3651 >        if test "$ac_cv_prog_ps_ax" = yes; then
3652 >                ac_cv_prog_ps_syntax=BSD
3653 >        else
3654 >                if test "$ac_cv_prog_ps_ef" = yes; then
3655 >                        ac_cv_prog_ps_syntax=POSIX
3656 >                else
3657 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3658 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3659 >   { (exit 1); exit 1; }; }
3660 >                fi
3661 >        fi
3662 >
3663   fi
3664 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3665 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3666  
3667 + cat >>confdefs.h <<_ACEOF
3668 + #define PSCOMMAND $PS
3669 + _ACEOF
3670  
3671 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3672 < # input file.
3673 < ac_save_ext=$ac_ext
3674 < ac_ext=F90
3675 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3676 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3454 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3455 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3671 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3672 >
3673 > cat >>confdefs.h <<\_ACEOF
3674 > #define PSTYPE_IS_BSD 1
3675 > _ACEOF
3676 >
3677   else
3678 <  cat >conftest.$ac_ext <<_ACEOF
3678 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679  
3680 < program main
3680 > cat >>confdefs.h <<\_ACEOF
3681 > #define PSTYPE_IS_POSIX 1
3682 > _ACEOF
3683  
3684 < #ifndef __GNUC__
3685 <       choke me
3686 < #endif
3684 >   else
3685 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3686 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3687 >   { (exit 1); exit 1; }; }
3688 >   fi
3689 > fi
3690  
3691 < end program main
3691 > ac_ext=${FC_SRCEXT-f}
3692 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3693 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3694 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3695  
3696 +
3697 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3698 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3699 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3700 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3701 + else
3702 +  ac_ext=F90
3703 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3704 + FCFLAGS_SRCEXT=""
3705 + ac_cv_fc_srcext_F90=unknown
3706 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3707 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3708 +  cat >conftest.$ac_ext <<_ACEOF
3709 +      program main
3710 +
3711 +      end
3712   _ACEOF
3713   rm -f conftest.$ac_objext
3714   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3474 | Line 3719 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3719    cat conftest.err >&5
3720    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3721    (exit $ac_status); } &&
3722 <         { ac_try='test -z "$ac_f90_werror_flag"
3722 >         { ac_try='test -z "$ac_fc_werror_flag"
3723                           || test ! -s conftest.err'
3724    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3725    (eval $ac_try) 2>&5
# Line 3487 | Line 3732 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3732    ac_status=$?
3733    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3734    (exit $ac_status); }; }; then
3735 <  ac_compiler_gnu=yes
3735 >  ac_cv_fc_srcext_F90=$ac_flag; break
3736   else
3737    echo "$as_me: failed program was:" >&5
3738   sed 's/^/| /' conftest.$ac_ext >&5
3739  
3495 ac_compiler_gnu=no
3740   fi
3741   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3742 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3742 > done
3743 > rm -f conftest.$ac_objext conftest.F90
3744 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3745  
3746   fi
3747 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3748 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3749 < ac_ext=$ac_save_ext
3750 < G95=`test $ac_compiler_gnu = yes && echo yes`
3751 < ac_ext=c
3752 < ac_cpp='$CPP $CPPFLAGS'
3753 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3754 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3747 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3748 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3749 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3750 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3751 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3752 >   { (exit 1); exit 1; }; }
3753 > else
3754 >  FC_SRCEXT=F90
3755 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3756 >    FCFLAGS_SRCEXT=""
3757 >    FCFLAGS_F90=""
3758 >  else
3759 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3760 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3761 >  fi
3762  
3763  
3764 + fi
3765  
3766  
3767  
3768 +
3769 +
3770   # Try to determine native compiler flags that allow us to use F90 suffix
3771   # for preprocessed f90 source.
3772  
# Line 3519 | Line 3774 | if test "$ac_test_PREPFLAG" != "set"; then
3774    PREPFLAG=""
3775    case "${host_cpu}-${host_os}" in
3776  
3777 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3777 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3778                      PREPFLAG="-fpp1 "
3779                  fi;;
3780 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3780 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3781                      PREPFLAG="-qsuffix=cpp=F90 "
3782                  fi;;
3783    *darwin*)
3784 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3784 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3785                  PREPFLAG="-qsuffix=cpp=F90 "
3786          fi;;
3787    esac
# Line 3541 | Line 3796 | echo $ECHO_N "checking to make sure F90 preprocessor f
3796   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3797  
3798  
3799 <  ac_ext=f90
3800 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3801 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3802 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3799 >  ac_ext=${FC_SRCEXT-f}
3800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3803  
3804    ac_save_ext=$ac_ext
3805    ac_ext=F90
3806 <  ac_save_F90FLAGS=$F90FLAGS
3806 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3807  
3808    if test "$PREPFLAG"; then
3809 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3809 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3810   fi
3811  
3812      cat >conftest.$ac_ext <<_ACEOF
3813  
3814  
3815 < program main
3561 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3565
3566 end program main
3567
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3575 | Line 3827 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827    cat conftest.err >&5
3828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3829    (exit $ac_status); } &&
3830 <         { ac_try='test -z "$ac_f90_werror_flag"
3830 >         { ac_try='test -z "$ac_fc_werror_flag"
3831                           || test ! -s conftest.err'
3832    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3833    (eval $ac_try) 2>&5
# Line 3597 | Line 3849 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3849   fi
3850   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3851  
3852 <  F90FLAGS=$ac_save_F90FLAGS
3852 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3853    ac_ext=$ac_save_ext
3854 <  ac_ext=c
3855 < ac_cpp='$CPP $CPPFLAGS'
3856 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3857 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3606 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3854 >  ac_ext=${FC_SRCEXT-f}
3855 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3856 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3857 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3858  
3859  
3860    if test "$prepflagworks" = 1; then
3861      echo "$as_me:$LINENO: result: yes" >&5
3862   echo "${ECHO_T}yes" >&6
3863 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3864  
3865    else
3866      echo "$as_me:$LINENO: result: no" >&5
# Line 3630 | Line 3882 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3882    PREPDEFFLAG=""
3883    case "${host_cpu}-${host_os}" in
3884  
3885 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3885 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3886                      PREPDEFFLAG=" "
3887                  fi;;
3888 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3888 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3889                      PREPDEFFLAG="-WF,"
3890                  fi;;
3891    *darwin*)
3892 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3892 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3893                  PREPDEFFLAG="-WF,"
3894          fi;;
3895    esac
# Line 3652 | Line 3904 | echo $ECHO_N "checking to make sure F90 preprocessor d
3904   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3905  
3906  
3907 <  ac_ext=f90
3908 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3909 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3907 >  ac_ext=${FC_SRCEXT-f}
3908 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3909 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3910 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3911  
3912    ac_save_ext=$ac_ext
3913    ac_ext=F90
3914 <  ac_save_F90FLAGS=$F90FLAGS
3914 >  ac_save_FCFLAGS=$FCFLAGS
3915  
3916    if test "$PREPDEFFLAG"; then
3917 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3917 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3918   fi
3919  
3920      cat >conftest.$ac_ext <<_ACEOF
3921  
3922  
3923 < program main
3672 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3680
3681 end program main
3682
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3690 | Line 3939 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3939    cat conftest.err >&5
3940    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3941    (exit $ac_status); } &&
3942 <         { ac_try='test -z "$ac_f90_werror_flag"
3942 >         { ac_try='test -z "$ac_fc_werror_flag"
3943                           || test ! -s conftest.err'
3944    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3945    (eval $ac_try) 2>&5
# Line 3712 | Line 3961 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3961   fi
3962   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3963  
3964 <  F90FLAGS=$ac_save_F90FLAGS
3964 >  FCFLAGS=$ac_save_FCFLAGS
3965    ac_ext=$ac_save_ext
3966 <  ac_ext=c
3967 < ac_cpp='$CPP $CPPFLAGS'
3968 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3969 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3721 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3966 >  ac_ext=${FC_SRCEXT-f}
3967 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3968 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3969 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3970  
3971  
3724
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3735 | Line 3982 | fi
3982    fi
3983   fi
3984  
3985 < ac_ext=f90
3986 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3987 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3988 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3989 <
3990 <
3991 <
3745 < ac_ext=f90
3746 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3747 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3748 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3749 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3750 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3751 < if test "${ac_cv_prog_f90_v+set}" = set; then
3985 > ac_ext=${FC_SRCEXT-f}
3986 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3987 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3988 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3989 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3990 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3991 > if test "${ac_cv_prog_fc_v+set}" = set; then
3992    echo $ECHO_N "(cached) $ECHO_C" >&6
3993   else
3994 +  cat >conftest.$ac_ext <<_ACEOF
3995 +      program main
3996  
3997 < cat >conftest.$ac_ext <<_ACEOF
3756 <
3757 < program main
3758 <
3759 <
3760 < end program main
3761 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3769 | Line 4005 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4005    cat conftest.err >&5
4006    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007    (exit $ac_status); } &&
4008 <         { ac_try='test -z "$ac_f90_werror_flag"
4008 >         { ac_try='test -z "$ac_fc_werror_flag"
4009                           || test ! -s conftest.err'
4010    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4011    (eval $ac_try) 2>&5
# Line 3782 | Line 4018 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018    ac_status=$?
4019    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020    (exit $ac_status); }; }; then
4021 <  ac_cv_prog_f90_v=
4021 >  ac_cv_prog_fc_v=
4022   # Try some options frequently used verbose output
4023   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4024 <  ac_ext=f90
4025 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3790 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3791 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3794 <
3795 < program main
3796 <
3797 <
3798 < end program main
3799 <
4027 >      end
4028   _ACEOF
4029  
4030   # Compile and link our simple test program by passing a flag (argument
4031 < # 1 to this macro) to the Fortran 90 compiler in order to get
4032 < # "verbose" output that we can then parse for the Fortran 90 linker
4031 > # 1 to this macro) to the Fortran compiler in order to get
4032 > # "verbose" output that we can then parse for the Fortran linker
4033   # flags.
4034 < ac_save_F90FLAGS=$F90FLAGS
4035 < F90FLAGS="$F90FLAGS $ac_verb"
4034 > ac_save_FFLAGS=$FCFLAGS
4035 > FCFLAGS="$FCFLAGS $ac_verb"
4036 > (eval echo $as_me:4036: \"$ac_link\") >&5
4037 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4038 > echo "$ac_fc_v_output" >&5
4039 > FCFLAGS=$ac_save_FFLAGS
4040  
4041 < (eval echo $as_me:3809: \"$ac_link\") >&5
3810 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3811 < echo "$ac_f90_v_output" >&5
3812 < F90FLAGS=$ac_save_F90FLAGS
4041 > rm -f conftest*
4042  
4043 < rm -f conftest.*
4044 < ac_ext=f90
4045 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4046 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4047 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4043 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4044 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4045 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4046 > ac_fc_v_output="`echo $ac_fc_v_output |
4047 >        grep 'LPATH is:' |
4048 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4049  
4050 < # If we are using xlf then replace all the commas with spaces.
4051 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4052 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4053 < fi
4050 > case $ac_fc_v_output in
4051 >  # If we are using xlf then replace all the commas with spaces.
4052 >  *xlfentry*)
4053 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4054  
4055 < # If we are using Cray Fortran then delete quotes.
4056 < # Use "\"" instead of '"' for font-lock-mode.
4057 < # FIXME: a more general fix for quoted arguments with spaces?
4058 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4059 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4060 < fi
4055 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4056 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4057 >  *mGLOB_options_string*)
4058 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4059 >
4060 >  # If we are using Cray Fortran then delete quotes.
4061 >  # Use "\"" instead of '"' for font-lock-mode.
4062 >  # FIXME: a more general fix for quoted arguments with spaces?
4063 >  *cft90*)
4064 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4065 > esac
4066 >
4067 >
4068    # look for -l* and *.a constructs in the output
4069 <  for ac_arg in $ac_f90_v_output; do
4069 >  for ac_arg in $ac_fc_v_output; do
4070       case $ac_arg in
4071          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4072 <          ac_cv_prog_f90_v=$ac_verb
4072 >          ac_cv_prog_fc_v=$ac_verb
4073            break 2 ;;
4074       esac
4075    done
4076   done
4077 < if test -z "$ac_cv_prog_f90_v"; then
4078 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4079 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4077 > if test -z "$ac_cv_prog_fc_v"; then
4078 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4079 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4080   fi
4081   else
4082    echo "$as_me: failed program was:" >&5
# Line 3851 | Line 4088 | fi
4088   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089  
4090   fi
4091 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4092 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4093 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4094 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4095 < if test "${ac_cv_flibs+set}" = set; then
4091 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4092 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4093 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4094 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4095 > if test "${ac_cv_fc_libs+set}" = set; then
4096    echo $ECHO_N "(cached) $ECHO_C" >&6
4097   else
4098 <  if test "x$F90LIBS" != "x"; then
4099 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4098 >  if test "x$FCLIBS" != "x"; then
4099 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4100   else
4101  
3865 ac_ext=f90
3866 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3867 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3868 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3869
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3873 <
3874 <
3875 < end program main
3876 <
4105 >      end
4106   _ACEOF
4107  
4108   # Compile and link our simple test program by passing a flag (argument
4109 < # 1 to this macro) to the Fortran 90 compiler in order to get
4110 < # "verbose" output that we can then parse for the Fortran 90 linker
4109 > # 1 to this macro) to the Fortran compiler in order to get
4110 > # "verbose" output that we can then parse for the Fortran linker
4111   # flags.
4112 < ac_save_F90FLAGS=$F90FLAGS
4113 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4114 <
4115 < (eval echo $as_me:3886: \"$ac_link\") >&5
4116 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4117 < echo "$ac_f90_v_output" >&5
4118 < F90FLAGS=$ac_save_F90FLAGS
4119 <
4120 < rm -f conftest.*
4121 < ac_ext=f90
4122 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4123 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4124 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4125 <
4126 < # If we are using xlf then replace all the commas with spaces.
4127 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4128 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4129 < fi
4130 <
4131 < # If we are using Cray Fortran then delete quotes.
4132 < # Use "\"" instead of '"' for font-lock-mode.
4133 < # FIXME: a more general fix for quoted arguments with spaces?
4134 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4135 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4136 < fi
4137 <
4138 < ac_cv_f90libs=
4139 <
4140 < # Save positional arguments (if any)
4141 < ac_save_positional="$@"
4142 <
4143 < set X $ac_f90_v_output
4144 < while test $# != 1; do
4145 <  shift
4146 <  ac_arg=$1
4147 <  case $ac_arg in
4148 <        [\\/]*.a | ?:[\\/]*.a)
4149 <            ac_exists=false
4150 <  for ac_i in $ac_cv_f90libs; do
4151 <    if test x"$ac_arg" = x"$ac_i"; then
4152 <      ac_exists=true
4153 <      break
4154 <    fi
4155 <  done
4156 <
4157 <  if test x"$ac_exists" = xtrue; then
4158 <  :
4159 < else
4160 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4161 < fi
4162 <
4163 <          ;;
4164 <        -bI:*)
4165 <            ac_exists=false
4166 <  for ac_i in $ac_cv_f90libs; do
4167 <    if test x"$ac_arg" = x"$ac_i"; then
4168 <      ac_exists=true
4169 <      break
4170 <    fi
4171 <  done
4172 <
4173 <  if test x"$ac_exists" = xtrue; then
4174 <  :
4175 < else
4176 <  if test "$ac_compiler_gnu" = yes; then
4177 <  for ac_link_opt in $ac_arg; do
4178 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4179 <  done
4180 < else
4181 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4182 < fi
4183 < fi
4184 <
4185 <          ;;
4186 <          # Ignore these flags.
4187 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4188 <          ;;
4189 <        -lkernel32)
4190 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4191 <          ;;
4192 <        -[LRuY])
4193 <          # These flags, when seen by themselves, take an argument.
4194 <          # We remove the space between option and argument and re-iterate
4195 <          # unless we find an empty arg or a new option (starting with -)
4196 <          case $2 in
4197 <             "" | -*);;
4198 <             *)
4199 <                ac_arg="$ac_arg$2"
4200 <
4201 <                shift; shift
4202 <                set X $ac_arg "$@"
4203 <                ;;
4204 <          esac
4205 <          ;;
4206 <        -YP,*)
4207 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4208 <              ac_exists=false
4209 <  for ac_i in $ac_cv_f90libs; do
4210 <    if test x"$ac_j" = x"$ac_i"; then
4211 <      ac_exists=true
4212 <      break
4213 <    fi
4214 <  done
4215 <
4216 <  if test x"$ac_exists" = xtrue; then
4217 <  :
4218 < else
4219 <  ac_arg="$ac_arg $ac_j"
4220 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4221 < fi
4222 <
4223 <          done
4224 <          ;;
4225 <        -[lLR]*)
4226 <            ac_exists=false
4227 <  for ac_i in $ac_cv_f90libs; do
4228 <    if test x"$ac_arg" = x"$ac_i"; then
4229 <      ac_exists=true
4230 <      break
4231 <    fi
4232 <  done
4233 <
4234 <  if test x"$ac_exists" = xtrue; then
4235 <  :
4236 < else
4237 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4238 < fi
4239 <
4240 <          ;;
4241 <          # Ignore everything else.
4242 <  esac
4243 < done
4244 < # restore positional arguments
4245 < set X $ac_save_positional; shift
4246 <
4247 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
4248 < # then we insist that the "run path" must be an absolute path (i.e. it
4249 < # must begin with a "/").
4250 < case `(uname -sr) 2>/dev/null` in
4251 <   "SunOS 5"*)
4252 <      ac_ld_run_path=`echo $ac_f90_v_output |
4253 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4254 <      test "x$ac_ld_run_path" != x &&
4255 <
4256 <        if test "$ac_compiler_gnu" = yes; then
4257 <  for ac_link_opt in $ac_ld_run_path; do
4258 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4259 <  done
4260 < else
4261 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4262 < fi
4263 <      ;;
4264 < esac
4265 < fi # test "x$F90LIBS" = "x"
4266 <
4267 < fi
4268 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4269 < echo "${ECHO_T}$ac_cv_flibs" >&6
4270 < F90LIBS="$ac_cv_f90libs"
4271 <
4272 < ac_ext=f90
4273 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4274 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4275 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4276 <
4277 <
4278 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4279 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4280 < if test "${ac_cv_f90_mangling+set}" = set; then
4281 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4282 < else
4283 <  ac_ext=f90
4284 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4285 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4286 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4287 < cat >conftest.$ac_ext <<_ACEOF
4288 < subroutine foobar()
4289 < return
4290 < end
4291 < subroutine foo_bar()
4292 < return
4293 < end
4294 < _ACEOF
4295 < rm -f conftest.$ac_objext
4296 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4297 <  (eval $ac_compile) 2>conftest.er1
4298 <  ac_status=$?
4299 <  grep -v '^ *+' conftest.er1 >conftest.err
4300 <  rm -f conftest.er1
4301 <  cat conftest.err >&5
4302 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4303 <  (exit $ac_status); } &&
4304 <         { ac_try='test -z "$ac_f90_werror_flag"
4305 <                         || test ! -s conftest.err'
4306 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4307 <  (eval $ac_try) 2>&5
4308 <  ac_status=$?
4309 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4310 <  (exit $ac_status); }; } &&
4311 <         { ac_try='test -s conftest.$ac_objext'
4312 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4313 <  (eval $ac_try) 2>&5
4314 <  ac_status=$?
4315 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4316 <  (exit $ac_status); }; }; then
4317 <  mv conftest.$ac_objext cf90_test.$ac_objext
4318 <
4319 <  ac_ext=c
4320 < ac_cpp='$CPP $CPPFLAGS'
4321 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4322 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4323 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4324 <
4325 <  ac_save_LIBS=$LIBS
4326 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4327 <
4328 <  ac_success=no
4329 <  for ac_foobar in foobar FOOBAR; do
4330 <    for ac_underscore in "" "_"; do
4331 <      ac_func="$ac_foobar$ac_underscore"
4332 <      cat >conftest.$ac_ext <<_ACEOF
4333 < /* confdefs.h.  */
4334 < _ACEOF
4335 < cat confdefs.h >>conftest.$ac_ext
4336 < cat >>conftest.$ac_ext <<_ACEOF
4337 < /* end confdefs.h.  */
4338 <
4339 < /* Override any gcc2 internal prototype to avoid an error.  */
4340 < #ifdef __cplusplus
4341 < extern "C"
4342 < #endif
4343 < /* We use char because int might match the return type of a gcc2
4344 <   builtin and then its argument prototype would still apply.  */
4345 < char $ac_func ();
4346 < int
4347 < main ()
4348 < {
4349 < $ac_func ();
4350 <  ;
4351 <  return 0;
4352 < }
4353 < _ACEOF
4354 < rm -f conftest.$ac_objext conftest$ac_exeext
4355 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4356 <  (eval $ac_link) 2>conftest.er1
4357 <  ac_status=$?
4358 <  grep -v '^ *+' conftest.er1 >conftest.err
4359 <  rm -f conftest.er1
4360 <  cat conftest.err >&5
4361 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4362 <  (exit $ac_status); } &&
4363 <         { ac_try='test -z "$ac_c_werror_flag"
4364 <                         || test ! -s conftest.err'
4365 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4366 <  (eval $ac_try) 2>&5
4367 <  ac_status=$?
4368 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4369 <  (exit $ac_status); }; } &&
4370 <         { ac_try='test -s conftest$ac_exeext'
4371 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4372 <  (eval $ac_try) 2>&5
4373 <  ac_status=$?
4374 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4375 <  (exit $ac_status); }; }; then
4376 <  ac_success=yes; break 2
4377 < else
4378 <  echo "$as_me: failed program was:" >&5
4379 < sed 's/^/| /' conftest.$ac_ext >&5
4380 <
4381 < fi
4382 < rm -f conftest.err conftest.$ac_objext \
4383 <      conftest$ac_exeext conftest.$ac_ext
4384 <    done
4385 <  done
4386 <
4387 <  if test "$ac_success" = "yes"; then
4388 <     case $ac_foobar in
4389 <        foobar)
4390 <           ac_case=lower
4391 <           ac_foo_bar=foo_bar
4392 <           ;;
4393 <        FOOBAR)
4394 <           ac_case=upper
4395 <           ac_foo_bar=FOO_BAR
4396 <           ;;
4397 <     esac
4398 <
4399 <     ac_success_extra=no
4400 <     for ac_extra in "" "_"; do
4401 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4402 <
4403 <        cat >conftest.$ac_ext <<_ACEOF
4404 < /* confdefs.h.  */
4405 < _ACEOF
4406 < cat confdefs.h >>conftest.$ac_ext
4407 < cat >>conftest.$ac_ext <<_ACEOF
4408 < /* end confdefs.h.  */
4409 <
4410 < /* Override any gcc2 internal prototype to avoid an error.  */
4411 < #ifdef __cplusplus
4412 < extern "C"
4413 < #endif
4414 < /* We use char because int might match the return type of a gcc2
4415 <   builtin and then its argument prototype would still apply.  */
4416 < char $ac_func ();
4417 < int
4418 < main ()
4419 < {
4420 < $ac_func ();
4421 <  ;
4422 <  return 0;
4423 < }
4424 < _ACEOF
4425 < rm -f conftest.$ac_objext conftest$ac_exeext
4426 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4427 <  (eval $ac_link) 2>conftest.er1
4428 <  ac_status=$?
4429 <  grep -v '^ *+' conftest.er1 >conftest.err
4430 <  rm -f conftest.er1
4431 <  cat conftest.err >&5
4432 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4433 <  (exit $ac_status); } &&
4434 <         { ac_try='test -z "$ac_c_werror_flag"
4435 <                         || test ! -s conftest.err'
4436 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4437 <  (eval $ac_try) 2>&5
4438 <  ac_status=$?
4439 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4440 <  (exit $ac_status); }; } &&
4441 <         { ac_try='test -s conftest$ac_exeext'
4442 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4443 <  (eval $ac_try) 2>&5
4444 <  ac_status=$?
4445 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4446 <  (exit $ac_status); }; }; then
4447 <  ac_success_extra=yes; break
4448 < else
4449 <  echo "$as_me: failed program was:" >&5
4450 < sed 's/^/| /' conftest.$ac_ext >&5
4451 <
4452 < fi
4453 < rm -f conftest.err conftest.$ac_objext \
4454 <      conftest$ac_exeext conftest.$ac_ext
4455 <     done
4456 <
4457 <     if test "$ac_success_extra" = "yes"; then
4458 <        ac_cv_f90_mangling="$ac_case case"
4459 <        if test -z "$ac_underscore"; then
4460 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4461 <        else
4462 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4463 <
4464 <        fi
4465 <        if test -z "$ac_extra"; then
4466 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4467 <        else
4468 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4469 <        fi
4470 <      else
4471 <        ac_cv_f90_mangling="unknown"
4472 <      fi
4473 <  else
4474 <     ac_cv_f90_mangling="unknown"
4475 <
4476 <  fi
4477 <
4478 <  LIBS=$ac_save_LIBS
4479 <  ac_ext=f90
4480 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4481 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4482 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4483 <  rm -f cf90_test* conftest*
4484 < else
4485 <  echo "$as_me: failed program was:" >&5
4486 < sed 's/^/| /' conftest.$ac_ext >&5
4487 <
4488 < fi
4489 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4490 < ac_ext=f90
4491 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4492 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4493 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4494 <
4495 < fi
4496 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4497 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4498 <
4499 <
4500 <
4501 < case $ac_cv_f90_mangling in
4502 <  "lower case, no underscore, no extra underscore")
4503 <          cat >>confdefs.h <<\_ACEOF
4504 < #define F90_FUNC(name,NAME) name
4505 < _ACEOF
4506 <
4507 <          cat >>confdefs.h <<\_ACEOF
4508 < #define F90_FUNC_(name,NAME) name
4509 < _ACEOF
4510 < ;;
4511 <  "lower case, no underscore, extra underscore")
4512 <          cat >>confdefs.h <<\_ACEOF
4513 < #define F90_FUNC(name,NAME) name
4514 < _ACEOF
4515 <
4516 <          cat >>confdefs.h <<\_ACEOF
4517 < #define F90_FUNC_(name,NAME) name ## _
4518 < _ACEOF
4519 < ;;
4520 <  "lower case, underscore, no extra underscore")
4521 <          cat >>confdefs.h <<\_ACEOF
4522 < #define F90_FUNC(name,NAME) name ## _
4523 < _ACEOF
4524 <
4525 <          cat >>confdefs.h <<\_ACEOF
4526 < #define F90_FUNC_(name,NAME) name ## _
4527 < _ACEOF
4528 < ;;
4529 <  "lower case, underscore, extra underscore")
4530 <          cat >>confdefs.h <<\_ACEOF
4531 < #define F90_FUNC(name,NAME) name ## _
4532 < _ACEOF
4533 <
4534 <          cat >>confdefs.h <<\_ACEOF
4535 < #define F90_FUNC_(name,NAME) name ## __
4536 < _ACEOF
4537 < ;;
4538 <  "upper case, no underscore, no extra underscore")
4539 <          cat >>confdefs.h <<\_ACEOF
4540 < #define F90_FUNC(name,NAME) NAME
4541 < _ACEOF
4542 <
4543 <          cat >>confdefs.h <<\_ACEOF
4544 < #define F90_FUNC_(name,NAME) NAME
4545 < _ACEOF
4546 < ;;
4547 <  "upper case, no underscore, extra underscore")
4548 <          cat >>confdefs.h <<\_ACEOF
4549 < #define F90_FUNC(name,NAME) NAME
4550 < _ACEOF
4551 <
4552 <          cat >>confdefs.h <<\_ACEOF
4553 < #define F90_FUNC_(name,NAME) NAME ## _
4554 < _ACEOF
4555 < ;;
4556 <  "upper case, underscore, no extra underscore")
4557 <          cat >>confdefs.h <<\_ACEOF
4558 < #define F90_FUNC(name,NAME) NAME ## _
4559 < _ACEOF
4560 <
4561 <          cat >>confdefs.h <<\_ACEOF
4562 < #define F90_FUNC_(name,NAME) NAME ## _
4563 < _ACEOF
4564 < ;;
4565 <  "upper case, underscore, extra underscore")
4566 <          cat >>confdefs.h <<\_ACEOF
4567 < #define F90_FUNC(name,NAME) NAME ## _
4568 < _ACEOF
4569 <
4570 <          cat >>confdefs.h <<\_ACEOF
4571 < #define F90_FUNC_(name,NAME) NAME ## __
4572 < _ACEOF
4573 < ;;
4574 <  *)
4575 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4576 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4577 <          ;;
4578 < esac
4579 <
4580 <
4581 <
4582 <
4583 <
4584 < echo "$as_me:$LINENO: checking for module suffix" >&5
4585 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4586 < rm -f conftest*
4587 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4588 < rm -f work*
4589 < cat >conftest.f90 <<EOF
4590 <        module conftest
4591 <        integer n
4592 <        parameter (n=1)
4593 <        end module conftest
4594 < EOF
4595 < # SGI and absoft compilers generates module name in upper case!
4596 < testname="conftest"
4597 < modcase="lower"
4598 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4599 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4600 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4601 <    if test -z "$MOD" ; then
4602 <        MOD=`ls CONFTEST* 2>/dev/null \
4603 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4604 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4605 <        if test -n "$MOD" ; then
4606 <            testname="CONFTEST"
4607 <            modcase="upper"
4608 <        fi
4609 <    fi
4610 <    if test -z "$MOD" ; then
4611 <        echo "$as_me:$LINENO: result: unknown" >&5
4612 < echo "${ECHO_T}unknown" >&6
4613 <        # Use mod if we can't figure it out
4614 <        MOD="mod"
4615 <    else
4616 <        echo "$as_me:$LINENO: result: $MOD" >&5
4617 < echo "${ECHO_T}$MOD" >&6
4618 <    fi
4619 <    if test -s work.pcl ; then
4620 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4621 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4622 <    fi
4623 < else
4624 <    echo "$as_me:$LINENO: result: unknown" >&5
4625 < echo "${ECHO_T}unknown" >&6
4626 < fi
4627 <
4628 <
4629 <
4630 <
4631 <
4632 < # Check for module include path (some use -I, some (Solaris) use -M, some
4633 < # (absoft) use -p).
4634 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4635 < # specified, work.pcl and work.pc are created.  However, if you specify
4636 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4637 < # Use the module made above
4638 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4639 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4640 < rm -f conftest*
4641 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4642 < rm -f work*
4643 < cat >conftest.f90 <<EOF
4644 <        module conftest
4645 <        integer n
4646 <        parameter (n=1)
4647 <        end module conftest
4648 < EOF
4649 < # SGI and absoft compilers generates module name in upper case!
4650 < testname="conftest"
4651 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4652 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4653 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4654 <   if test -n "$mod" ; then
4655 <      testname="CONFTEST"
4656 <   fi
4657 <   madedir=0
4658 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4659 <   cp $testname.$MOD conf
4660 <   rm -f conftest* CONFTEST*
4661 <   cat >conftest1.f90 <<EOF
4662 <        program main
4663 <        use conftest
4664 <        print *, n
4665 <        end
4666 < EOF
4667 <   F90_WORK_FILES_ARG=""
4668 <   F90MODINCSPEC=""
4669 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4670 <       MODDIRFLAG="-I"
4671 <       F90MODINCSPEC="-I<dir>"
4672 <       echo "$as_me:$LINENO: result: -I" >&5
4673 < echo "${ECHO_T}-I" >&6
4674 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4675 <       MODDIRFLAG="-M"
4676 <       F90MODINCSPEC="-M<dir>"
4677 <       echo "$as_me:$LINENO: result: -M" >&5
4678 < echo "${ECHO_T}-M" >&6
4679 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4680 <       MODDIRFLAG="-p"
4681 <       F90MODINCSPEC="-p<dir>"
4682 <       echo "$as_me:$LINENO: result: -p" >&5
4683 < echo "${ECHO_T}-p" >&6
4684 <   elif test -s work.pc ; then
4685 <        cp work.pc conf/mpimod.pc
4686 <        echo "mpimod.pc" > conf/mpimod.pcl
4687 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4688 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4689 <            MODDIRFLAG='-cl,mpimod.pcl'
4690 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4691 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4692 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4693 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4694 <
4695 <        else
4696 <            # The version of the Intel compiler that I have refuses to let
4697 <            # you put the "work catalog" list anywhere but the current
4698 <            # directory. For example, you cannot in
4699 <         :
4700 <        fi
4701 <   fi
4702 <   if test -z "MODDIRFLAG" ; then
4703 <       echo "$as_me:$LINENO: result: unknown" >&5
4704 < echo "${ECHO_T}unknown" >&6
4705 <   fi
4706 <
4707 <
4708 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4709 <   if test $madedir = 1 ; then rmdir conf ; fi
4710 < fi
4711 <
4712 <
4713 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4714 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4715 < if test "${ac_cv_f90_module_names+set}" = set; then
4716 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4717 < else
4718 <  ac_ext=f90
4719 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4720 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4721 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4722 <
4723 < # carry out the test in a new directory, so that we don't miss anything
4724 < mkdir conftest
4725 < cd conftest
4726 < cat >conftest.$ac_ext <<_ACEOF
4727 < MODULE Bar
4728 < END MODULE Bar
4729 < _ACEOF
4730 < rm -f conftest.$ac_objext
4731 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4732 <  (eval $ac_compile) 2>conftest.er1
4733 <  ac_status=$?
4734 <  grep -v '^ *+' conftest.er1 >conftest.err
4735 <  rm -f conftest.er1
4736 <  cat conftest.err >&5
4737 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4738 <  (exit $ac_status); } &&
4739 <         { ac_try='test -z "$ac_f90_werror_flag"
4740 <                         || test ! -s conftest.err'
4741 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4742 <  (eval $ac_try) 2>&5
4743 <  ac_status=$?
4744 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4745 <  (exit $ac_status); }; } &&
4746 <         { ac_try='test -s conftest.$ac_objext'
4747 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4748 <  (eval $ac_try) 2>&5
4749 <  ac_status=$?
4750 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4751 <  (exit $ac_status); }; }; then
4752 <  ac_cv_f90_module_names=
4753 < ac_file_list=*
4754 < for ac_file in $ac_file_list; do
4755 <   case $ac_file in
4756 <      # don't care for original source and object files
4757 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4758 <          :
4759 <          ;;
4760 <      # look for new files derived from the file name
4761 <      *conftest*)
4762 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4763 <            ac_exists=false
4764 <  for ac_i in $ac_cv_f90_module_names; do
4765 <    if test x"$ac_pat" = x"$ac_i"; then
4766 <      ac_exists=true
4767 <      break
4768 <    fi
4769 <  done
4770 <
4771 <  if test x"$ac_exists" = xtrue; then
4772 <  :
4773 < else
4774 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4775 < fi
4776 <
4777 <          ;;
4778 <      # look for new files derived from the module name,
4779 <      # with different case translation schemes
4780 <      *Bar*)
4781 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4782 <            ac_exists=false
4783 <  for ac_i in $ac_cv_f90_module_names; do
4784 <    if test x"$ac_pat" = x"$ac_i"; then
4785 <      ac_exists=true
4786 <      break
4787 <    fi
4788 <  done
4789 <
4790 <  if test x"$ac_exists" = xtrue; then
4791 <  :
4792 < else
4793 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4794 < fi
4795 <
4796 <          ;;
4797 <      *bar*)
4798 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4799 <            ac_exists=false
4800 <  for ac_i in $ac_cv_f90_module_names; do
4801 <    if test x"$ac_pat" = x"$ac_i"; then
4802 <      ac_exists=true
4803 <      break
4804 <    fi
4805 <  done
4806 <
4807 <  if test x"$ac_exists" = xtrue; then
4808 <  :
4809 < else
4810 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4811 < fi
4812 <
4813 <          ;;
4814 <      *BAR*)
4815 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4816 <            ac_exists=false
4817 <  for ac_i in $ac_cv_f90_module_names; do
4818 <    if test x"$ac_pat" = x"$ac_i"; then
4819 <      ac_exists=true
4820 <      break
4821 <    fi
4822 <  done
4823 <
4824 <  if test x"$ac_exists" = xtrue; then
4825 <  :
4826 < else
4827 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4828 < fi
4829 <
4830 <          ;;
4831 <       # Other files - we have no idea how they are generated
4832 <       *)
4833 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4834 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4835 <          ;;
4836 <   esac
4837 < done
4838 < if test "x$ac_cv_f90_module_names" = "x"; then
4839 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4840 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4841 < fi
4842 <
4843 < else
4844 <  echo "$as_me: failed program was:" >&5
4845 < sed 's/^/| /' conftest.$ac_ext >&5
4846 <
4847 < ac_cv_f90_module_names=
4848 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4849 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4850 < fi
4851 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4852 < cd ..
4853 < # cleanup
4854 < rm -rf conftest
4855 < ac_ext=f90
4856 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4857 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4858 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4859 <
4860 < fi
4861 < echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4862 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
4863 <
4864 < # We now generate a shell script that will help us to figure out the correct
4865 < # module file names, using the value of ac_cv_f90_module_names
4866 <
4867 < echo "Generating shell script modnam"
4868 <
4869 < cat > scripts/modnam << EOF
4870 < #! /bin/sh
4871 < # This script is auto-generated by configure
4872 < #
4873 < usage="\\
4874 < Usage: \$0 [FILES]
4875 <
4876 < [FILES] are Fortran 90 source files.
4877 < The output is a list of module file names that the Fortran 90 compiler
4878 < generates when compiling [FILES]."
4879 <
4880 < list=
4881 < empty=
4882 <
4883 < if test \$# -eq 0; then
4884 <   echo "\$usage"; exit 0
4885 < fi
4886 <
4887 < while test \$# != 0; do
4888 <
4889 <  file=\$1
4890 <  shift
4891 <
4892 < # strip suffix
4893 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4894 <
4895 <  test ! -f \$file && continue
4896 <
4897 < # Look for module definitions and transform them to upper / lower case
4898 <  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4899 <  upper=\`echo \$mods | tr a-z A-Z\`
4900 <  lower=\`echo \$mods | tr A-Z a-z\`
4901 <
4902 < # Here, the patterns for generating module file names were inserted by configure
4903 <  for trans in $ac_cv_f90_module_names; do
4904 <
4905 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4906 <    var=empty
4907 <    case \$pat in
4908 <       %MODULE%)
4909 <          var=upper ;;
4910 <       %Module%)
4911 <          var=mods ;;
4912 <       %module%)
4913 <          var=lower ;;
4914 <       %FILE%)
4915 <          test -n "\$mods" && var=base ;;
4916 <    esac
4917 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4918 <    list="\$list \$new"
4919 <  done
4920 < done
4921 <
4922 < echo \$list
4923 < # end of configure-generated script
4924 < EOF
4925 < chmod 755 scripts/modnam
4926 <
4927 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4928 < F90_MODULE_NAMES=empty
4929 < case $pat in
4930 <       %MODULE%)
4931 <          F90_MODULE_NAMES=UPPER ;;
4932 <       %Module%)
4933 <          F90_MODULE_NAMES=Mixed ;;
4934 <       %module%)
4935 <          F90_MODULE_NAMES=lower ;;
4936 <       *)
4937 <          F90_MODULE_NAMES=unknown ;;
4938 < esac
4939 <
4940 < ac_ext=c
4941 < ac_cpp='$CPP $CPPFLAGS'
4942 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4943 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4944 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4945 <
4946 <
4947 < ac_ext=cc
4948 < ac_cpp='$CXXCPP $CPPFLAGS'
4949 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4950 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4951 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4952 <
4953 <
4954 <
4955 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
4956 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
4957 < if test "${ac_cv_lib_m_asin+set}" = set; then
4958 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4959 < else
4960 <  ac_check_lib_save_LIBS=$LIBS
4961 < LIBS="-lm  $LIBS"
4962 < cat >conftest.$ac_ext <<_ACEOF
4963 < /* confdefs.h.  */
4964 < _ACEOF
4965 < cat confdefs.h >>conftest.$ac_ext
4966 < cat >>conftest.$ac_ext <<_ACEOF
4967 < /* end confdefs.h.  */
4968 <
4969 < /* Override any gcc2 internal prototype to avoid an error.  */
4970 < #ifdef __cplusplus
4971 < extern "C"
4972 < #endif
4973 < /* We use char because int might match the return type of a gcc2
4974 <   builtin and then its argument prototype would still apply.  */
4975 < char asin ();
4976 < int
4977 < main ()
4978 < {
4979 < asin ();
4980 <  ;
4981 <  return 0;
4982 < }
4983 < _ACEOF
4984 < rm -f conftest.$ac_objext conftest$ac_exeext
4985 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4986 <  (eval $ac_link) 2>conftest.er1
4987 <  ac_status=$?
4988 <  grep -v '^ *+' conftest.er1 >conftest.err
4989 <  rm -f conftest.er1
4990 <  cat conftest.err >&5
4991 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4992 <  (exit $ac_status); } &&
4993 <         { ac_try='test -z "$ac_cxx_werror_flag"
4994 <                         || test ! -s conftest.err'
4995 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4996 <  (eval $ac_try) 2>&5
4997 <  ac_status=$?
4998 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4999 <  (exit $ac_status); }; } &&
5000 <         { ac_try='test -s conftest$ac_exeext'
5001 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5002 <  (eval $ac_try) 2>&5
5003 <  ac_status=$?
5004 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5005 <  (exit $ac_status); }; }; then
5006 <  ac_cv_lib_m_asin=yes
5007 < else
5008 <  echo "$as_me: failed program was:" >&5
5009 < sed 's/^/| /' conftest.$ac_ext >&5
5010 <
5011 < ac_cv_lib_m_asin=no
5012 < fi
5013 < rm -f conftest.err conftest.$ac_objext \
5014 <      conftest$ac_exeext conftest.$ac_ext
5015 < LIBS=$ac_check_lib_save_LIBS
5016 < fi
5017 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5018 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5019 < if test $ac_cv_lib_m_asin = yes; then
5020 <  cat >>confdefs.h <<_ACEOF
5021 < #define HAVE_LIBM 1
5022 < _ACEOF
5023 <
5024 <  LIBS="-lm $LIBS"
5025 <
5026 < else
5027 <  exit
5028 < fi
5029 <
5030 <
5031 < ac_ext=c
5032 < ac_cpp='$CPP $CPPFLAGS'
5033 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5034 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5035 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5036 <
5037 <
5038 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5039 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5040 < if test "${ac_cv_header_stdc+set}" = set; then
5041 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5042 < else
5043 <  cat >conftest.$ac_ext <<_ACEOF
5044 < /* confdefs.h.  */
5045 < _ACEOF
5046 < cat confdefs.h >>conftest.$ac_ext
5047 < cat >>conftest.$ac_ext <<_ACEOF
5048 < /* end confdefs.h.  */
5049 < #include <stdlib.h>
5050 < #include <stdarg.h>
5051 < #include <string.h>
5052 < #include <float.h>
5053 <
5054 < int
5055 < main ()
5056 < {
5057 <
5058 <  ;
5059 <  return 0;
5060 < }
5061 < _ACEOF
5062 < rm -f conftest.$ac_objext
5063 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5064 <  (eval $ac_compile) 2>conftest.er1
5065 <  ac_status=$?
5066 <  grep -v '^ *+' conftest.er1 >conftest.err
5067 <  rm -f conftest.er1
5068 <  cat conftest.err >&5
5069 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5070 <  (exit $ac_status); } &&
5071 <         { ac_try='test -z "$ac_c_werror_flag"
5072 <                         || test ! -s conftest.err'
5073 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5074 <  (eval $ac_try) 2>&5
5075 <  ac_status=$?
5076 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5077 <  (exit $ac_status); }; } &&
5078 <         { ac_try='test -s conftest.$ac_objext'
5079 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5080 <  (eval $ac_try) 2>&5
5081 <  ac_status=$?
5082 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5083 <  (exit $ac_status); }; }; then
5084 <  ac_cv_header_stdc=yes
5085 < else
5086 <  echo "$as_me: failed program was:" >&5
5087 < sed 's/^/| /' conftest.$ac_ext >&5
5088 <
5089 < ac_cv_header_stdc=no
5090 < fi
5091 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5092 <
5093 < if test $ac_cv_header_stdc = yes; then
5094 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5095 <  cat >conftest.$ac_ext <<_ACEOF
5096 < /* confdefs.h.  */
5097 < _ACEOF
5098 < cat confdefs.h >>conftest.$ac_ext
5099 < cat >>conftest.$ac_ext <<_ACEOF
5100 < /* end confdefs.h.  */
5101 < #include <string.h>
5102 <
5103 < _ACEOF
5104 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5105 <  $EGREP "memchr" >/dev/null 2>&1; then
5106 <  :
5107 < else
5108 <  ac_cv_header_stdc=no
5109 < fi
5110 < rm -f conftest*
5111 <
5112 < fi
5113 <
5114 < if test $ac_cv_header_stdc = yes; then
5115 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5116 <  cat >conftest.$ac_ext <<_ACEOF
5117 < /* confdefs.h.  */
5118 < _ACEOF
5119 < cat confdefs.h >>conftest.$ac_ext
5120 < cat >>conftest.$ac_ext <<_ACEOF
5121 < /* end confdefs.h.  */
5122 < #include <stdlib.h>
5123 <
5124 < _ACEOF
5125 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5126 <  $EGREP "free" >/dev/null 2>&1; then
5127 <  :
5128 < else
5129 <  ac_cv_header_stdc=no
5130 < fi
5131 < rm -f conftest*
5132 <
5133 < fi
5134 <
5135 < if test $ac_cv_header_stdc = yes; then
5136 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5137 <  if test "$cross_compiling" = yes; then
5138 <  :
5139 < else
5140 <  cat >conftest.$ac_ext <<_ACEOF
5141 < /* confdefs.h.  */
5142 < _ACEOF
5143 < cat confdefs.h >>conftest.$ac_ext
5144 < cat >>conftest.$ac_ext <<_ACEOF
5145 < /* end confdefs.h.  */
5146 < #include <ctype.h>
5147 < #if ((' ' & 0x0FF) == 0x020)
5148 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5149 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5150 < #else
5151 < # define ISLOWER(c) \
5152 <                   (('a' <= (c) && (c) <= 'i') \
5153 <                     || ('j' <= (c) && (c) <= 'r') \
5154 <                     || ('s' <= (c) && (c) <= 'z'))
5155 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5156 < #endif
5157 <
5158 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5159 < int
5160 < main ()
5161 < {
5162 <  int i;
5163 <  for (i = 0; i < 256; i++)
5164 <    if (XOR (islower (i), ISLOWER (i))
5165 <        || toupper (i) != TOUPPER (i))
5166 <      exit(2);
5167 <  exit (0);
5168 < }
5169 < _ACEOF
5170 < rm -f conftest$ac_exeext
5171 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5172 <  (eval $ac_link) 2>&5
5173 <  ac_status=$?
5174 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5175 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5176 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5177 <  (eval $ac_try) 2>&5
5178 <  ac_status=$?
5179 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5180 <  (exit $ac_status); }; }; then
5181 <  :
5182 < else
5183 <  echo "$as_me: program exited with status $ac_status" >&5
5184 < echo "$as_me: failed program was:" >&5
5185 < sed 's/^/| /' conftest.$ac_ext >&5
5186 <
5187 < ( exit $ac_status )
5188 < ac_cv_header_stdc=no
5189 < fi
5190 < rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5191 < fi
5192 < fi
5193 < fi
5194 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5195 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
5196 < if test $ac_cv_header_stdc = yes; then
5197 <
5198 < cat >>confdefs.h <<\_ACEOF
5199 < #define STDC_HEADERS 1
5200 < _ACEOF
5201 <
5202 < fi
5203 <
5204 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5205 <
5206 <
5207 <
5208 <
5209 <
5210 <
5211 <
5212 <
5213 <
5214 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5215 <                  inttypes.h stdint.h unistd.h
5216 < do
5217 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5218 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5219 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5220 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5221 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5222 < else
5223 <  cat >conftest.$ac_ext <<_ACEOF
5224 < /* confdefs.h.  */
5225 < _ACEOF
5226 < cat confdefs.h >>conftest.$ac_ext
5227 < cat >>conftest.$ac_ext <<_ACEOF
5228 < /* end confdefs.h.  */
5229 < $ac_includes_default
5230 <
5231 < #include <$ac_header>
5232 < _ACEOF
5233 < rm -f conftest.$ac_objext
5234 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5235 <  (eval $ac_compile) 2>conftest.er1
5236 <  ac_status=$?
5237 <  grep -v '^ *+' conftest.er1 >conftest.err
5238 <  rm -f conftest.er1
5239 <  cat conftest.err >&5
5240 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5241 <  (exit $ac_status); } &&
5242 <         { ac_try='test -z "$ac_c_werror_flag"
5243 <                         || test ! -s conftest.err'
5244 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5245 <  (eval $ac_try) 2>&5
5246 <  ac_status=$?
5247 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5248 <  (exit $ac_status); }; } &&
5249 <         { ac_try='test -s conftest.$ac_objext'
5250 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5251 <  (eval $ac_try) 2>&5
5252 <  ac_status=$?
5253 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5254 <  (exit $ac_status); }; }; then
5255 <  eval "$as_ac_Header=yes"
5256 < else
5257 <  echo "$as_me: failed program was:" >&5
5258 < sed 's/^/| /' conftest.$ac_ext >&5
5259 <
5260 < eval "$as_ac_Header=no"
5261 < fi
5262 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5263 < fi
5264 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5265 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5266 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5267 <  cat >>confdefs.h <<_ACEOF
5268 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5269 < _ACEOF
5270 <
5271 < fi
5272 <
5273 < done
5274 <
5275 <
5276 < #
5277 < # Handle user hints
5278 < #
5279 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5280 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5281 <
5282 < # Check whether --with-zlib or --without-zlib was given.
5283 < if test "${with_zlib+set}" = set; then
5284 <  withval="$with_zlib"
5285 <  if test "$withval" != no ; then
5286 <  echo "$as_me:$LINENO: result: yes" >&5
5287 < echo "${ECHO_T}yes" >&6
5288 <  if test -d "$withval"
5289 <  then
5290 <    ZLIB_HOME="$withval"
5291 <  else
5292 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5293 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5294 <  fi
5295 < else
5296 <  echo "$as_me:$LINENO: result: no" >&5
5297 < echo "${ECHO_T}no" >&6
5298 < fi
5299 < fi;
5300 <
5301 < ZLIB_HOME=/usr/local
5302 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
5303 < then
5304 <        ZLIB_HOME=/usr
5305 < fi
5306 <
5307 < #
5308 < # Locate zlib, if wanted
5309 < #
5310 < if test -n "${ZLIB_HOME}"
5311 < then
5312 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
5313 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5314 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5315 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5316 <
5317 <
5318 <        ac_ext=c
5319 < ac_cpp='$CPP $CPPFLAGS'
5320 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5321 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5322 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5323 <
5324 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5325 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5326 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5327 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5328 < else
5329 <  ac_check_lib_save_LIBS=$LIBS
5330 < LIBS="-lz  $LIBS"
5331 < cat >conftest.$ac_ext <<_ACEOF
5332 < /* confdefs.h.  */
5333 < _ACEOF
5334 < cat confdefs.h >>conftest.$ac_ext
5335 < cat >>conftest.$ac_ext <<_ACEOF
5336 < /* end confdefs.h.  */
5337 <
5338 < /* Override any gcc2 internal prototype to avoid an error.  */
5339 < #ifdef __cplusplus
5340 < extern "C"
5341 < #endif
5342 < /* We use char because int might match the return type of a gcc2
5343 <   builtin and then its argument prototype would still apply.  */
5344 < char inflateEnd ();
5345 < int
5346 < main ()
5347 < {
5348 < inflateEnd ();
5349 <  ;
5350 <  return 0;
5351 < }
5352 < _ACEOF
5353 < rm -f conftest.$ac_objext conftest$ac_exeext
5354 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5355 <  (eval $ac_link) 2>conftest.er1
5356 <  ac_status=$?
5357 <  grep -v '^ *+' conftest.er1 >conftest.err
5358 <  rm -f conftest.er1
5359 <  cat conftest.err >&5
5360 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5361 <  (exit $ac_status); } &&
5362 <         { ac_try='test -z "$ac_c_werror_flag"
5363 <                         || test ! -s conftest.err'
5364 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5365 <  (eval $ac_try) 2>&5
5366 <  ac_status=$?
5367 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5368 <  (exit $ac_status); }; } &&
5369 <         { ac_try='test -s conftest$ac_exeext'
5370 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5371 <  (eval $ac_try) 2>&5
5372 <  ac_status=$?
5373 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5374 <  (exit $ac_status); }; }; then
5375 <  ac_cv_lib_z_inflateEnd=yes
5376 < else
5377 <  echo "$as_me: failed program was:" >&5
5378 < sed 's/^/| /' conftest.$ac_ext >&5
5379 <
5380 < ac_cv_lib_z_inflateEnd=no
5381 < fi
5382 < rm -f conftest.err conftest.$ac_objext \
5383 <      conftest$ac_exeext conftest.$ac_ext
5384 < LIBS=$ac_check_lib_save_LIBS
5385 < fi
5386 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5387 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5388 < if test $ac_cv_lib_z_inflateEnd = yes; then
5389 <  zlib_cv_libz=yes
5390 < else
5391 <  zlib_cv_libz=no
5392 < fi
5393 <
5394 <        if test "${ac_cv_header_zlib_h+set}" = set; then
5395 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
5396 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5397 < if test "${ac_cv_header_zlib_h+set}" = set; then
5398 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5399 < fi
5400 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5401 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5402 < else
5403 <  # Is the header compilable?
5404 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
5405 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5406 < cat >conftest.$ac_ext <<_ACEOF
5407 < /* confdefs.h.  */
5408 < _ACEOF
5409 < cat confdefs.h >>conftest.$ac_ext
5410 < cat >>conftest.$ac_ext <<_ACEOF
5411 < /* end confdefs.h.  */
5412 < $ac_includes_default
5413 < #include <zlib.h>
5414 < _ACEOF
5415 < rm -f conftest.$ac_objext
5416 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5417 <  (eval $ac_compile) 2>conftest.er1
5418 <  ac_status=$?
5419 <  grep -v '^ *+' conftest.er1 >conftest.err
5420 <  rm -f conftest.er1
5421 <  cat conftest.err >&5
5422 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5423 <  (exit $ac_status); } &&
5424 <         { ac_try='test -z "$ac_c_werror_flag"
5425 <                         || test ! -s conftest.err'
5426 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5427 <  (eval $ac_try) 2>&5
5428 <  ac_status=$?
5429 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5430 <  (exit $ac_status); }; } &&
5431 <         { ac_try='test -s conftest.$ac_objext'
5432 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5433 <  (eval $ac_try) 2>&5
5434 <  ac_status=$?
5435 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5436 <  (exit $ac_status); }; }; then
5437 <  ac_header_compiler=yes
5438 < else
5439 <  echo "$as_me: failed program was:" >&5
5440 < sed 's/^/| /' conftest.$ac_ext >&5
5441 <
5442 < ac_header_compiler=no
5443 < fi
5444 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5445 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5446 < echo "${ECHO_T}$ac_header_compiler" >&6
5447 <
5448 < # Is the header present?
5449 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
5450 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5451 < cat >conftest.$ac_ext <<_ACEOF
5452 < /* confdefs.h.  */
5453 < _ACEOF
5454 < cat confdefs.h >>conftest.$ac_ext
5455 < cat >>conftest.$ac_ext <<_ACEOF
5456 < /* end confdefs.h.  */
5457 < #include <zlib.h>
5458 < _ACEOF
5459 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5460 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5461 <  ac_status=$?
5462 <  grep -v '^ *+' conftest.er1 >conftest.err
5463 <  rm -f conftest.er1
5464 <  cat conftest.err >&5
5465 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5466 <  (exit $ac_status); } >/dev/null; then
5467 <  if test -s conftest.err; then
5468 <    ac_cpp_err=$ac_c_preproc_warn_flag
5469 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5470 <  else
5471 <    ac_cpp_err=
5472 <  fi
5473 < else
5474 <  ac_cpp_err=yes
5475 < fi
5476 < if test -z "$ac_cpp_err"; then
5477 <  ac_header_preproc=yes
5478 < else
5479 <  echo "$as_me: failed program was:" >&5
5480 < sed 's/^/| /' conftest.$ac_ext >&5
5481 <
5482 <  ac_header_preproc=no
5483 < fi
5484 < rm -f conftest.err conftest.$ac_ext
5485 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5486 < echo "${ECHO_T}$ac_header_preproc" >&6
5487 <
5488 < # So?  What about this header?
5489 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5490 <  yes:no: )
5491 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5492 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5493 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5494 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5495 <    ac_header_preproc=yes
5496 <    ;;
5497 <  no:yes:* )
5498 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5499 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5500 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5501 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5502 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5503 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5504 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5505 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5506 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5507 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
5508 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
5509 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5510 <    (
5511 <      cat <<\_ASBOX
5512 < ## ------------------------------ ##
5513 < ## Report this to gezelter@nd.edu ##
5514 < ## ------------------------------ ##
5515 < _ASBOX
5516 <    ) |
5517 <      sed "s/^/$as_me: WARNING:     /" >&2
5518 <    ;;
5519 < esac
5520 < echo "$as_me:$LINENO: checking for zlib.h" >&5
5521 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5522 < if test "${ac_cv_header_zlib_h+set}" = set; then
5523 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5524 < else
5525 <  ac_cv_header_zlib_h=$ac_header_preproc
5526 < fi
5527 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5528 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5529 <
5530 < fi
5531 < if test $ac_cv_header_zlib_h = yes; then
5532 <  zlib_cv_zlib_h=yes
5533 < else
5534 <  zlib_cv_zlib_h=no
5535 < fi
5536 <
5537 <
5538 <        ac_ext=c
5539 < ac_cpp='$CPP $CPPFLAGS'
5540 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5541 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5542 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5543 <
5544 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
5545 <        then
5546 <                #
5547 <                # If both library and header were found, use them
5548 <                #
5549 <
5550 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5551 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5552 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5553 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5554 < else
5555 <  ac_check_lib_save_LIBS=$LIBS
5556 < LIBS="-lz  $LIBS"
5557 < cat >conftest.$ac_ext <<_ACEOF
5558 < /* confdefs.h.  */
5559 < _ACEOF
5560 < cat confdefs.h >>conftest.$ac_ext
5561 < cat >>conftest.$ac_ext <<_ACEOF
5562 < /* end confdefs.h.  */
5563 <
5564 < /* Override any gcc2 internal prototype to avoid an error.  */
5565 < #ifdef __cplusplus
5566 < extern "C"
5567 < #endif
5568 < /* We use char because int might match the return type of a gcc2
5569 <   builtin and then its argument prototype would still apply.  */
5570 < char inflateEnd ();
5571 < int
5572 < main ()
5573 < {
5574 < inflateEnd ();
5575 <  ;
5576 <  return 0;
5577 < }
5578 < _ACEOF
5579 < rm -f conftest.$ac_objext conftest$ac_exeext
5580 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5581 <  (eval $ac_link) 2>conftest.er1
5582 <  ac_status=$?
5583 <  grep -v '^ *+' conftest.er1 >conftest.err
5584 <  rm -f conftest.er1
5585 <  cat conftest.err >&5
5586 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5587 <  (exit $ac_status); } &&
5588 <         { ac_try='test -z "$ac_c_werror_flag"
5589 <                         || test ! -s conftest.err'
5590 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5591 <  (eval $ac_try) 2>&5
5592 <  ac_status=$?
5593 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5594 <  (exit $ac_status); }; } &&
5595 <         { ac_try='test -s conftest$ac_exeext'
5596 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5597 <  (eval $ac_try) 2>&5
5598 <  ac_status=$?
5599 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5600 <  (exit $ac_status); }; }; then
5601 <  ac_cv_lib_z_inflateEnd=yes
5602 < else
5603 <  echo "$as_me: failed program was:" >&5
5604 < sed 's/^/| /' conftest.$ac_ext >&5
5605 <
5606 < ac_cv_lib_z_inflateEnd=no
5607 < fi
5608 < rm -f conftest.err conftest.$ac_objext \
5609 <      conftest$ac_exeext conftest.$ac_ext
5610 < LIBS=$ac_check_lib_save_LIBS
5611 < fi
5612 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5613 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5614 < if test $ac_cv_lib_z_inflateEnd = yes; then
5615 <  cat >>confdefs.h <<_ACEOF
5616 < #define HAVE_LIBZ 1
5617 < _ACEOF
5618 <
5619 <  LIBS="-lz $LIBS"
5620 <
5621 < fi
5622 <
5623 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5624 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5625 <                echo "$as_me:$LINENO: result: ok" >&5
5626 < echo "${ECHO_T}ok" >&6
5627 <        else
5628 <                #
5629 <                # If either header or library was not found, revert and bomb
5630 <                #
5631 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5632 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5633 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5634 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5635 <                echo "$as_me:$LINENO: result: failed" >&5
5636 < echo "${ECHO_T}failed" >&6
5637 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5638 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5639 <   { (exit 1); exit 1; }; }
5640 <        fi
5641 < fi
5642 <
5643 <
5644 <
5645 <
5646 <
5647 <
5648 <
5649 <
5650 < for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
5651 < do
5652 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5653 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5654 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5655 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5656 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5657 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5658 < fi
5659 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5660 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5661 < else
5662 <  # Is the header compilable?
5663 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5664 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5665 < cat >conftest.$ac_ext <<_ACEOF
5666 < /* confdefs.h.  */
5667 < _ACEOF
5668 < cat confdefs.h >>conftest.$ac_ext
5669 < cat >>conftest.$ac_ext <<_ACEOF
5670 < /* end confdefs.h.  */
5671 < $ac_includes_default
5672 < #include <$ac_header>
5673 < _ACEOF
5674 < rm -f conftest.$ac_objext
5675 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5676 <  (eval $ac_compile) 2>conftest.er1
5677 <  ac_status=$?
5678 <  grep -v '^ *+' conftest.er1 >conftest.err
5679 <  rm -f conftest.er1
5680 <  cat conftest.err >&5
5681 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5682 <  (exit $ac_status); } &&
5683 <         { ac_try='test -z "$ac_c_werror_flag"
5684 <                         || test ! -s conftest.err'
5685 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5686 <  (eval $ac_try) 2>&5
5687 <  ac_status=$?
5688 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5689 <  (exit $ac_status); }; } &&
5690 <         { ac_try='test -s conftest.$ac_objext'
5691 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5692 <  (eval $ac_try) 2>&5
5693 <  ac_status=$?
5694 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5695 <  (exit $ac_status); }; }; then
5696 <  ac_header_compiler=yes
5697 < else
5698 <  echo "$as_me: failed program was:" >&5
5699 < sed 's/^/| /' conftest.$ac_ext >&5
5700 <
5701 < ac_header_compiler=no
5702 < fi
5703 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5704 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5705 < echo "${ECHO_T}$ac_header_compiler" >&6
5706 <
5707 < # Is the header present?
5708 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
5709 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5710 < cat >conftest.$ac_ext <<_ACEOF
5711 < /* confdefs.h.  */
5712 < _ACEOF
5713 < cat confdefs.h >>conftest.$ac_ext
5714 < cat >>conftest.$ac_ext <<_ACEOF
5715 < /* end confdefs.h.  */
5716 < #include <$ac_header>
5717 < _ACEOF
5718 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5719 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5720 <  ac_status=$?
5721 <  grep -v '^ *+' conftest.er1 >conftest.err
5722 <  rm -f conftest.er1
5723 <  cat conftest.err >&5
5724 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725 <  (exit $ac_status); } >/dev/null; then
5726 <  if test -s conftest.err; then
5727 <    ac_cpp_err=$ac_c_preproc_warn_flag
5728 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5729 <  else
5730 <    ac_cpp_err=
5731 <  fi
5732 < else
5733 <  ac_cpp_err=yes
5734 < fi
5735 < if test -z "$ac_cpp_err"; then
5736 <  ac_header_preproc=yes
5737 < else
5738 <  echo "$as_me: failed program was:" >&5
5739 < sed 's/^/| /' conftest.$ac_ext >&5
5740 <
5741 <  ac_header_preproc=no
5742 < fi
5743 < rm -f conftest.err conftest.$ac_ext
5744 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5745 < echo "${ECHO_T}$ac_header_preproc" >&6
5746 <
5747 < # So?  What about this header?
5748 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5749 <  yes:no: )
5750 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5751 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5752 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5753 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5754 <    ac_header_preproc=yes
5755 <    ;;
5756 <  no:yes:* )
5757 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5758 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5759 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5760 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5761 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5762 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5763 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5764 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5765 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5766 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5767 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5768 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5769 <    (
5770 <      cat <<\_ASBOX
5771 < ## ------------------------------ ##
5772 < ## Report this to gezelter@nd.edu ##
5773 < ## ------------------------------ ##
5774 < _ASBOX
5775 <    ) |
5776 <      sed "s/^/$as_me: WARNING:     /" >&2
5777 <    ;;
5778 < esac
5779 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5780 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5781 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5782 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5783 < else
5784 <  eval "$as_ac_Header=\$ac_header_preproc"
5785 < fi
5786 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5787 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
4112 > ac_save_FFLAGS=$FCFLAGS
4113 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4114 > (eval echo $as_me:4114: \"$ac_link\") >&5
4115 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4116 > echo "$ac_fc_v_output" >&5
4117 > FCFLAGS=$ac_save_FFLAGS
4118 >
4119 > rm -f conftest*
4120 >
4121 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4122 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4123 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4124 > ac_fc_v_output="`echo $ac_fc_v_output |
4125 >        grep 'LPATH is:' |
4126 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4127 >
4128 > case $ac_fc_v_output in
4129 >  # If we are using xlf then replace all the commas with spaces.
4130 >  *xlfentry*)
4131 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4132 >
4133 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4134 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4135 >  *mGLOB_options_string*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4137 >
4138 >  # If we are using Cray Fortran then delete quotes.
4139 >  # Use "\"" instead of '"' for font-lock-mode.
4140 >  # FIXME: a more general fix for quoted arguments with spaces?
4141 >  *cft90*)
4142 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4143 > esac
4144 >
4145 >
4146 >
4147 > ac_cv_fc_libs=
4148 >
4149 > # Save positional arguments (if any)
4150 > ac_save_positional="$@"
4151 >
4152 > set X $ac_fc_v_output
4153 > while test $# != 1; do
4154 >  shift
4155 >  ac_arg=$1
4156 >  case $ac_arg in
4157 >        [\\/]*.a | ?:[\\/]*.a)
4158 >            ac_exists=false
4159 >  for ac_i in $ac_cv_fc_libs; do
4160 >    if test x"$ac_arg" = x"$ac_i"; then
4161 >      ac_exists=true
4162 >      break
4163 >    fi
4164 >  done
4165 >
4166 >  if test x"$ac_exists" = xtrue; then
4167 >  :
4168 > else
4169 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4170 > fi
4171 >
4172 >          ;;
4173 >        -bI:*)
4174 >            ac_exists=false
4175 >  for ac_i in $ac_cv_fc_libs; do
4176 >    if test x"$ac_arg" = x"$ac_i"; then
4177 >      ac_exists=true
4178 >      break
4179 >    fi
4180 >  done
4181 >
4182 >  if test x"$ac_exists" = xtrue; then
4183 >  :
4184 > else
4185 >  if test "$ac_compiler_gnu" = yes; then
4186 >  for ac_link_opt in $ac_arg; do
4187 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4188 >  done
4189 > else
4190 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4191 > fi
4192 > fi
4193 >
4194 >          ;;
4195 >          # Ignore these flags.
4196 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4197 >          ;;
4198 >        -lkernel32)
4199 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4200 >          ;;
4201 >        -[LRuY])
4202 >          # These flags, when seen by themselves, take an argument.
4203 >          # We remove the space between option and argument and re-iterate
4204 >          # unless we find an empty arg or a new option (starting with -)
4205 >          case $2 in
4206 >             "" | -*);;
4207 >             *)
4208 >                ac_arg="$ac_arg$2"
4209 >                shift; shift
4210 >                set X $ac_arg "$@"
4211 >                ;;
4212 >          esac
4213 >          ;;
4214 >        -YP,*)
4215 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4216 >              ac_exists=false
4217 >  for ac_i in $ac_cv_fc_libs; do
4218 >    if test x"$ac_j" = x"$ac_i"; then
4219 >      ac_exists=true
4220 >      break
4221 >    fi
4222 >  done
4223 >
4224 >  if test x"$ac_exists" = xtrue; then
4225 >  :
4226 > else
4227 >  ac_arg="$ac_arg $ac_j"
4228 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4229 > fi
4230 >
4231 >          done
4232 >          ;;
4233 >        -[lLR]*)
4234 >            ac_exists=false
4235 >  for ac_i in $ac_cv_fc_libs; do
4236 >    if test x"$ac_arg" = x"$ac_i"; then
4237 >      ac_exists=true
4238 >      break
4239 >    fi
4240 >  done
4241 >
4242 >  if test x"$ac_exists" = xtrue; then
4243 >  :
4244 > else
4245 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4246 > fi
4247 >
4248 >          ;;
4249 >          # Ignore everything else.
4250 >  esac
4251 > done
4252 > # restore positional arguments
4253 > set X $ac_save_positional; shift
4254 >
4255 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
4256 > # then we insist that the "run path" must be an absolute path (i.e. it
4257 > # must begin with a "/").
4258 > case `(uname -sr) 2>/dev/null` in
4259 >   "SunOS 5"*)
4260 >      ac_ld_run_path=`echo $ac_fc_v_output |
4261 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4262 >      test "x$ac_ld_run_path" != x &&
4263 >        if test "$ac_compiler_gnu" = yes; then
4264 >  for ac_link_opt in $ac_ld_run_path; do
4265 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4266 >  done
4267 > else
4268 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4269 > fi
4270 >      ;;
4271 > esac
4272 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4273 >
4274 > fi
4275 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4276 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4277 > FCLIBS="$ac_cv_fc_libs"
4278 >
4279 >
4280 > ac_ext=${FC_SRCEXT-f}
4281 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4282 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4283 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4284 >
4285 >
4286 > ac_ext=${FC_SRCEXT-f}
4287 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4288 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4289 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4290 >
4291 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4292 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4293 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4294 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4295 > else
4296 >  ac_fc_dm_save_LIBS=$LIBS
4297 > LIBS="$LIBS $FCLIBS"
4298 > ac_fortran_dm_var=FC_DUMMY_MAIN
4299 > ac_ext=c
4300 > ac_cpp='$CPP $CPPFLAGS'
4301 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4302 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4303 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4304 >
4305 > # First, try linking without a dummy main:
4306 > cat >conftest.$ac_ext <<_ACEOF
4307 > /* confdefs.h.  */
4308 > _ACEOF
4309 > cat confdefs.h >>conftest.$ac_ext
4310 > cat >>conftest.$ac_ext <<_ACEOF
4311 > /* end confdefs.h.  */
4312 >
4313 > #ifdef FC_DUMMY_MAIN
4314 > #ifndef FC_DUMMY_MAIN_EQ_F77
4315 > #  ifdef __cplusplus
4316 >     extern "C"
4317 > #  endif
4318 >   int FC_DUMMY_MAIN() { return 1; }
4319 > #endif
4320 > #endif
4321 > int
4322 > main ()
4323 > {
4324 >
4325 >  ;
4326 >  return 0;
4327 > }
4328 > _ACEOF
4329 > rm -f conftest.$ac_objext conftest$ac_exeext
4330 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4331 >  (eval $ac_link) 2>conftest.er1
4332 >  ac_status=$?
4333 >  grep -v '^ *+' conftest.er1 >conftest.err
4334 >  rm -f conftest.er1
4335 >  cat conftest.err >&5
4336 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4337 >  (exit $ac_status); } &&
4338 >         { ac_try='test -z "$ac_c_werror_flag"
4339 >                         || test ! -s conftest.err'
4340 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4341 >  (eval $ac_try) 2>&5
4342 >  ac_status=$?
4343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4344 >  (exit $ac_status); }; } &&
4345 >         { ac_try='test -s conftest$ac_exeext'
4346 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4347 >  (eval $ac_try) 2>&5
4348 >  ac_status=$?
4349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4350 >  (exit $ac_status); }; }; then
4351 >  ac_cv_fortran_dummy_main=none
4352 > else
4353 >  echo "$as_me: failed program was:" >&5
4354 > sed 's/^/| /' conftest.$ac_ext >&5
4355 >
4356 > ac_cv_fortran_dummy_main=unknown
4357 > fi
4358 > rm -f conftest.err conftest.$ac_objext \
4359 >      conftest$ac_exeext conftest.$ac_ext
4360 >
4361 > if test $ac_cv_fortran_dummy_main = unknown; then
4362 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4363 >     cat >conftest.$ac_ext <<_ACEOF
4364 > /* confdefs.h.  */
4365 > _ACEOF
4366 > cat confdefs.h >>conftest.$ac_ext
4367 > cat >>conftest.$ac_ext <<_ACEOF
4368 > /* end confdefs.h.  */
4369 > #define $ac_fortran_dm_var $ac_func
4370 > #ifdef FC_DUMMY_MAIN
4371 > #ifndef FC_DUMMY_MAIN_EQ_F77
4372 > #  ifdef __cplusplus
4373 >     extern "C"
4374 > #  endif
4375 >   int FC_DUMMY_MAIN() { return 1; }
4376 > #endif
4377 > #endif
4378 > int
4379 > main ()
4380 > {
4381 >
4382 >  ;
4383 >  return 0;
4384 > }
4385 > _ACEOF
4386 > rm -f conftest.$ac_objext conftest$ac_exeext
4387 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4388 >  (eval $ac_link) 2>conftest.er1
4389 >  ac_status=$?
4390 >  grep -v '^ *+' conftest.er1 >conftest.err
4391 >  rm -f conftest.er1
4392 >  cat conftest.err >&5
4393 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4394 >  (exit $ac_status); } &&
4395 >         { ac_try='test -z "$ac_c_werror_flag"
4396 >                         || test ! -s conftest.err'
4397 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4398 >  (eval $ac_try) 2>&5
4399 >  ac_status=$?
4400 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4401 >  (exit $ac_status); }; } &&
4402 >         { ac_try='test -s conftest$ac_exeext'
4403 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4404 >  (eval $ac_try) 2>&5
4405 >  ac_status=$?
4406 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4407 >  (exit $ac_status); }; }; then
4408 >  ac_cv_fortran_dummy_main=$ac_func; break
4409 > else
4410 >  echo "$as_me: failed program was:" >&5
4411 > sed 's/^/| /' conftest.$ac_ext >&5
4412 >
4413 > fi
4414 > rm -f conftest.err conftest.$ac_objext \
4415 >      conftest$ac_exeext conftest.$ac_ext
4416 >   done
4417 > fi
4418 > ac_ext=${FC_SRCEXT-f}
4419 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4420 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4421 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4422 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4423 > rm -f conftest*
4424 > LIBS=$ac_fc_dm_save_LIBS
4425 >
4426 > fi
4427 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4428 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4429 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4430 > if test "$FC_DUMMY_MAIN" != unknown; then
4431 >  if test $FC_DUMMY_MAIN != none; then
4432 >
4433 > cat >>confdefs.h <<_ACEOF
4434 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4435 > _ACEOF
4436 >
4437 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4438 >
4439 > cat >>confdefs.h <<\_ACEOF
4440 > #define FC_DUMMY_MAIN_EQ_F77 1
4441 > _ACEOF
4442 >
4443 >  fi
4444 > fi
4445 > else
4446 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4447 > See \`config.log' for more details." >&5
4448 > echo "$as_me: error: linking to Fortran libraries from C fails
4449 > See \`config.log' for more details." >&2;}
4450 >   { (exit 1); exit 1; }; }
4451 > fi
4452 >
4453 >
4454 > ac_ext=${FC_SRCEXT-f}
4455 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4456 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4457 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4458 >
4459 > ac_ext=${FC_SRCEXT-f}
4460 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4461 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4462 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4463 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4464 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4465 > if test "${ac_cv_fc_mangling+set}" = set; then
4466 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4467 > else
4468 >  cat >conftest.$ac_ext <<_ACEOF
4469 >      subroutine foobar()
4470 >      return
4471 >      end
4472 >      subroutine foo_bar()
4473 >      return
4474 >      end
4475 > _ACEOF
4476 > rm -f conftest.$ac_objext
4477 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4478 >  (eval $ac_compile) 2>conftest.er1
4479 >  ac_status=$?
4480 >  grep -v '^ *+' conftest.er1 >conftest.err
4481 >  rm -f conftest.er1
4482 >  cat conftest.err >&5
4483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4484 >  (exit $ac_status); } &&
4485 >         { ac_try='test -z "$ac_fc_werror_flag"
4486 >                         || test ! -s conftest.err'
4487 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4488 >  (eval $ac_try) 2>&5
4489 >  ac_status=$?
4490 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4491 >  (exit $ac_status); }; } &&
4492 >         { ac_try='test -s conftest.$ac_objext'
4493 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4494 >  (eval $ac_try) 2>&5
4495 >  ac_status=$?
4496 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4497 >  (exit $ac_status); }; }; then
4498 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4499 >
4500 >  ac_save_LIBS=$LIBS
4501 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4502 >
4503 >  ac_ext=c
4504 > ac_cpp='$CPP $CPPFLAGS'
4505 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4506 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4507 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4508 >  ac_success=no
4509 >  for ac_foobar in foobar FOOBAR; do
4510 >    for ac_underscore in "" "_"; do
4511 >      ac_func="$ac_foobar$ac_underscore"
4512 >      cat >conftest.$ac_ext <<_ACEOF
4513 > /* confdefs.h.  */
4514 > _ACEOF
4515 > cat confdefs.h >>conftest.$ac_ext
4516 > cat >>conftest.$ac_ext <<_ACEOF
4517 > /* end confdefs.h.  */
4518 >
4519 > /* Override any gcc2 internal prototype to avoid an error.  */
4520 > #ifdef __cplusplus
4521 > extern "C"
4522 > #endif
4523 > /* We use char because int might match the return type of a gcc2
4524 >   builtin and then its argument prototype would still apply.  */
4525 > char $ac_func ();
4526 > #ifdef FC_DUMMY_MAIN
4527 > #ifndef FC_DUMMY_MAIN_EQ_F77
4528 > #  ifdef __cplusplus
4529 >     extern "C"
4530 > #  endif
4531 >   int FC_DUMMY_MAIN() { return 1; }
4532 > #endif
4533 > #endif
4534 > int
4535 > main ()
4536 > {
4537 > $ac_func ();
4538 >  ;
4539 >  return 0;
4540 > }
4541 > _ACEOF
4542 > rm -f conftest.$ac_objext conftest$ac_exeext
4543 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4544 >  (eval $ac_link) 2>conftest.er1
4545 >  ac_status=$?
4546 >  grep -v '^ *+' conftest.er1 >conftest.err
4547 >  rm -f conftest.er1
4548 >  cat conftest.err >&5
4549 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4550 >  (exit $ac_status); } &&
4551 >         { ac_try='test -z "$ac_c_werror_flag"
4552 >                         || test ! -s conftest.err'
4553 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4554 >  (eval $ac_try) 2>&5
4555 >  ac_status=$?
4556 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4557 >  (exit $ac_status); }; } &&
4558 >         { ac_try='test -s conftest$ac_exeext'
4559 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4560 >  (eval $ac_try) 2>&5
4561 >  ac_status=$?
4562 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4563 >  (exit $ac_status); }; }; then
4564 >  ac_success=yes; break 2
4565 > else
4566 >  echo "$as_me: failed program was:" >&5
4567 > sed 's/^/| /' conftest.$ac_ext >&5
4568 >
4569 > fi
4570 > rm -f conftest.err conftest.$ac_objext \
4571 >      conftest$ac_exeext conftest.$ac_ext
4572 >    done
4573 >  done
4574 >  ac_ext=${FC_SRCEXT-f}
4575 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4576 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4577 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4578 >
4579 >  if test "$ac_success" = "yes"; then
4580 >     case $ac_foobar in
4581 >        foobar)
4582 >           ac_case=lower
4583 >           ac_foo_bar=foo_bar
4584 >           ;;
4585 >        FOOBAR)
4586 >           ac_case=upper
4587 >           ac_foo_bar=FOO_BAR
4588 >           ;;
4589 >     esac
4590 >
4591 >     ac_ext=c
4592 > ac_cpp='$CPP $CPPFLAGS'
4593 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4594 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4595 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4596 >     ac_success_extra=no
4597 >     for ac_extra in "" "_"; do
4598 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 >        cat >conftest.$ac_ext <<_ACEOF
4600 > /* confdefs.h.  */
4601 > _ACEOF
4602 > cat confdefs.h >>conftest.$ac_ext
4603 > cat >>conftest.$ac_ext <<_ACEOF
4604 > /* end confdefs.h.  */
4605 >
4606 > /* Override any gcc2 internal prototype to avoid an error.  */
4607 > #ifdef __cplusplus
4608 > extern "C"
4609 > #endif
4610 > /* We use char because int might match the return type of a gcc2
4611 >   builtin and then its argument prototype would still apply.  */
4612 > char $ac_func ();
4613 > #ifdef FC_DUMMY_MAIN
4614 > #ifndef FC_DUMMY_MAIN_EQ_F77
4615 > #  ifdef __cplusplus
4616 >     extern "C"
4617 > #  endif
4618 >   int FC_DUMMY_MAIN() { return 1; }
4619 > #endif
4620 > #endif
4621 > int
4622 > main ()
4623 > {
4624 > $ac_func ();
4625 >  ;
4626 >  return 0;
4627 > }
4628 > _ACEOF
4629 > rm -f conftest.$ac_objext conftest$ac_exeext
4630 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4631 >  (eval $ac_link) 2>conftest.er1
4632 >  ac_status=$?
4633 >  grep -v '^ *+' conftest.er1 >conftest.err
4634 >  rm -f conftest.er1
4635 >  cat conftest.err >&5
4636 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4637 >  (exit $ac_status); } &&
4638 >         { ac_try='test -z "$ac_c_werror_flag"
4639 >                         || test ! -s conftest.err'
4640 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4641 >  (eval $ac_try) 2>&5
4642 >  ac_status=$?
4643 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4644 >  (exit $ac_status); }; } &&
4645 >         { ac_try='test -s conftest$ac_exeext'
4646 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4647 >  (eval $ac_try) 2>&5
4648 >  ac_status=$?
4649 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4650 >  (exit $ac_status); }; }; then
4651 >  ac_success_extra=yes; break
4652 > else
4653 >  echo "$as_me: failed program was:" >&5
4654 > sed 's/^/| /' conftest.$ac_ext >&5
4655 >
4656 > fi
4657 > rm -f conftest.err conftest.$ac_objext \
4658 >      conftest$ac_exeext conftest.$ac_ext
4659 >     done
4660 >     ac_ext=${FC_SRCEXT-f}
4661 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664 >
4665 >     if test "$ac_success_extra" = "yes"; then
4666 >        ac_cv_fc_mangling="$ac_case case"
4667 >        if test -z "$ac_underscore"; then
4668 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4669 >        else
4670 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4671 >        fi
4672 >        if test -z "$ac_extra"; then
4673 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4674 >        else
4675 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4676 >        fi
4677 >      else
4678 >        ac_cv_fc_mangling="unknown"
4679 >      fi
4680 >  else
4681 >     ac_cv_fc_mangling="unknown"
4682 >  fi
4683 >
4684 >  LIBS=$ac_save_LIBS
4685 >  rm -f cfortran_test* conftest*
4686 > else
4687 >  echo "$as_me: failed program was:" >&5
4688 > sed 's/^/| /' conftest.$ac_ext >&5
4689 >
4690 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4691 > See \`config.log' for more details." >&5
4692 > echo "$as_me: error: cannot compile a simple Fortran program
4693 > See \`config.log' for more details." >&2;}
4694 >   { (exit 1); exit 1; }; }
4695 > fi
4696 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4697 >
4698 > fi
4699 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4700 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4701 >
4702 > ac_ext=${FC_SRCEXT-f}
4703 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4704 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4705 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4706 >
4707 > ac_ext=${FC_SRCEXT-f}
4708 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4709 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4710 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4711 >
4712 >
4713 > case $ac_cv_fc_mangling in
4714 >  "lower case, no underscore, no extra underscore")
4715 >          cat >>confdefs.h <<\_ACEOF
4716 > #define FC_FUNC(name,NAME) name
4717 > _ACEOF
4718 >
4719 >          cat >>confdefs.h <<\_ACEOF
4720 > #define FC_FUNC_(name,NAME) name
4721 > _ACEOF
4722 > ;;
4723 >  "lower case, no underscore, extra underscore")
4724 >          cat >>confdefs.h <<\_ACEOF
4725 > #define FC_FUNC(name,NAME) name
4726 > _ACEOF
4727 >
4728 >          cat >>confdefs.h <<\_ACEOF
4729 > #define FC_FUNC_(name,NAME) name ## _
4730 > _ACEOF
4731 > ;;
4732 >  "lower case, underscore, no extra underscore")
4733 >          cat >>confdefs.h <<\_ACEOF
4734 > #define FC_FUNC(name,NAME) name ## _
4735 > _ACEOF
4736 >
4737 >          cat >>confdefs.h <<\_ACEOF
4738 > #define FC_FUNC_(name,NAME) name ## _
4739 > _ACEOF
4740 > ;;
4741 >  "lower case, underscore, extra underscore")
4742 >          cat >>confdefs.h <<\_ACEOF
4743 > #define FC_FUNC(name,NAME) name ## _
4744 > _ACEOF
4745 >
4746 >          cat >>confdefs.h <<\_ACEOF
4747 > #define FC_FUNC_(name,NAME) name ## __
4748 > _ACEOF
4749 > ;;
4750 >  "upper case, no underscore, no extra underscore")
4751 >          cat >>confdefs.h <<\_ACEOF
4752 > #define FC_FUNC(name,NAME) NAME
4753 > _ACEOF
4754 >
4755 >          cat >>confdefs.h <<\_ACEOF
4756 > #define FC_FUNC_(name,NAME) NAME
4757 > _ACEOF
4758 > ;;
4759 >  "upper case, no underscore, extra underscore")
4760 >          cat >>confdefs.h <<\_ACEOF
4761 > #define FC_FUNC(name,NAME) NAME
4762 > _ACEOF
4763 >
4764 >          cat >>confdefs.h <<\_ACEOF
4765 > #define FC_FUNC_(name,NAME) NAME ## _
4766 > _ACEOF
4767 > ;;
4768 >  "upper case, underscore, no extra underscore")
4769 >          cat >>confdefs.h <<\_ACEOF
4770 > #define FC_FUNC(name,NAME) NAME ## _
4771 > _ACEOF
4772 >
4773 >          cat >>confdefs.h <<\_ACEOF
4774 > #define FC_FUNC_(name,NAME) NAME ## _
4775 > _ACEOF
4776 > ;;
4777 >  "upper case, underscore, extra underscore")
4778 >          cat >>confdefs.h <<\_ACEOF
4779 > #define FC_FUNC(name,NAME) NAME ## _
4780 > _ACEOF
4781 >
4782 >          cat >>confdefs.h <<\_ACEOF
4783 > #define FC_FUNC_(name,NAME) NAME ## __
4784 > _ACEOF
4785 > ;;
4786 >  *)
4787 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4788 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4789 >          ;;
4790 > esac
4791 >
4792 > ac_ext=${FC_SRCEXT-f}
4793 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4794 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4795 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4796 >
4797 >
4798 >
4799 > ac_ext=${FC_SRCEXT-f}
4800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4803 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4804 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4805 > if test "${ac_cv_prog_fc_v+set}" = set; then
4806 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4807 > else
4808 >  cat >conftest.$ac_ext <<_ACEOF
4809 >      program main
4810 >
4811 >      end
4812 > _ACEOF
4813 > rm -f conftest.$ac_objext
4814 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4815 >  (eval $ac_compile) 2>conftest.er1
4816 >  ac_status=$?
4817 >  grep -v '^ *+' conftest.er1 >conftest.err
4818 >  rm -f conftest.er1
4819 >  cat conftest.err >&5
4820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4821 >  (exit $ac_status); } &&
4822 >         { ac_try='test -z "$ac_fc_werror_flag"
4823 >                         || test ! -s conftest.err'
4824 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4825 >  (eval $ac_try) 2>&5
4826 >  ac_status=$?
4827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828 >  (exit $ac_status); }; } &&
4829 >         { ac_try='test -s conftest.$ac_objext'
4830 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4831 >  (eval $ac_try) 2>&5
4832 >  ac_status=$?
4833 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4834 >  (exit $ac_status); }; }; then
4835 >  ac_cv_prog_fc_v=
4836 > # Try some options frequently used verbose output
4837 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4838 >  cat >conftest.$ac_ext <<_ACEOF
4839 >      program main
4840 >
4841 >      end
4842 > _ACEOF
4843 >
4844 > # Compile and link our simple test program by passing a flag (argument
4845 > # 1 to this macro) to the Fortran compiler in order to get
4846 > # "verbose" output that we can then parse for the Fortran linker
4847 > # flags.
4848 > ac_save_FFLAGS=$FCFLAGS
4849 > FCFLAGS="$FCFLAGS $ac_verb"
4850 > (eval echo $as_me:4850: \"$ac_link\") >&5
4851 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4852 > echo "$ac_fc_v_output" >&5
4853 > FCFLAGS=$ac_save_FFLAGS
4854 >
4855 > rm -f conftest*
4856 >
4857 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4858 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4859 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4860 > ac_fc_v_output="`echo $ac_fc_v_output |
4861 >        grep 'LPATH is:' |
4862 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4863 >
4864 > case $ac_fc_v_output in
4865 >  # If we are using xlf then replace all the commas with spaces.
4866 >  *xlfentry*)
4867 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4868 >
4869 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4870 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4871 >  *mGLOB_options_string*)
4872 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4873 >
4874 >  # If we are using Cray Fortran then delete quotes.
4875 >  # Use "\"" instead of '"' for font-lock-mode.
4876 >  # FIXME: a more general fix for quoted arguments with spaces?
4877 >  *cft90*)
4878 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4879 > esac
4880 >
4881 >
4882 >  # look for -l* and *.a constructs in the output
4883 >  for ac_arg in $ac_fc_v_output; do
4884 >     case $ac_arg in
4885 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4886 >          ac_cv_prog_fc_v=$ac_verb
4887 >          break 2 ;;
4888 >     esac
4889 >  done
4890 > done
4891 > if test -z "$ac_cv_prog_fc_v"; then
4892 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4893 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4894 > fi
4895 > else
4896 >  echo "$as_me: failed program was:" >&5
4897 > sed 's/^/| /' conftest.$ac_ext >&5
4898 >
4899 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4900 > echo "$as_me: WARNING: compilation failed" >&2;}
4901 > fi
4902 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4903 >
4904 > fi
4905 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4906 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4907 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4908 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4909 > if test "${ac_cv_fc_libs+set}" = set; then
4910 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4911 > else
4912 >  if test "x$FCLIBS" != "x"; then
4913 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4914 > else
4915 >
4916 > cat >conftest.$ac_ext <<_ACEOF
4917 >      program main
4918 >
4919 >      end
4920 > _ACEOF
4921 >
4922 > # Compile and link our simple test program by passing a flag (argument
4923 > # 1 to this macro) to the Fortran compiler in order to get
4924 > # "verbose" output that we can then parse for the Fortran linker
4925 > # flags.
4926 > ac_save_FFLAGS=$FCFLAGS
4927 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4928 > (eval echo $as_me:4928: \"$ac_link\") >&5
4929 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4930 > echo "$ac_fc_v_output" >&5
4931 > FCFLAGS=$ac_save_FFLAGS
4932 >
4933 > rm -f conftest*
4934 >
4935 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4936 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4937 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4938 > ac_fc_v_output="`echo $ac_fc_v_output |
4939 >        grep 'LPATH is:' |
4940 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4941 >
4942 > case $ac_fc_v_output in
4943 >  # If we are using xlf then replace all the commas with spaces.
4944 >  *xlfentry*)
4945 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4946 >
4947 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4948 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4949 >  *mGLOB_options_string*)
4950 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4951 >
4952 >  # If we are using Cray Fortran then delete quotes.
4953 >  # Use "\"" instead of '"' for font-lock-mode.
4954 >  # FIXME: a more general fix for quoted arguments with spaces?
4955 >  *cft90*)
4956 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4957 > esac
4958 >
4959 >
4960 >
4961 > ac_cv_fc_libs=
4962 >
4963 > # Save positional arguments (if any)
4964 > ac_save_positional="$@"
4965 >
4966 > set X $ac_fc_v_output
4967 > while test $# != 1; do
4968 >  shift
4969 >  ac_arg=$1
4970 >  case $ac_arg in
4971 >        [\\/]*.a | ?:[\\/]*.a)
4972 >            ac_exists=false
4973 >  for ac_i in $ac_cv_fc_libs; do
4974 >    if test x"$ac_arg" = x"$ac_i"; then
4975 >      ac_exists=true
4976 >      break
4977 >    fi
4978 >  done
4979 >
4980 >  if test x"$ac_exists" = xtrue; then
4981 >  :
4982 > else
4983 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4984 > fi
4985 >
4986 >          ;;
4987 >        -bI:*)
4988 >            ac_exists=false
4989 >  for ac_i in $ac_cv_fc_libs; do
4990 >    if test x"$ac_arg" = x"$ac_i"; then
4991 >      ac_exists=true
4992 >      break
4993 >    fi
4994 >  done
4995 >
4996 >  if test x"$ac_exists" = xtrue; then
4997 >  :
4998 > else
4999 >  if test "$ac_compiler_gnu" = yes; then
5000 >  for ac_link_opt in $ac_arg; do
5001 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5002 >  done
5003 > else
5004 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5005 > fi
5006 > fi
5007 >
5008 >          ;;
5009 >          # Ignore these flags.
5010 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5011 >          ;;
5012 >        -lkernel32)
5013 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5014 >          ;;
5015 >        -[LRuY])
5016 >          # These flags, when seen by themselves, take an argument.
5017 >          # We remove the space between option and argument and re-iterate
5018 >          # unless we find an empty arg or a new option (starting with -)
5019 >          case $2 in
5020 >             "" | -*);;
5021 >             *)
5022 >                ac_arg="$ac_arg$2"
5023 >                shift; shift
5024 >                set X $ac_arg "$@"
5025 >                ;;
5026 >          esac
5027 >          ;;
5028 >        -YP,*)
5029 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5030 >              ac_exists=false
5031 >  for ac_i in $ac_cv_fc_libs; do
5032 >    if test x"$ac_j" = x"$ac_i"; then
5033 >      ac_exists=true
5034 >      break
5035 >    fi
5036 >  done
5037 >
5038 >  if test x"$ac_exists" = xtrue; then
5039 >  :
5040 > else
5041 >  ac_arg="$ac_arg $ac_j"
5042 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5043 > fi
5044 >
5045 >          done
5046 >          ;;
5047 >        -[lLR]*)
5048 >            ac_exists=false
5049 >  for ac_i in $ac_cv_fc_libs; do
5050 >    if test x"$ac_arg" = x"$ac_i"; then
5051 >      ac_exists=true
5052 >      break
5053 >    fi
5054 >  done
5055 >
5056 >  if test x"$ac_exists" = xtrue; then
5057 >  :
5058 > else
5059 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5060 > fi
5061 >
5062 >          ;;
5063 >          # Ignore everything else.
5064 >  esac
5065 > done
5066 > # restore positional arguments
5067 > set X $ac_save_positional; shift
5068 >
5069 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5070 > # then we insist that the "run path" must be an absolute path (i.e. it
5071 > # must begin with a "/").
5072 > case `(uname -sr) 2>/dev/null` in
5073 >   "SunOS 5"*)
5074 >      ac_ld_run_path=`echo $ac_fc_v_output |
5075 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5076 >      test "x$ac_ld_run_path" != x &&
5077 >        if test "$ac_compiler_gnu" = yes; then
5078 >  for ac_link_opt in $ac_ld_run_path; do
5079 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5080 >  done
5081 > else
5082 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5083 > fi
5084 >      ;;
5085 > esac
5086 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5087 >
5088 > fi
5089 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5090 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5091 > FCLIBS="$ac_cv_fc_libs"
5092 >
5093 >
5094 > ac_ext=${FC_SRCEXT-f}
5095 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5096 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5097 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5098 >
5099 >
5100 >
5101 > echo "$as_me:$LINENO: checking for module suffix" >&5
5102 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5103 > rm -f conftest*
5104 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5105 > rm -f work*
5106 > cat >conftest.$ac_ext <<EOF
5107 >        module conftest
5108 >        integer n
5109 >        parameter (n=1)
5110 >        end module conftest
5111 > EOF
5112 > # SGI and absoft compilers generates module name in upper case!
5113 > testname="conftest"
5114 > modcase="lower"
5115 > if (eval $ac_compile) 2>/dev/null ; then
5116 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5117 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5118 >    if test -z "$MOD" ; then
5119 >        MOD=`ls CONFTEST* 2>/dev/null \
5120 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5121 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5122 >        if test -n "$MOD" ; then
5123 >            testname="CONFTEST"
5124 >            modcase="upper"
5125 >        fi
5126 >    fi
5127 >    if test -z "$MOD" ; then
5128 >        echo "$as_me:$LINENO: result: unknown" >&5
5129 > echo "${ECHO_T}unknown" >&6
5130 >        # Use mod if we can't figure it out
5131 >        MOD="mod"
5132 >    else
5133 >        echo "$as_me:$LINENO: result: $MOD" >&5
5134 > echo "${ECHO_T}$MOD" >&6
5135 >    fi
5136 >    if test -s work.pcl ; then
5137 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5138 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5139 >    fi
5140 > else
5141 >    echo "$as_me:$LINENO: result: unknown" >&5
5142 > echo "${ECHO_T}unknown" >&6
5143 > fi
5144 >
5145 >
5146 >
5147 >
5148 >
5149 > # Check for module include path (some use -I, some (Solaris) use -M, some
5150 > # (absoft) use -p).
5151 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5152 > # specified, work.pcl and work.pc are created.  However, if you specify
5153 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5154 > # Use the module made above
5155 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5156 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5157 > rm -f conftest*
5158 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5159 > rm -f work*
5160 > cat >conftest.$ac_ext <<EOF
5161 >        module conftest
5162 >        integer n
5163 >        parameter (n=1)
5164 >        end module conftest
5165 > EOF
5166 > # SGI and absoft compilers generates module name in upper case!
5167 > testname="conftest"
5168 > if (eval $ac_compile) 2>/dev/null ; then
5169 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5170 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5171 >   if test -n "$mod" ; then
5172 >      testname="CONFTEST"
5173 >   fi
5174 >   madedir=0
5175 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5176 >   cp $testname.$MOD conf
5177 >   rm -f conftest* CONFTEST*
5178 >   cat >conftest1.$ac_ext <<EOF
5179 >        program main
5180 >        use conftest
5181 >        print *, n
5182 >        end
5183 > EOF
5184 >   F90_WORK_FILES_ARG=""
5185 >   F90MODINCSPEC=""
5186 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5187 >       MODDIRFLAG="-I"
5188 >       F90MODINCSPEC="-I<dir>"
5189 >       echo "$as_me:$LINENO: result: -I" >&5
5190 > echo "${ECHO_T}-I" >&6
5191 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5192 >       MODDIRFLAG="-M"
5193 >       F90MODINCSPEC="-M<dir>"
5194 >       echo "$as_me:$LINENO: result: -M" >&5
5195 > echo "${ECHO_T}-M" >&6
5196 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5197 >       MODDIRFLAG="-p"
5198 >       F90MODINCSPEC="-p<dir>"
5199 >       echo "$as_me:$LINENO: result: -p" >&5
5200 > echo "${ECHO_T}-p" >&6
5201 >   elif test -s work.pc ; then
5202 >        cp work.pc conf/mpimod.pc
5203 >        echo "mpimod.pc" > conf/mpimod.pcl
5204 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5205 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5206 >            MODDIRFLAG='-cl,mpimod.pcl'
5207 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5208 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5209 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5210 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5211 >
5212 >        else
5213 >            # The version of the Intel compiler that I have refuses to let
5214 >            # you put the "work catalog" list anywhere but the current
5215 >            # directory. For example, you cannot in
5216 >         :
5217 >        fi
5218 >   fi
5219 >   if test -z "MODDIRFLAG" ; then
5220 >       echo "$as_me:$LINENO: result: unknown" >&5
5221 > echo "${ECHO_T}unknown" >&6
5222 >   fi
5223 >
5224 >
5225 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5226 >   if test $madedir = 1 ; then rmdir conf ; fi
5227 > fi
5228 >
5229 >
5230 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5231 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5232 > if test "${ac_cv_f90_module_names+set}" = set; then
5233 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5234 > else
5235 >  ac_ext=${FC_SRCEXT-f}
5236 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5237 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5238 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5239 >
5240 > # carry out the test in a new directory, so that we don't miss anything
5241 > mkdir conftest
5242 > cd conftest
5243 > cat >conftest.$ac_ext <<_ACEOF
5244 > MODULE Bar
5245 > END MODULE Bar
5246 > _ACEOF
5247 > rm -f conftest.$ac_objext
5248 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5249 >  (eval $ac_compile) 2>conftest.er1
5250 >  ac_status=$?
5251 >  grep -v '^ *+' conftest.er1 >conftest.err
5252 >  rm -f conftest.er1
5253 >  cat conftest.err >&5
5254 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5255 >  (exit $ac_status); } &&
5256 >         { ac_try='test -z "$ac_fc_werror_flag"
5257 >                         || test ! -s conftest.err'
5258 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5259 >  (eval $ac_try) 2>&5
5260 >  ac_status=$?
5261 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5262 >  (exit $ac_status); }; } &&
5263 >         { ac_try='test -s conftest.$ac_objext'
5264 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5265 >  (eval $ac_try) 2>&5
5266 >  ac_status=$?
5267 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5268 >  (exit $ac_status); }; }; then
5269 >  ac_cv_f90_module_names=
5270 > ac_file_list=*
5271 > for ac_file in $ac_file_list; do
5272 >   case $ac_file in
5273 >      # don't care for original source and object files
5274 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5275 >          :
5276 >          ;;
5277 >      # look for new files derived from the file name
5278 >      *conftest*)
5279 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5280 >            ac_exists=false
5281 >  for ac_i in $ac_cv_f90_module_names; do
5282 >    if test x"$ac_pat" = x"$ac_i"; then
5283 >      ac_exists=true
5284 >      break
5285 >    fi
5286 >  done
5287 >
5288 >  if test x"$ac_exists" = xtrue; then
5289 >  :
5290 > else
5291 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5292 > fi
5293 >
5294 >          ;;
5295 >      # look for new files derived from the module name,
5296 >      # with different case translation schemes
5297 >      *Bar*)
5298 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5299 >            ac_exists=false
5300 >  for ac_i in $ac_cv_f90_module_names; do
5301 >    if test x"$ac_pat" = x"$ac_i"; then
5302 >      ac_exists=true
5303 >      break
5304 >    fi
5305 >  done
5306 >
5307 >  if test x"$ac_exists" = xtrue; then
5308 >  :
5309 > else
5310 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5311 > fi
5312 >
5313 >          ;;
5314 >      *bar*)
5315 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5316 >            ac_exists=false
5317 >  for ac_i in $ac_cv_f90_module_names; do
5318 >    if test x"$ac_pat" = x"$ac_i"; then
5319 >      ac_exists=true
5320 >      break
5321 >    fi
5322 >  done
5323 >
5324 >  if test x"$ac_exists" = xtrue; then
5325 >  :
5326 > else
5327 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5328 > fi
5329 >
5330 >          ;;
5331 >      *BAR*)
5332 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5333 >            ac_exists=false
5334 >  for ac_i in $ac_cv_f90_module_names; do
5335 >    if test x"$ac_pat" = x"$ac_i"; then
5336 >      ac_exists=true
5337 >      break
5338 >    fi
5339 >  done
5340 >
5341 >  if test x"$ac_exists" = xtrue; then
5342 >  :
5343 > else
5344 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5345 > fi
5346 >
5347 >          ;;
5348 >       # Other files - we have no idea how they are generated
5349 >       *)
5350 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5351 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5352 >          ;;
5353 >   esac
5354 > done
5355 > if test "x$ac_cv_f90_module_names" = "x"; then
5356 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5357 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5358 > fi
5359 >
5360 > else
5361 >  echo "$as_me: failed program was:" >&5
5362 > sed 's/^/| /' conftest.$ac_ext >&5
5363 >
5364 > ac_cv_f90_module_names=
5365 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5366 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5367 > fi
5368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5369 > cd ..
5370 > # cleanup
5371 > rm -rf conftest
5372 > ac_ext=${FC_SRCEXT-f}
5373 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5374 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5375 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5376 >
5377 > fi
5378 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5379 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5380 >
5381 > # We now generate a shell script that will help us to figure out the correct
5382 > # module file names, using the value of ac_cv_f90_module_names
5383 >
5384 > echo "Generating shell script modnam"
5385 >
5386 > cat > scripts/modnam << EOF
5387 > #! /bin/sh
5388 > # This script is auto-generated by configure
5389 > #
5390 > usage="\\
5391 > Usage: \$0 [FILES]
5392 >
5393 > [FILES] are Fortran 90 source files.
5394 > The output is a list of module file names that the Fortran 90 compiler
5395 > generates when compiling [FILES]."
5396 >
5397 > list=
5398 > empty=
5399 >
5400 > if test \$# -eq 0; then
5401 >   echo "\$usage"; exit 0
5402 > fi
5403 >
5404 > while test \$# != 0; do
5405 >
5406 >  file=\$1
5407 >  shift
5408 >
5409 > # strip suffix
5410 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5411 >
5412 >  test ! -f \$file && continue
5413 >
5414 > # Look for module definitions and transform them to upper / lower case
5415 >  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
5416 >  upper=\`echo \$mods | tr a-z A-Z\`
5417 >  lower=\`echo \$mods | tr A-Z a-z\`
5418 >
5419 > # Here, the patterns for generating module file names were inserted by configure
5420 >  for trans in $ac_cv_f90_module_names; do
5421 >
5422 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5423 >    var=empty
5424 >    case \$pat in
5425 >       %MODULE%)
5426 >          var=upper ;;
5427 >       %Module%)
5428 >          var=mods ;;
5429 >       %module%)
5430 >          var=lower ;;
5431 >       %FILE%)
5432 >          test -n "\$mods" && var=base ;;
5433 >    esac
5434 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5435 >    list="\$list \$new"
5436 >  done
5437 > done
5438 >
5439 > echo \$list
5440 > # end of configure-generated script
5441 > EOF
5442 > chmod 755 scripts/modnam
5443 >
5444 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5445 > F90_MODULE_NAMES=empty
5446 > case $pat in
5447 >       %MODULE%)
5448 >          F90_MODULE_NAMES=UPPER ;;
5449 >       %Module%)
5450 >          F90_MODULE_NAMES=Mixed ;;
5451 >       %module%)
5452 >          F90_MODULE_NAMES=lower ;;
5453 >       *)
5454 >          F90_MODULE_NAMES=unknown ;;
5455 > esac
5456 >
5457 > ac_ext=c
5458 > ac_cpp='$CPP $CPPFLAGS'
5459 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5460 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5461 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5462 >
5463 >
5464 > ac_ext=c
5465 > ac_cpp='$CPP $CPPFLAGS'
5466 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5467 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5468 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5469 >
5470 >
5471 >
5472 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5473 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5474 > if test "${ac_cv_lib_m_asin+set}" = set; then
5475 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5476 > else
5477 >  ac_check_lib_save_LIBS=$LIBS
5478 > LIBS="-lm  $LIBS"
5479 > cat >conftest.$ac_ext <<_ACEOF
5480 > /* confdefs.h.  */
5481 > _ACEOF
5482 > cat confdefs.h >>conftest.$ac_ext
5483 > cat >>conftest.$ac_ext <<_ACEOF
5484 > /* end confdefs.h.  */
5485 >
5486 > /* Override any gcc2 internal prototype to avoid an error.  */
5487 > #ifdef __cplusplus
5488 > extern "C"
5489 > #endif
5490 > /* We use char because int might match the return type of a gcc2
5491 >   builtin and then its argument prototype would still apply.  */
5492 > char asin ();
5493 > #ifdef FC_DUMMY_MAIN
5494 > #ifndef FC_DUMMY_MAIN_EQ_F77
5495 > #  ifdef __cplusplus
5496 >     extern "C"
5497 > #  endif
5498 >   int FC_DUMMY_MAIN() { return 1; }
5499 > #endif
5500 > #endif
5501 > int
5502 > main ()
5503 > {
5504 > asin ();
5505 >  ;
5506 >  return 0;
5507 > }
5508 > _ACEOF
5509 > rm -f conftest.$ac_objext conftest$ac_exeext
5510 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5511 >  (eval $ac_link) 2>conftest.er1
5512 >  ac_status=$?
5513 >  grep -v '^ *+' conftest.er1 >conftest.err
5514 >  rm -f conftest.er1
5515 >  cat conftest.err >&5
5516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5517 >  (exit $ac_status); } &&
5518 >         { ac_try='test -z "$ac_c_werror_flag"
5519 >                         || test ! -s conftest.err'
5520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5521 >  (eval $ac_try) 2>&5
5522 >  ac_status=$?
5523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5524 >  (exit $ac_status); }; } &&
5525 >         { ac_try='test -s conftest$ac_exeext'
5526 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5527 >  (eval $ac_try) 2>&5
5528 >  ac_status=$?
5529 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5530 >  (exit $ac_status); }; }; then
5531 >  ac_cv_lib_m_asin=yes
5532 > else
5533 >  echo "$as_me: failed program was:" >&5
5534 > sed 's/^/| /' conftest.$ac_ext >&5
5535 >
5536 > ac_cv_lib_m_asin=no
5537 > fi
5538 > rm -f conftest.err conftest.$ac_objext \
5539 >      conftest$ac_exeext conftest.$ac_ext
5540 > LIBS=$ac_check_lib_save_LIBS
5541 > fi
5542 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5543 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5544 > if test $ac_cv_lib_m_asin = yes; then
5545 >  cat >>confdefs.h <<_ACEOF
5546 > #define HAVE_LIBM 1
5547 > _ACEOF
5548 >
5549 >  LIBS="-lm $LIBS"
5550 >
5551 > else
5552 >  exit
5553 > fi
5554 >
5555 >
5556 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5557 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5558 > if test "${ac_cv_header_stdc+set}" = set; then
5559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5560 > else
5561 >  cat >conftest.$ac_ext <<_ACEOF
5562 > /* confdefs.h.  */
5563 > _ACEOF
5564 > cat confdefs.h >>conftest.$ac_ext
5565 > cat >>conftest.$ac_ext <<_ACEOF
5566 > /* end confdefs.h.  */
5567 > #include <stdlib.h>
5568 > #include <stdarg.h>
5569 > #include <string.h>
5570 > #include <float.h>
5571 >
5572 > #ifdef FC_DUMMY_MAIN
5573 > #ifndef FC_DUMMY_MAIN_EQ_F77
5574 > #  ifdef __cplusplus
5575 >     extern "C"
5576 > #  endif
5577 >   int FC_DUMMY_MAIN() { return 1; }
5578 > #endif
5579 > #endif
5580 > int
5581 > main ()
5582 > {
5583 >
5584 >  ;
5585 >  return 0;
5586 > }
5587 > _ACEOF
5588 > rm -f conftest.$ac_objext
5589 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5590 >  (eval $ac_compile) 2>conftest.er1
5591 >  ac_status=$?
5592 >  grep -v '^ *+' conftest.er1 >conftest.err
5593 >  rm -f conftest.er1
5594 >  cat conftest.err >&5
5595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5596 >  (exit $ac_status); } &&
5597 >         { ac_try='test -z "$ac_c_werror_flag"
5598 >                         || test ! -s conftest.err'
5599 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5600 >  (eval $ac_try) 2>&5
5601 >  ac_status=$?
5602 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603 >  (exit $ac_status); }; } &&
5604 >         { ac_try='test -s conftest.$ac_objext'
5605 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5606 >  (eval $ac_try) 2>&5
5607 >  ac_status=$?
5608 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5609 >  (exit $ac_status); }; }; then
5610 >  ac_cv_header_stdc=yes
5611 > else
5612 >  echo "$as_me: failed program was:" >&5
5613 > sed 's/^/| /' conftest.$ac_ext >&5
5614 >
5615 > ac_cv_header_stdc=no
5616 > fi
5617 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5618 >
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5621 >  cat >conftest.$ac_ext <<_ACEOF
5622 > /* confdefs.h.  */
5623 > _ACEOF
5624 > cat confdefs.h >>conftest.$ac_ext
5625 > cat >>conftest.$ac_ext <<_ACEOF
5626 > /* end confdefs.h.  */
5627 > #include <string.h>
5628 >
5629 > _ACEOF
5630 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5631 >  $EGREP "memchr" >/dev/null 2>&1; then
5632 >  :
5633 > else
5634 >  ac_cv_header_stdc=no
5635 > fi
5636 > rm -f conftest*
5637 >
5638 > fi
5639 >
5640 > if test $ac_cv_header_stdc = yes; then
5641 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5642 >  cat >conftest.$ac_ext <<_ACEOF
5643 > /* confdefs.h.  */
5644 > _ACEOF
5645 > cat confdefs.h >>conftest.$ac_ext
5646 > cat >>conftest.$ac_ext <<_ACEOF
5647 > /* end confdefs.h.  */
5648 > #include <stdlib.h>
5649 >
5650 > _ACEOF
5651 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5652 >  $EGREP "free" >/dev/null 2>&1; then
5653 >  :
5654 > else
5655 >  ac_cv_header_stdc=no
5656 > fi
5657 > rm -f conftest*
5658 >
5659 > fi
5660 >
5661 > if test $ac_cv_header_stdc = yes; then
5662 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5663 >  if test "$cross_compiling" = yes; then
5664 >  :
5665 > else
5666 >  cat >conftest.$ac_ext <<_ACEOF
5667 > /* confdefs.h.  */
5668 > _ACEOF
5669 > cat confdefs.h >>conftest.$ac_ext
5670 > cat >>conftest.$ac_ext <<_ACEOF
5671 > /* end confdefs.h.  */
5672 > #include <ctype.h>
5673 > #if ((' ' & 0x0FF) == 0x020)
5674 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5675 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5676 > #else
5677 > # define ISLOWER(c) \
5678 >                   (('a' <= (c) && (c) <= 'i') \
5679 >                     || ('j' <= (c) && (c) <= 'r') \
5680 >                     || ('s' <= (c) && (c) <= 'z'))
5681 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5682 > #endif
5683 >
5684 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5685 > int
5686 > main ()
5687 > {
5688 >  int i;
5689 >  for (i = 0; i < 256; i++)
5690 >    if (XOR (islower (i), ISLOWER (i))
5691 >        || toupper (i) != TOUPPER (i))
5692 >      exit(2);
5693 >  exit (0);
5694 > }
5695 > _ACEOF
5696 > rm -f conftest$ac_exeext
5697 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5698 >  (eval $ac_link) 2>&5
5699 >  ac_status=$?
5700 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5701 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5702 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5703 >  (eval $ac_try) 2>&5
5704 >  ac_status=$?
5705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5706 >  (exit $ac_status); }; }; then
5707 >  :
5708 > else
5709 >  echo "$as_me: program exited with status $ac_status" >&5
5710 > echo "$as_me: failed program was:" >&5
5711 > sed 's/^/| /' conftest.$ac_ext >&5
5712 >
5713 > ( exit $ac_status )
5714 > ac_cv_header_stdc=no
5715 > fi
5716 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5717 > fi
5718 > fi
5719 > fi
5720 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5721 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5722 > if test $ac_cv_header_stdc = yes; then
5723 >
5724 > cat >>confdefs.h <<\_ACEOF
5725 > #define STDC_HEADERS 1
5726 > _ACEOF
5727 >
5728 > fi
5729 >
5730 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5731 >
5732 >
5733 >
5734 >
5735 >
5736 >
5737 >
5738 >
5739 >
5740 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5741 >                  inttypes.h stdint.h unistd.h
5742 > do
5743 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5744 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5745 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5746 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5747 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5748 > else
5749 >  cat >conftest.$ac_ext <<_ACEOF
5750 > /* confdefs.h.  */
5751 > _ACEOF
5752 > cat confdefs.h >>conftest.$ac_ext
5753 > cat >>conftest.$ac_ext <<_ACEOF
5754 > /* end confdefs.h.  */
5755 > $ac_includes_default
5756 >
5757 > #include <$ac_header>
5758 > _ACEOF
5759 > rm -f conftest.$ac_objext
5760 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5761 >  (eval $ac_compile) 2>conftest.er1
5762 >  ac_status=$?
5763 >  grep -v '^ *+' conftest.er1 >conftest.err
5764 >  rm -f conftest.er1
5765 >  cat conftest.err >&5
5766 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5767 >  (exit $ac_status); } &&
5768 >         { ac_try='test -z "$ac_c_werror_flag"
5769 >                         || test ! -s conftest.err'
5770 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5771 >  (eval $ac_try) 2>&5
5772 >  ac_status=$?
5773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5774 >  (exit $ac_status); }; } &&
5775 >         { ac_try='test -s conftest.$ac_objext'
5776 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5777 >  (eval $ac_try) 2>&5
5778 >  ac_status=$?
5779 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5780 >  (exit $ac_status); }; }; then
5781 >  eval "$as_ac_Header=yes"
5782 > else
5783 >  echo "$as_me: failed program was:" >&5
5784 > sed 's/^/| /' conftest.$ac_ext >&5
5785 >
5786 > eval "$as_ac_Header=no"
5787 > fi
5788 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5789 > fi
5790 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5791 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5792 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5793 >  cat >>confdefs.h <<_ACEOF
5794 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5795 > _ACEOF
5796 >
5797 > fi
5798 >
5799 > done
5800 >
5801 >
5802 > #
5803 > # Handle user hints
5804 > #
5805 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5806 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5807 >
5808 > # Check whether --with-zlib or --without-zlib was given.
5809 > if test "${with_zlib+set}" = set; then
5810 >  withval="$with_zlib"
5811 >  if test "$withval" != no ; then
5812 >  echo "$as_me:$LINENO: result: yes" >&5
5813 > echo "${ECHO_T}yes" >&6
5814 >  if test -d "$withval"
5815 >  then
5816 >    ZLIB_HOME="$withval"
5817 >  else
5818 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5819 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5820 >  fi
5821 > else
5822 >  echo "$as_me:$LINENO: result: no" >&5
5823 > echo "${ECHO_T}no" >&6
5824 > fi
5825 > fi;
5826 >
5827 > ZLIB_HOME=/usr/local
5828 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5829 > then
5830 >        ZLIB_HOME=/usr
5831 > fi
5832 >
5833 > #
5834 > # Locate zlib, if wanted
5835 > #
5836 > if test -n "${ZLIB_HOME}"
5837 > then
5838 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5839 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5840 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5841 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5842 >
5843 >
5844 >        ac_ext=c
5845 > ac_cpp='$CPP $CPPFLAGS'
5846 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5847 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5848 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5849 >
5850 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5851 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5852 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5853 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5854 > else
5855 >  ac_check_lib_save_LIBS=$LIBS
5856 > LIBS="-lz  $LIBS"
5857 > cat >conftest.$ac_ext <<_ACEOF
5858 > /* confdefs.h.  */
5859 > _ACEOF
5860 > cat confdefs.h >>conftest.$ac_ext
5861 > cat >>conftest.$ac_ext <<_ACEOF
5862 > /* end confdefs.h.  */
5863 >
5864 > /* Override any gcc2 internal prototype to avoid an error.  */
5865 > #ifdef __cplusplus
5866 > extern "C"
5867 > #endif
5868 > /* We use char because int might match the return type of a gcc2
5869 >   builtin and then its argument prototype would still apply.  */
5870 > char inflateEnd ();
5871 > #ifdef FC_DUMMY_MAIN
5872 > #ifndef FC_DUMMY_MAIN_EQ_F77
5873 > #  ifdef __cplusplus
5874 >     extern "C"
5875 > #  endif
5876 >   int FC_DUMMY_MAIN() { return 1; }
5877 > #endif
5878 > #endif
5879 > int
5880 > main ()
5881 > {
5882 > inflateEnd ();
5883 >  ;
5884 >  return 0;
5885 > }
5886 > _ACEOF
5887 > rm -f conftest.$ac_objext conftest$ac_exeext
5888 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5889 >  (eval $ac_link) 2>conftest.er1
5890 >  ac_status=$?
5891 >  grep -v '^ *+' conftest.er1 >conftest.err
5892 >  rm -f conftest.er1
5893 >  cat conftest.err >&5
5894 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5895 >  (exit $ac_status); } &&
5896 >         { ac_try='test -z "$ac_c_werror_flag"
5897 >                         || test ! -s conftest.err'
5898 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5899 >  (eval $ac_try) 2>&5
5900 >  ac_status=$?
5901 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5902 >  (exit $ac_status); }; } &&
5903 >         { ac_try='test -s conftest$ac_exeext'
5904 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5905 >  (eval $ac_try) 2>&5
5906 >  ac_status=$?
5907 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5908 >  (exit $ac_status); }; }; then
5909 >  ac_cv_lib_z_inflateEnd=yes
5910 > else
5911 >  echo "$as_me: failed program was:" >&5
5912 > sed 's/^/| /' conftest.$ac_ext >&5
5913 >
5914 > ac_cv_lib_z_inflateEnd=no
5915 > fi
5916 > rm -f conftest.err conftest.$ac_objext \
5917 >      conftest$ac_exeext conftest.$ac_ext
5918 > LIBS=$ac_check_lib_save_LIBS
5919 > fi
5920 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5921 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5922 > if test $ac_cv_lib_z_inflateEnd = yes; then
5923 >  zlib_cv_libz=yes
5924 > else
5925 >  zlib_cv_libz=no
5926 > fi
5927 >
5928 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5929 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5930 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5931 > if test "${ac_cv_header_zlib_h+set}" = set; then
5932 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5933 > fi
5934 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5935 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5936 > else
5937 >  # Is the header compilable?
5938 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5939 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5940 > cat >conftest.$ac_ext <<_ACEOF
5941 > /* confdefs.h.  */
5942 > _ACEOF
5943 > cat confdefs.h >>conftest.$ac_ext
5944 > cat >>conftest.$ac_ext <<_ACEOF
5945 > /* end confdefs.h.  */
5946 > $ac_includes_default
5947 > #include <zlib.h>
5948 > _ACEOF
5949 > rm -f conftest.$ac_objext
5950 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5951 >  (eval $ac_compile) 2>conftest.er1
5952 >  ac_status=$?
5953 >  grep -v '^ *+' conftest.er1 >conftest.err
5954 >  rm -f conftest.er1
5955 >  cat conftest.err >&5
5956 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5957 >  (exit $ac_status); } &&
5958 >         { ac_try='test -z "$ac_c_werror_flag"
5959 >                         || test ! -s conftest.err'
5960 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5961 >  (eval $ac_try) 2>&5
5962 >  ac_status=$?
5963 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5964 >  (exit $ac_status); }; } &&
5965 >         { ac_try='test -s conftest.$ac_objext'
5966 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5967 >  (eval $ac_try) 2>&5
5968 >  ac_status=$?
5969 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5970 >  (exit $ac_status); }; }; then
5971 >  ac_header_compiler=yes
5972 > else
5973 >  echo "$as_me: failed program was:" >&5
5974 > sed 's/^/| /' conftest.$ac_ext >&5
5975 >
5976 > ac_header_compiler=no
5977 > fi
5978 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5979 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5980 > echo "${ECHO_T}$ac_header_compiler" >&6
5981 >
5982 > # Is the header present?
5983 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5984 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5985 > cat >conftest.$ac_ext <<_ACEOF
5986 > /* confdefs.h.  */
5987 > _ACEOF
5988 > cat confdefs.h >>conftest.$ac_ext
5989 > cat >>conftest.$ac_ext <<_ACEOF
5990 > /* end confdefs.h.  */
5991 > #include <zlib.h>
5992 > _ACEOF
5993 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5994 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5995 >  ac_status=$?
5996 >  grep -v '^ *+' conftest.er1 >conftest.err
5997 >  rm -f conftest.er1
5998 >  cat conftest.err >&5
5999 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6000 >  (exit $ac_status); } >/dev/null; then
6001 >  if test -s conftest.err; then
6002 >    ac_cpp_err=$ac_c_preproc_warn_flag
6003 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6004 >  else
6005 >    ac_cpp_err=
6006 >  fi
6007 > else
6008 >  ac_cpp_err=yes
6009 > fi
6010 > if test -z "$ac_cpp_err"; then
6011 >  ac_header_preproc=yes
6012 > else
6013 >  echo "$as_me: failed program was:" >&5
6014 > sed 's/^/| /' conftest.$ac_ext >&5
6015 >
6016 >  ac_header_preproc=no
6017 > fi
6018 > rm -f conftest.err conftest.$ac_ext
6019 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6020 > echo "${ECHO_T}$ac_header_preproc" >&6
6021 >
6022 > # So?  What about this header?
6023 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6024 >  yes:no: )
6025 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6026 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6027 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6028 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6029 >    ac_header_preproc=yes
6030 >    ;;
6031 >  no:yes:* )
6032 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6033 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6034 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6035 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6036 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6037 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6038 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6039 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6040 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6041 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6042 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6043 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6044 >    (
6045 >      cat <<\_ASBOX
6046 > ## ------------------------------ ##
6047 > ## Report this to gezelter@nd.edu ##
6048 > ## ------------------------------ ##
6049 > _ASBOX
6050 >    ) |
6051 >      sed "s/^/$as_me: WARNING:     /" >&2
6052 >    ;;
6053 > esac
6054 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6055 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6056 > if test "${ac_cv_header_zlib_h+set}" = set; then
6057 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6058 > else
6059 >  ac_cv_header_zlib_h=$ac_header_preproc
6060 > fi
6061 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6062 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6063 >
6064 > fi
6065 > if test $ac_cv_header_zlib_h = yes; then
6066 >  zlib_cv_zlib_h=yes
6067 > else
6068 >  zlib_cv_zlib_h=no
6069 > fi
6070 >
6071 >
6072 >        ac_ext=c
6073 > ac_cpp='$CPP $CPPFLAGS'
6074 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6075 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6076 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6077 >
6078 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6079 >        then
6080 >                #
6081 >                # If both library and header were found, use them
6082 >                #
6083 >
6084 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6085 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6086 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6087 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6088 > else
6089 >  ac_check_lib_save_LIBS=$LIBS
6090 > LIBS="-lz  $LIBS"
6091 > cat >conftest.$ac_ext <<_ACEOF
6092 > /* confdefs.h.  */
6093 > _ACEOF
6094 > cat confdefs.h >>conftest.$ac_ext
6095 > cat >>conftest.$ac_ext <<_ACEOF
6096 > /* end confdefs.h.  */
6097 >
6098 > /* Override any gcc2 internal prototype to avoid an error.  */
6099 > #ifdef __cplusplus
6100 > extern "C"
6101 > #endif
6102 > /* We use char because int might match the return type of a gcc2
6103 >   builtin and then its argument prototype would still apply.  */
6104 > char inflateEnd ();
6105 > #ifdef FC_DUMMY_MAIN
6106 > #ifndef FC_DUMMY_MAIN_EQ_F77
6107 > #  ifdef __cplusplus
6108 >     extern "C"
6109 > #  endif
6110 >   int FC_DUMMY_MAIN() { return 1; }
6111 > #endif
6112 > #endif
6113 > int
6114 > main ()
6115 > {
6116 > inflateEnd ();
6117 >  ;
6118 >  return 0;
6119 > }
6120 > _ACEOF
6121 > rm -f conftest.$ac_objext conftest$ac_exeext
6122 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6123 >  (eval $ac_link) 2>conftest.er1
6124 >  ac_status=$?
6125 >  grep -v '^ *+' conftest.er1 >conftest.err
6126 >  rm -f conftest.er1
6127 >  cat conftest.err >&5
6128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6129 >  (exit $ac_status); } &&
6130 >         { ac_try='test -z "$ac_c_werror_flag"
6131 >                         || test ! -s conftest.err'
6132 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6133 >  (eval $ac_try) 2>&5
6134 >  ac_status=$?
6135 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6136 >  (exit $ac_status); }; } &&
6137 >         { ac_try='test -s conftest$ac_exeext'
6138 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6139 >  (eval $ac_try) 2>&5
6140 >  ac_status=$?
6141 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6142 >  (exit $ac_status); }; }; then
6143 >  ac_cv_lib_z_inflateEnd=yes
6144 > else
6145 >  echo "$as_me: failed program was:" >&5
6146 > sed 's/^/| /' conftest.$ac_ext >&5
6147 >
6148 > ac_cv_lib_z_inflateEnd=no
6149 > fi
6150 > rm -f conftest.err conftest.$ac_objext \
6151 >      conftest$ac_exeext conftest.$ac_ext
6152 > LIBS=$ac_check_lib_save_LIBS
6153 > fi
6154 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6155 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6156 > if test $ac_cv_lib_z_inflateEnd = yes; then
6157 >  cat >>confdefs.h <<_ACEOF
6158 > #define HAVE_LIBZ 1
6159 > _ACEOF
6160 >
6161 >  LIBS="-lz $LIBS"
6162 >
6163 > fi
6164 >
6165 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6166 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6167 >                echo "$as_me:$LINENO: result: ok" >&5
6168 > echo "${ECHO_T}ok" >&6
6169 >        else
6170 >                #
6171 >                # If either header or library was not found, revert and bomb
6172 >                #
6173 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6174 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6175 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6176 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6177 >                echo "$as_me:$LINENO: result: failed" >&5
6178 > echo "${ECHO_T}failed" >&6
6179 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6180 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6181 >   { (exit 1); exit 1; }; }
6182 >        fi
6183 > fi
6184 >
6185 >
6186 > #
6187 > # Handle user hints
6188 > #
6189 >
6190 > # Check whether --with-fftw or --without-fftw was given.
6191 > if test "${with_fftw+set}" = set; then
6192 >  withval="$with_fftw"
6193 >  fftw_dir="$withval"
6194 > else
6195 >                fftw_dir="not_set"
6196 > fi;
6197 > if test "$fftw_dir" != "no"; then
6198 >
6199 > if test "$fftw_dir" != "not_set" ; then
6200 >  if test -d "$fftw_dir"
6201 >  then
6202 >    FFTW_HOME="$fftw_dir"
6203 >  else
6204 >    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6205 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6206 >  fi
6207 > fi
6208 >
6209 > FFTW_HOME=/usr/local
6210 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6211 > then
6212 >        FFTW_HOME=/usr
6213 > fi
6214 >
6215 > #
6216 > # Locate fftw, if wanted
6217 > #
6218 > if test -n "${FFTW_HOME}"
6219 > then
6220 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6221 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6222 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6223 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6224 >
6225 >
6226 >        ac_ext=c
6227 > ac_cpp='$CPP $CPPFLAGS'
6228 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6229 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6230 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6231 >
6232 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6233 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6234 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6235 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6236 > else
6237 >  ac_check_lib_save_LIBS=$LIBS
6238 > LIBS="-lfftw3  $LIBS"
6239 > cat >conftest.$ac_ext <<_ACEOF
6240 > /* confdefs.h.  */
6241 > _ACEOF
6242 > cat confdefs.h >>conftest.$ac_ext
6243 > cat >>conftest.$ac_ext <<_ACEOF
6244 > /* end confdefs.h.  */
6245 >
6246 > /* Override any gcc2 internal prototype to avoid an error.  */
6247 > #ifdef __cplusplus
6248 > extern "C"
6249 > #endif
6250 > /* We use char because int might match the return type of a gcc2
6251 >   builtin and then its argument prototype would still apply.  */
6252 > char fftw_execute ();
6253 > #ifdef FC_DUMMY_MAIN
6254 > #ifndef FC_DUMMY_MAIN_EQ_F77
6255 > #  ifdef __cplusplus
6256 >     extern "C"
6257 > #  endif
6258 >   int FC_DUMMY_MAIN() { return 1; }
6259 > #endif
6260 > #endif
6261 > int
6262 > main ()
6263 > {
6264 > fftw_execute ();
6265 >  ;
6266 >  return 0;
6267 > }
6268 > _ACEOF
6269 > rm -f conftest.$ac_objext conftest$ac_exeext
6270 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6271 >  (eval $ac_link) 2>conftest.er1
6272 >  ac_status=$?
6273 >  grep -v '^ *+' conftest.er1 >conftest.err
6274 >  rm -f conftest.er1
6275 >  cat conftest.err >&5
6276 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6277 >  (exit $ac_status); } &&
6278 >         { ac_try='test -z "$ac_c_werror_flag"
6279 >                         || test ! -s conftest.err'
6280 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6281 >  (eval $ac_try) 2>&5
6282 >  ac_status=$?
6283 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6284 >  (exit $ac_status); }; } &&
6285 >         { ac_try='test -s conftest$ac_exeext'
6286 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6287 >  (eval $ac_try) 2>&5
6288 >  ac_status=$?
6289 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6290 >  (exit $ac_status); }; }; then
6291 >  ac_cv_lib_fftw3_fftw_execute=yes
6292 > else
6293 >  echo "$as_me: failed program was:" >&5
6294 > sed 's/^/| /' conftest.$ac_ext >&5
6295 >
6296 > ac_cv_lib_fftw3_fftw_execute=no
6297 > fi
6298 > rm -f conftest.err conftest.$ac_objext \
6299 >      conftest$ac_exeext conftest.$ac_ext
6300 > LIBS=$ac_check_lib_save_LIBS
6301 > fi
6302 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6303 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6304 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6305 >  fftw_cv_libfftw3=yes
6306 > else
6307 >  fftw_cv_libfftw3=no
6308 > fi
6309 >
6310 >        if test "${ac_cv_header_fftw3_h+set}" = set; then
6311 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6312 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6313 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6314 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6315 > fi
6316 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6317 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6318 > else
6319 >  # Is the header compilable?
6320 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6321 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6322 > cat >conftest.$ac_ext <<_ACEOF
6323 > /* confdefs.h.  */
6324 > _ACEOF
6325 > cat confdefs.h >>conftest.$ac_ext
6326 > cat >>conftest.$ac_ext <<_ACEOF
6327 > /* end confdefs.h.  */
6328 > $ac_includes_default
6329 > #include <fftw3.h>
6330 > _ACEOF
6331 > rm -f conftest.$ac_objext
6332 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6333 >  (eval $ac_compile) 2>conftest.er1
6334 >  ac_status=$?
6335 >  grep -v '^ *+' conftest.er1 >conftest.err
6336 >  rm -f conftest.er1
6337 >  cat conftest.err >&5
6338 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6339 >  (exit $ac_status); } &&
6340 >         { ac_try='test -z "$ac_c_werror_flag"
6341 >                         || test ! -s conftest.err'
6342 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6343 >  (eval $ac_try) 2>&5
6344 >  ac_status=$?
6345 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6346 >  (exit $ac_status); }; } &&
6347 >         { ac_try='test -s conftest.$ac_objext'
6348 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6349 >  (eval $ac_try) 2>&5
6350 >  ac_status=$?
6351 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6352 >  (exit $ac_status); }; }; then
6353 >  ac_header_compiler=yes
6354 > else
6355 >  echo "$as_me: failed program was:" >&5
6356 > sed 's/^/| /' conftest.$ac_ext >&5
6357 >
6358 > ac_header_compiler=no
6359 > fi
6360 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6361 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6362 > echo "${ECHO_T}$ac_header_compiler" >&6
6363 >
6364 > # Is the header present?
6365 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6366 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6367 > cat >conftest.$ac_ext <<_ACEOF
6368 > /* confdefs.h.  */
6369 > _ACEOF
6370 > cat confdefs.h >>conftest.$ac_ext
6371 > cat >>conftest.$ac_ext <<_ACEOF
6372 > /* end confdefs.h.  */
6373 > #include <fftw3.h>
6374 > _ACEOF
6375 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6376 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6377 >  ac_status=$?
6378 >  grep -v '^ *+' conftest.er1 >conftest.err
6379 >  rm -f conftest.er1
6380 >  cat conftest.err >&5
6381 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6382 >  (exit $ac_status); } >/dev/null; then
6383 >  if test -s conftest.err; then
6384 >    ac_cpp_err=$ac_c_preproc_warn_flag
6385 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6386 >  else
6387 >    ac_cpp_err=
6388 >  fi
6389 > else
6390 >  ac_cpp_err=yes
6391 > fi
6392 > if test -z "$ac_cpp_err"; then
6393 >  ac_header_preproc=yes
6394 > else
6395 >  echo "$as_me: failed program was:" >&5
6396 > sed 's/^/| /' conftest.$ac_ext >&5
6397 >
6398 >  ac_header_preproc=no
6399 > fi
6400 > rm -f conftest.err conftest.$ac_ext
6401 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6402 > echo "${ECHO_T}$ac_header_preproc" >&6
6403 >
6404 > # So?  What about this header?
6405 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6406 >  yes:no: )
6407 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6408 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6409 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6410 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6411 >    ac_header_preproc=yes
6412 >    ;;
6413 >  no:yes:* )
6414 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6415 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6416 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6417 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6418 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6419 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6420 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6421 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6422 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6423 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6424 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6425 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6426 >    (
6427 >      cat <<\_ASBOX
6428 > ## ------------------------------ ##
6429 > ## Report this to gezelter@nd.edu ##
6430 > ## ------------------------------ ##
6431 > _ASBOX
6432 >    ) |
6433 >      sed "s/^/$as_me: WARNING:     /" >&2
6434 >    ;;
6435 > esac
6436 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6437 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6438 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6439 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6440 > else
6441 >  ac_cv_header_fftw3_h=$ac_header_preproc
6442 > fi
6443 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6444 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6445 >
6446 > fi
6447 > if test $ac_cv_header_fftw3_h = yes; then
6448 >  fftw_cv_fftw3_h=yes
6449 > else
6450 >  fftw_cv_fftw3_h=no
6451 > fi
6452 >
6453 >
6454 >        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6455 >        then
6456 >                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6457 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6458 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6459 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6460 > else
6461 >  ac_check_lib_save_LIBS=$LIBS
6462 > LIBS="-lfftw  $LIBS"
6463 > cat >conftest.$ac_ext <<_ACEOF
6464 > /* confdefs.h.  */
6465 > _ACEOF
6466 > cat confdefs.h >>conftest.$ac_ext
6467 > cat >>conftest.$ac_ext <<_ACEOF
6468 > /* end confdefs.h.  */
6469 >
6470 > /* Override any gcc2 internal prototype to avoid an error.  */
6471 > #ifdef __cplusplus
6472 > extern "C"
6473 > #endif
6474 > /* We use char because int might match the return type of a gcc2
6475 >   builtin and then its argument prototype would still apply.  */
6476 > char fftwnd_one ();
6477 > #ifdef FC_DUMMY_MAIN
6478 > #ifndef FC_DUMMY_MAIN_EQ_F77
6479 > #  ifdef __cplusplus
6480 >     extern "C"
6481 > #  endif
6482 >   int FC_DUMMY_MAIN() { return 1; }
6483 > #endif
6484 > #endif
6485 > int
6486 > main ()
6487 > {
6488 > fftwnd_one ();
6489 >  ;
6490 >  return 0;
6491 > }
6492 > _ACEOF
6493 > rm -f conftest.$ac_objext conftest$ac_exeext
6494 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6495 >  (eval $ac_link) 2>conftest.er1
6496 >  ac_status=$?
6497 >  grep -v '^ *+' conftest.er1 >conftest.err
6498 >  rm -f conftest.er1
6499 >  cat conftest.err >&5
6500 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6501 >  (exit $ac_status); } &&
6502 >         { ac_try='test -z "$ac_c_werror_flag"
6503 >                         || test ! -s conftest.err'
6504 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6505 >  (eval $ac_try) 2>&5
6506 >  ac_status=$?
6507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508 >  (exit $ac_status); }; } &&
6509 >         { ac_try='test -s conftest$ac_exeext'
6510 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6511 >  (eval $ac_try) 2>&5
6512 >  ac_status=$?
6513 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6514 >  (exit $ac_status); }; }; then
6515 >  ac_cv_lib_fftw_fftwnd_one=yes
6516 > else
6517 >  echo "$as_me: failed program was:" >&5
6518 > sed 's/^/| /' conftest.$ac_ext >&5
6519 >
6520 > ac_cv_lib_fftw_fftwnd_one=no
6521 > fi
6522 > rm -f conftest.err conftest.$ac_objext \
6523 >      conftest$ac_exeext conftest.$ac_ext
6524 > LIBS=$ac_check_lib_save_LIBS
6525 > fi
6526 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6527 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6528 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6529 >  fftw_cv_libfftw=yes
6530 > else
6531 >  fftw_cv_libfftw=no
6532 > fi
6533 >
6534 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6535 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6536 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6537 > if test "${ac_cv_header_fftw_h+set}" = set; then
6538 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6539 > fi
6540 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6541 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6542 > else
6543 >  # Is the header compilable?
6544 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6545 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6546 > cat >conftest.$ac_ext <<_ACEOF
6547 > /* confdefs.h.  */
6548 > _ACEOF
6549 > cat confdefs.h >>conftest.$ac_ext
6550 > cat >>conftest.$ac_ext <<_ACEOF
6551 > /* end confdefs.h.  */
6552 > $ac_includes_default
6553 > #include <fftw.h>
6554 > _ACEOF
6555 > rm -f conftest.$ac_objext
6556 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6557 >  (eval $ac_compile) 2>conftest.er1
6558 >  ac_status=$?
6559 >  grep -v '^ *+' conftest.er1 >conftest.err
6560 >  rm -f conftest.er1
6561 >  cat conftest.err >&5
6562 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6563 >  (exit $ac_status); } &&
6564 >         { ac_try='test -z "$ac_c_werror_flag"
6565 >                         || test ! -s conftest.err'
6566 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6567 >  (eval $ac_try) 2>&5
6568 >  ac_status=$?
6569 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6570 >  (exit $ac_status); }; } &&
6571 >         { ac_try='test -s conftest.$ac_objext'
6572 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6573 >  (eval $ac_try) 2>&5
6574 >  ac_status=$?
6575 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6576 >  (exit $ac_status); }; }; then
6577 >  ac_header_compiler=yes
6578 > else
6579 >  echo "$as_me: failed program was:" >&5
6580 > sed 's/^/| /' conftest.$ac_ext >&5
6581 >
6582 > ac_header_compiler=no
6583 > fi
6584 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6585 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6586 > echo "${ECHO_T}$ac_header_compiler" >&6
6587 >
6588 > # Is the header present?
6589 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6590 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6591 > cat >conftest.$ac_ext <<_ACEOF
6592 > /* confdefs.h.  */
6593 > _ACEOF
6594 > cat confdefs.h >>conftest.$ac_ext
6595 > cat >>conftest.$ac_ext <<_ACEOF
6596 > /* end confdefs.h.  */
6597 > #include <fftw.h>
6598 > _ACEOF
6599 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6600 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6601 >  ac_status=$?
6602 >  grep -v '^ *+' conftest.er1 >conftest.err
6603 >  rm -f conftest.er1
6604 >  cat conftest.err >&5
6605 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6606 >  (exit $ac_status); } >/dev/null; then
6607 >  if test -s conftest.err; then
6608 >    ac_cpp_err=$ac_c_preproc_warn_flag
6609 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6610 >  else
6611 >    ac_cpp_err=
6612 >  fi
6613 > else
6614 >  ac_cpp_err=yes
6615 > fi
6616 > if test -z "$ac_cpp_err"; then
6617 >  ac_header_preproc=yes
6618 > else
6619 >  echo "$as_me: failed program was:" >&5
6620 > sed 's/^/| /' conftest.$ac_ext >&5
6621 >
6622 >  ac_header_preproc=no
6623 > fi
6624 > rm -f conftest.err conftest.$ac_ext
6625 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6626 > echo "${ECHO_T}$ac_header_preproc" >&6
6627 >
6628 > # So?  What about this header?
6629 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6630 >  yes:no: )
6631 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6632 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6633 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6634 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6635 >    ac_header_preproc=yes
6636 >    ;;
6637 >  no:yes:* )
6638 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6639 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6640 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6641 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6642 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6643 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6644 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6645 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6646 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6647 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6648 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6649 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6650 >    (
6651 >      cat <<\_ASBOX
6652 > ## ------------------------------ ##
6653 > ## Report this to gezelter@nd.edu ##
6654 > ## ------------------------------ ##
6655 > _ASBOX
6656 >    ) |
6657 >      sed "s/^/$as_me: WARNING:     /" >&2
6658 >    ;;
6659 > esac
6660 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6661 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6662 > if test "${ac_cv_header_fftw_h+set}" = set; then
6663 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6664 > else
6665 >  ac_cv_header_fftw_h=$ac_header_preproc
6666 > fi
6667 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6668 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6669 >
6670 > fi
6671 > if test $ac_cv_header_fftw_h = yes; then
6672 >  fftw_cv_fftw_h=yes
6673 > else
6674 >  fftw_cv_fftw_h=no
6675 > fi
6676 >
6677 >
6678 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6679 >                then
6680 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6681 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6682 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6683 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6684 > else
6685 >  ac_check_lib_save_LIBS=$LIBS
6686 > LIBS="-ldfftw  $LIBS"
6687 > cat >conftest.$ac_ext <<_ACEOF
6688 > /* confdefs.h.  */
6689 > _ACEOF
6690 > cat confdefs.h >>conftest.$ac_ext
6691 > cat >>conftest.$ac_ext <<_ACEOF
6692 > /* end confdefs.h.  */
6693 >
6694 > /* Override any gcc2 internal prototype to avoid an error.  */
6695 > #ifdef __cplusplus
6696 > extern "C"
6697 > #endif
6698 > /* We use char because int might match the return type of a gcc2
6699 >   builtin and then its argument prototype would still apply.  */
6700 > char fftwnd_one ();
6701 > #ifdef FC_DUMMY_MAIN
6702 > #ifndef FC_DUMMY_MAIN_EQ_F77
6703 > #  ifdef __cplusplus
6704 >     extern "C"
6705 > #  endif
6706 >   int FC_DUMMY_MAIN() { return 1; }
6707 > #endif
6708 > #endif
6709 > int
6710 > main ()
6711 > {
6712 > fftwnd_one ();
6713 >  ;
6714 >  return 0;
6715 > }
6716 > _ACEOF
6717 > rm -f conftest.$ac_objext conftest$ac_exeext
6718 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6719 >  (eval $ac_link) 2>conftest.er1
6720 >  ac_status=$?
6721 >  grep -v '^ *+' conftest.er1 >conftest.err
6722 >  rm -f conftest.er1
6723 >  cat conftest.err >&5
6724 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6725 >  (exit $ac_status); } &&
6726 >         { ac_try='test -z "$ac_c_werror_flag"
6727 >                         || test ! -s conftest.err'
6728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6729 >  (eval $ac_try) 2>&5
6730 >  ac_status=$?
6731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6732 >  (exit $ac_status); }; } &&
6733 >         { ac_try='test -s conftest$ac_exeext'
6734 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6735 >  (eval $ac_try) 2>&5
6736 >  ac_status=$?
6737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738 >  (exit $ac_status); }; }; then
6739 >  ac_cv_lib_dfftw_fftwnd_one=yes
6740 > else
6741 >  echo "$as_me: failed program was:" >&5
6742 > sed 's/^/| /' conftest.$ac_ext >&5
6743 >
6744 > ac_cv_lib_dfftw_fftwnd_one=no
6745 > fi
6746 > rm -f conftest.err conftest.$ac_objext \
6747 >      conftest$ac_exeext conftest.$ac_ext
6748 > LIBS=$ac_check_lib_save_LIBS
6749 > fi
6750 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6751 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6752 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6753 >  fftw_cv_libdfftw=yes
6754 > else
6755 >  fftw_cv_libdfftw=no
6756 > fi
6757 >
6758 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6759 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6760 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6761 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6762 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6763 > fi
6764 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6765 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6766 > else
6767 >  # Is the header compilable?
6768 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6769 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6770 > cat >conftest.$ac_ext <<_ACEOF
6771 > /* confdefs.h.  */
6772 > _ACEOF
6773 > cat confdefs.h >>conftest.$ac_ext
6774 > cat >>conftest.$ac_ext <<_ACEOF
6775 > /* end confdefs.h.  */
6776 > $ac_includes_default
6777 > #include <dfftw.h>
6778 > _ACEOF
6779 > rm -f conftest.$ac_objext
6780 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6781 >  (eval $ac_compile) 2>conftest.er1
6782 >  ac_status=$?
6783 >  grep -v '^ *+' conftest.er1 >conftest.err
6784 >  rm -f conftest.er1
6785 >  cat conftest.err >&5
6786 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6787 >  (exit $ac_status); } &&
6788 >         { ac_try='test -z "$ac_c_werror_flag"
6789 >                         || test ! -s conftest.err'
6790 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6791 >  (eval $ac_try) 2>&5
6792 >  ac_status=$?
6793 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6794 >  (exit $ac_status); }; } &&
6795 >         { ac_try='test -s conftest.$ac_objext'
6796 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6797 >  (eval $ac_try) 2>&5
6798 >  ac_status=$?
6799 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800 >  (exit $ac_status); }; }; then
6801 >  ac_header_compiler=yes
6802 > else
6803 >  echo "$as_me: failed program was:" >&5
6804 > sed 's/^/| /' conftest.$ac_ext >&5
6805 >
6806 > ac_header_compiler=no
6807 > fi
6808 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6809 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6810 > echo "${ECHO_T}$ac_header_compiler" >&6
6811 >
6812 > # Is the header present?
6813 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6814 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6815 > cat >conftest.$ac_ext <<_ACEOF
6816 > /* confdefs.h.  */
6817 > _ACEOF
6818 > cat confdefs.h >>conftest.$ac_ext
6819 > cat >>conftest.$ac_ext <<_ACEOF
6820 > /* end confdefs.h.  */
6821 > #include <dfftw.h>
6822 > _ACEOF
6823 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6824 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6825 >  ac_status=$?
6826 >  grep -v '^ *+' conftest.er1 >conftest.err
6827 >  rm -f conftest.er1
6828 >  cat conftest.err >&5
6829 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6830 >  (exit $ac_status); } >/dev/null; then
6831 >  if test -s conftest.err; then
6832 >    ac_cpp_err=$ac_c_preproc_warn_flag
6833 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6834 >  else
6835 >    ac_cpp_err=
6836 >  fi
6837 > else
6838 >  ac_cpp_err=yes
6839 > fi
6840 > if test -z "$ac_cpp_err"; then
6841 >  ac_header_preproc=yes
6842 > else
6843 >  echo "$as_me: failed program was:" >&5
6844 > sed 's/^/| /' conftest.$ac_ext >&5
6845 >
6846 >  ac_header_preproc=no
6847 > fi
6848 > rm -f conftest.err conftest.$ac_ext
6849 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6850 > echo "${ECHO_T}$ac_header_preproc" >&6
6851 >
6852 > # So?  What about this header?
6853 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6854 >  yes:no: )
6855 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6856 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6857 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6858 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6859 >    ac_header_preproc=yes
6860 >    ;;
6861 >  no:yes:* )
6862 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6863 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6864 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6865 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6866 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6867 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6868 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6869 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6870 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6871 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6872 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6873 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6874 >    (
6875 >      cat <<\_ASBOX
6876 > ## ------------------------------ ##
6877 > ## Report this to gezelter@nd.edu ##
6878 > ## ------------------------------ ##
6879 > _ASBOX
6880 >    ) |
6881 >      sed "s/^/$as_me: WARNING:     /" >&2
6882 >    ;;
6883 > esac
6884 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6885 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6886 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6887 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6888 > else
6889 >  ac_cv_header_dfftw_h=$ac_header_preproc
6890 > fi
6891 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6892 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6893 >
6894 > fi
6895 > if test $ac_cv_header_dfftw_h = yes; then
6896 >  fftw_cv_dfftw_h=yes
6897 > else
6898 >  fftw_cv_dfftw_h=no
6899 > fi
6900 >
6901 >
6902 >                fi
6903 >        fi
6904 >        ac_ext=c
6905 > ac_cpp='$CPP $CPPFLAGS'
6906 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6907 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6908 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6909 >
6910 >
6911 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6912 >        then
6913 >
6914 > cat >>confdefs.h <<\_ACEOF
6915 > #define HAVE_FFTW3_H 1
6916 > _ACEOF
6917 >
6918 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6919 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6920 >                FFTW_LIBS="-lfftw3"
6921 >        else
6922 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6923 >        then
6924 >
6925 > cat >>confdefs.h <<\_ACEOF
6926 > #define HAVE_FFTW_H 1
6927 > _ACEOF
6928 >
6929 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6930 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6931 >                FFTW_LIBS="-lfftw"
6932 >        else
6933 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6934 >        then
6935 >
6936 > cat >>confdefs.h <<\_ACEOF
6937 > #define HAVE_DFFTW_H 1
6938 > _ACEOF
6939 >
6940 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6941 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6942 >                FFTW_LIBS="-ldfftw"
6943 >        else
6944 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6945 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6946 >                FFTW_INC_DIR=
6947 >                FFTW_LIB_DIR=
6948 >                FFTW_LIBS=
6949 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6950 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6951 >                echo "$as_me:$LINENO: result: failed" >&5
6952 > echo "${ECHO_T}failed" >&6
6953 >        echo ""
6954 >        echo "*********************************************************"
6955 >        echo "* WARNING: Could not find a working FFTW installation   *"
6956 >        echo "* If you need the staticProps program to be able to     *"
6957 >        echo "* compute undulation spectra, be sure to specify a      *"
6958 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6959 >        echo "*                                                       *"
6960 >        echo "* OOPSE will still work without fftw installed.         *"
6961 >        echo "*********************************************************"
6962 >        echo ""
6963 >        fi
6964 >        fi
6965 >        fi
6966 >
6967 >
6968 >
6969 > fi
6970 > fi
6971 >
6972 >
6973 >
6974 > # Checks for header files.
6975 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6976 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6977 > if test "${ac_cv_header_stdc+set}" = set; then
6978 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6979 > else
6980 >  cat >conftest.$ac_ext <<_ACEOF
6981 > /* confdefs.h.  */
6982 > _ACEOF
6983 > cat confdefs.h >>conftest.$ac_ext
6984 > cat >>conftest.$ac_ext <<_ACEOF
6985 > /* end confdefs.h.  */
6986 > #include <stdlib.h>
6987 > #include <stdarg.h>
6988 > #include <string.h>
6989 > #include <float.h>
6990 >
6991 > #ifdef FC_DUMMY_MAIN
6992 > #ifndef FC_DUMMY_MAIN_EQ_F77
6993 > #  ifdef __cplusplus
6994 >     extern "C"
6995 > #  endif
6996 >   int FC_DUMMY_MAIN() { return 1; }
6997 > #endif
6998 > #endif
6999 > int
7000 > main ()
7001 > {
7002 >
7003 >  ;
7004 >  return 0;
7005 > }
7006 > _ACEOF
7007 > rm -f conftest.$ac_objext
7008 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7009 >  (eval $ac_compile) 2>conftest.er1
7010 >  ac_status=$?
7011 >  grep -v '^ *+' conftest.er1 >conftest.err
7012 >  rm -f conftest.er1
7013 >  cat conftest.err >&5
7014 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7015 >  (exit $ac_status); } &&
7016 >         { ac_try='test -z "$ac_c_werror_flag"
7017 >                         || test ! -s conftest.err'
7018 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7019 >  (eval $ac_try) 2>&5
7020 >  ac_status=$?
7021 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7022 >  (exit $ac_status); }; } &&
7023 >         { ac_try='test -s conftest.$ac_objext'
7024 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7025 >  (eval $ac_try) 2>&5
7026 >  ac_status=$?
7027 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7028 >  (exit $ac_status); }; }; then
7029 >  ac_cv_header_stdc=yes
7030 > else
7031 >  echo "$as_me: failed program was:" >&5
7032 > sed 's/^/| /' conftest.$ac_ext >&5
7033 >
7034 > ac_cv_header_stdc=no
7035 > fi
7036 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7037 >
7038 > if test $ac_cv_header_stdc = yes; then
7039 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7040 >  cat >conftest.$ac_ext <<_ACEOF
7041 > /* confdefs.h.  */
7042 > _ACEOF
7043 > cat confdefs.h >>conftest.$ac_ext
7044 > cat >>conftest.$ac_ext <<_ACEOF
7045 > /* end confdefs.h.  */
7046 > #include <string.h>
7047 >
7048 > _ACEOF
7049 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7050 >  $EGREP "memchr" >/dev/null 2>&1; then
7051 >  :
7052 > else
7053 >  ac_cv_header_stdc=no
7054 > fi
7055 > rm -f conftest*
7056 >
7057 > fi
7058 >
7059 > if test $ac_cv_header_stdc = yes; then
7060 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7061 >  cat >conftest.$ac_ext <<_ACEOF
7062 > /* confdefs.h.  */
7063 > _ACEOF
7064 > cat confdefs.h >>conftest.$ac_ext
7065 > cat >>conftest.$ac_ext <<_ACEOF
7066 > /* end confdefs.h.  */
7067 > #include <stdlib.h>
7068 >
7069 > _ACEOF
7070 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7071 >  $EGREP "free" >/dev/null 2>&1; then
7072 >  :
7073 > else
7074 >  ac_cv_header_stdc=no
7075 > fi
7076 > rm -f conftest*
7077 >
7078 > fi
7079 >
7080 > if test $ac_cv_header_stdc = yes; then
7081 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7082 >  if test "$cross_compiling" = yes; then
7083 >  :
7084 > else
7085 >  cat >conftest.$ac_ext <<_ACEOF
7086 > /* confdefs.h.  */
7087 > _ACEOF
7088 > cat confdefs.h >>conftest.$ac_ext
7089 > cat >>conftest.$ac_ext <<_ACEOF
7090 > /* end confdefs.h.  */
7091 > #include <ctype.h>
7092 > #if ((' ' & 0x0FF) == 0x020)
7093 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7094 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7095 > #else
7096 > # define ISLOWER(c) \
7097 >                   (('a' <= (c) && (c) <= 'i') \
7098 >                     || ('j' <= (c) && (c) <= 'r') \
7099 >                     || ('s' <= (c) && (c) <= 'z'))
7100 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7101 > #endif
7102 >
7103 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7104 > int
7105 > main ()
7106 > {
7107 >  int i;
7108 >  for (i = 0; i < 256; i++)
7109 >    if (XOR (islower (i), ISLOWER (i))
7110 >        || toupper (i) != TOUPPER (i))
7111 >      exit(2);
7112 >  exit (0);
7113 > }
7114 > _ACEOF
7115 > rm -f conftest$ac_exeext
7116 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7117 >  (eval $ac_link) 2>&5
7118 >  ac_status=$?
7119 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7120 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122 >  (eval $ac_try) 2>&5
7123 >  ac_status=$?
7124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125 >  (exit $ac_status); }; }; then
7126 >  :
7127 > else
7128 >  echo "$as_me: program exited with status $ac_status" >&5
7129 > echo "$as_me: failed program was:" >&5
7130 > sed 's/^/| /' conftest.$ac_ext >&5
7131 >
7132 > ( exit $ac_status )
7133 > ac_cv_header_stdc=no
7134 > fi
7135 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7136 > fi
7137 > fi
7138 > fi
7139 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7140 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7141 > if test $ac_cv_header_stdc = yes; then
7142 >
7143 > cat >>confdefs.h <<\_ACEOF
7144 > #define STDC_HEADERS 1
7145 > _ACEOF
7146 >
7147 > fi
7148 >
7149 >
7150 >
7151 >
7152 >
7153 >
7154 >
7155 >
7156 >
7157 >
7158 >
7159 >
7160 >
7161 >
7162 >
7163 >
7164 >
7165 >
7166 >
7167 >
7168 >
7169 >
7170 >
7171 >
7172 >
7173 >
7174 > 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
7175 > do
7176 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7177 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7178 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7179 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7180 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7181 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7182 > fi
7183 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7184 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7185 > else
7186 >  # Is the header compilable?
7187 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7188 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7189 > cat >conftest.$ac_ext <<_ACEOF
7190 > /* confdefs.h.  */
7191 > _ACEOF
7192 > cat confdefs.h >>conftest.$ac_ext
7193 > cat >>conftest.$ac_ext <<_ACEOF
7194 > /* end confdefs.h.  */
7195 > $ac_includes_default
7196 > #include <$ac_header>
7197 > _ACEOF
7198 > rm -f conftest.$ac_objext
7199 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7200 >  (eval $ac_compile) 2>conftest.er1
7201 >  ac_status=$?
7202 >  grep -v '^ *+' conftest.er1 >conftest.err
7203 >  rm -f conftest.er1
7204 >  cat conftest.err >&5
7205 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7206 >  (exit $ac_status); } &&
7207 >         { ac_try='test -z "$ac_c_werror_flag"
7208 >                         || test ! -s conftest.err'
7209 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7210 >  (eval $ac_try) 2>&5
7211 >  ac_status=$?
7212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7213 >  (exit $ac_status); }; } &&
7214 >         { ac_try='test -s conftest.$ac_objext'
7215 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7216 >  (eval $ac_try) 2>&5
7217 >  ac_status=$?
7218 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7219 >  (exit $ac_status); }; }; then
7220 >  ac_header_compiler=yes
7221 > else
7222 >  echo "$as_me: failed program was:" >&5
7223 > sed 's/^/| /' conftest.$ac_ext >&5
7224 >
7225 > ac_header_compiler=no
7226 > fi
7227 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7228 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7229 > echo "${ECHO_T}$ac_header_compiler" >&6
7230 >
7231 > # Is the header present?
7232 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7233 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7234 > cat >conftest.$ac_ext <<_ACEOF
7235 > /* confdefs.h.  */
7236 > _ACEOF
7237 > cat confdefs.h >>conftest.$ac_ext
7238 > cat >>conftest.$ac_ext <<_ACEOF
7239 > /* end confdefs.h.  */
7240 > #include <$ac_header>
7241 > _ACEOF
7242 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7243 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7244 >  ac_status=$?
7245 >  grep -v '^ *+' conftest.er1 >conftest.err
7246 >  rm -f conftest.er1
7247 >  cat conftest.err >&5
7248 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7249 >  (exit $ac_status); } >/dev/null; then
7250 >  if test -s conftest.err; then
7251 >    ac_cpp_err=$ac_c_preproc_warn_flag
7252 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7253 >  else
7254 >    ac_cpp_err=
7255 >  fi
7256 > else
7257 >  ac_cpp_err=yes
7258 > fi
7259 > if test -z "$ac_cpp_err"; then
7260 >  ac_header_preproc=yes
7261 > else
7262 >  echo "$as_me: failed program was:" >&5
7263 > sed 's/^/| /' conftest.$ac_ext >&5
7264 >
7265 >  ac_header_preproc=no
7266 > fi
7267 > rm -f conftest.err conftest.$ac_ext
7268 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7269 > echo "${ECHO_T}$ac_header_preproc" >&6
7270 >
7271 > # So?  What about this header?
7272 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7273 >  yes:no: )
7274 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7275 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7276 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7277 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7278 >    ac_header_preproc=yes
7279 >    ;;
7280 >  no:yes:* )
7281 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7282 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7283 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7284 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7285 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7286 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7287 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7288 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7289 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7290 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7291 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7292 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7293 >    (
7294 >      cat <<\_ASBOX
7295 > ## ------------------------------ ##
7296 > ## Report this to gezelter@nd.edu ##
7297 > ## ------------------------------ ##
7298 > _ASBOX
7299 >    ) |
7300 >      sed "s/^/$as_me: WARNING:     /" >&2
7301 >    ;;
7302 > esac
7303 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7304 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7305 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7307 > else
7308 >  eval "$as_ac_Header=\$ac_header_preproc"
7309 > fi
7310 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7311 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7312 >
7313 > fi
7314 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7315 >  cat >>confdefs.h <<_ACEOF
7316 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7317 > _ACEOF
7318 >
7319 > fi
7320 >
7321 > done
7322 >
7323 >
7324 > # Checks for typedefs, structures, and compiler characteristics.
7325 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7326 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7327 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7328 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7329 > else
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 >
7337 > #include <stdbool.h>
7338 > #ifndef bool
7339 > # error bool is not defined
7340 > #endif
7341 > #ifndef false
7342 > # error false is not defined
7343 > #endif
7344 > #if false
7345 > # error false is not 0
7346 > #endif
7347 > #ifndef true
7348 > # error true is not defined
7349 > #endif
7350 > #if true != 1
7351 > # error true is not 1
7352 > #endif
7353 > #ifndef __bool_true_false_are_defined
7354 > # error __bool_true_false_are_defined is not defined
7355 > #endif
7356 >
7357 >        struct s { _Bool s: 1; _Bool t; } s;
7358 >
7359 >        char a[true == 1 ? 1 : -1];
7360 >        char b[false == 0 ? 1 : -1];
7361 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7362 >        char d[(bool) -0.5 == true ? 1 : -1];
7363 >        bool e = &s;
7364 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7365 >        char g[true];
7366 >        char h[sizeof (_Bool)];
7367 >        char i[sizeof s.t];
7368 >
7369 > #ifdef FC_DUMMY_MAIN
7370 > #ifndef FC_DUMMY_MAIN_EQ_F77
7371 > #  ifdef __cplusplus
7372 >     extern "C"
7373 > #  endif
7374 >   int FC_DUMMY_MAIN() { return 1; }
7375 > #endif
7376 > #endif
7377 > int
7378 > main ()
7379 > {
7380 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7381 >  ;
7382 >  return 0;
7383 > }
7384 > _ACEOF
7385 > rm -f conftest.$ac_objext
7386 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7387 >  (eval $ac_compile) 2>conftest.er1
7388 >  ac_status=$?
7389 >  grep -v '^ *+' conftest.er1 >conftest.err
7390 >  rm -f conftest.er1
7391 >  cat conftest.err >&5
7392 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7393 >  (exit $ac_status); } &&
7394 >         { ac_try='test -z "$ac_c_werror_flag"
7395 >                         || test ! -s conftest.err'
7396 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7397 >  (eval $ac_try) 2>&5
7398 >  ac_status=$?
7399 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7400 >  (exit $ac_status); }; } &&
7401 >         { ac_try='test -s conftest.$ac_objext'
7402 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7403 >  (eval $ac_try) 2>&5
7404 >  ac_status=$?
7405 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7406 >  (exit $ac_status); }; }; then
7407 >  ac_cv_header_stdbool_h=yes
7408 > else
7409 >  echo "$as_me: failed program was:" >&5
7410 > sed 's/^/| /' conftest.$ac_ext >&5
7411 >
7412 > ac_cv_header_stdbool_h=no
7413 > fi
7414 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7415 > fi
7416 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7417 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7418 > echo "$as_me:$LINENO: checking for _Bool" >&5
7419 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7420 > if test "${ac_cv_type__Bool+set}" = set; then
7421 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7422 > else
7423 >  cat >conftest.$ac_ext <<_ACEOF
7424 > /* confdefs.h.  */
7425 > _ACEOF
7426 > cat confdefs.h >>conftest.$ac_ext
7427 > cat >>conftest.$ac_ext <<_ACEOF
7428 > /* end confdefs.h.  */
7429 > $ac_includes_default
7430 > #ifdef FC_DUMMY_MAIN
7431 > #ifndef FC_DUMMY_MAIN_EQ_F77
7432 > #  ifdef __cplusplus
7433 >     extern "C"
7434 > #  endif
7435 >   int FC_DUMMY_MAIN() { return 1; }
7436 > #endif
7437 > #endif
7438 > int
7439 > main ()
7440 > {
7441 > if ((_Bool *) 0)
7442 >  return 0;
7443 > if (sizeof (_Bool))
7444 >  return 0;
7445 >  ;
7446 >  return 0;
7447 > }
7448 > _ACEOF
7449 > rm -f conftest.$ac_objext
7450 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451 >  (eval $ac_compile) 2>conftest.er1
7452 >  ac_status=$?
7453 >  grep -v '^ *+' conftest.er1 >conftest.err
7454 >  rm -f conftest.er1
7455 >  cat conftest.err >&5
7456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457 >  (exit $ac_status); } &&
7458 >         { ac_try='test -z "$ac_c_werror_flag"
7459 >                         || test ! -s conftest.err'
7460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461 >  (eval $ac_try) 2>&5
7462 >  ac_status=$?
7463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464 >  (exit $ac_status); }; } &&
7465 >         { ac_try='test -s conftest.$ac_objext'
7466 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467 >  (eval $ac_try) 2>&5
7468 >  ac_status=$?
7469 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470 >  (exit $ac_status); }; }; then
7471 >  ac_cv_type__Bool=yes
7472 > else
7473 >  echo "$as_me: failed program was:" >&5
7474 > sed 's/^/| /' conftest.$ac_ext >&5
7475 >
7476 > ac_cv_type__Bool=no
7477 > fi
7478 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479 > fi
7480 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7481 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7482 > if test $ac_cv_type__Bool = yes; then
7483 >
7484 > cat >>confdefs.h <<_ACEOF
7485 > #define HAVE__BOOL 1
7486 > _ACEOF
7487 >
7488 >
7489 > fi
7490 >
7491 > if test $ac_cv_header_stdbool_h = yes; then
7492 >
7493 > cat >>confdefs.h <<\_ACEOF
7494 > #define HAVE_STDBOOL_H 1
7495 > _ACEOF
7496 >
7497 > fi
7498 >
7499 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7500 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7501 > if test "${ac_cv_c_const+set}" = set; then
7502 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7503 > else
7504 >  cat >conftest.$ac_ext <<_ACEOF
7505 > /* confdefs.h.  */
7506 > _ACEOF
7507 > cat confdefs.h >>conftest.$ac_ext
7508 > cat >>conftest.$ac_ext <<_ACEOF
7509 > /* end confdefs.h.  */
7510 >
7511 > #ifdef FC_DUMMY_MAIN
7512 > #ifndef FC_DUMMY_MAIN_EQ_F77
7513 > #  ifdef __cplusplus
7514 >     extern "C"
7515 > #  endif
7516 >   int FC_DUMMY_MAIN() { return 1; }
7517 > #endif
7518 > #endif
7519 > int
7520 > main ()
7521 > {
7522 > /* FIXME: Include the comments suggested by Paul. */
7523 > #ifndef __cplusplus
7524 >  /* Ultrix mips cc rejects this.  */
7525 >  typedef int charset[2];
7526 >  const charset x;
7527 >  /* SunOS 4.1.1 cc rejects this.  */
7528 >  char const *const *ccp;
7529 >  char **p;
7530 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7531 >  struct point {int x, y;};
7532 >  static struct point const zero = {0,0};
7533 >  /* AIX XL C 1.02.0.0 rejects this.
7534 >     It does not let you subtract one const X* pointer from another in
7535 >     an arm of an if-expression whose if-part is not a constant
7536 >     expression */
7537 >  const char *g = "string";
7538 >  ccp = &g + (g ? g-g : 0);
7539 >  /* HPUX 7.0 cc rejects these. */
7540 >  ++ccp;
7541 >  p = (char**) ccp;
7542 >  ccp = (char const *const *) p;
7543 >  { /* SCO 3.2v4 cc rejects this.  */
7544 >    char *t;
7545 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7546 >
7547 >    *t++ = 0;
7548 >  }
7549 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7550 >    int x[] = {25, 17};
7551 >    const int *foo = &x[0];
7552 >    ++foo;
7553 >  }
7554 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7555 >    typedef const int *iptr;
7556 >    iptr p = 0;
7557 >    ++p;
7558 >  }
7559 >  { /* AIX XL C 1.02.0.0 rejects this saying
7560 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7561 >    struct s { int j; const int *ap[3]; };
7562 >    struct s *b; b->j = 5;
7563 >  }
7564 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7565 >    const int foo = 10;
7566 >  }
7567 > #endif
7568 >
7569 >  ;
7570 >  return 0;
7571 > }
7572 > _ACEOF
7573 > rm -f conftest.$ac_objext
7574 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7575 >  (eval $ac_compile) 2>conftest.er1
7576 >  ac_status=$?
7577 >  grep -v '^ *+' conftest.er1 >conftest.err
7578 >  rm -f conftest.er1
7579 >  cat conftest.err >&5
7580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7581 >  (exit $ac_status); } &&
7582 >         { ac_try='test -z "$ac_c_werror_flag"
7583 >                         || test ! -s conftest.err'
7584 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7585 >  (eval $ac_try) 2>&5
7586 >  ac_status=$?
7587 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7588 >  (exit $ac_status); }; } &&
7589 >         { ac_try='test -s conftest.$ac_objext'
7590 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7591 >  (eval $ac_try) 2>&5
7592 >  ac_status=$?
7593 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7594 >  (exit $ac_status); }; }; then
7595 >  ac_cv_c_const=yes
7596 > else
7597 >  echo "$as_me: failed program was:" >&5
7598 > sed 's/^/| /' conftest.$ac_ext >&5
7599 >
7600 > ac_cv_c_const=no
7601 > fi
7602 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7603 > fi
7604 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7605 > echo "${ECHO_T}$ac_cv_c_const" >&6
7606 > if test $ac_cv_c_const = no; then
7607 >
7608 > cat >>confdefs.h <<\_ACEOF
7609 > #define const
7610 > _ACEOF
7611 >
7612 > fi
7613 >
7614 > echo "$as_me:$LINENO: checking for inline" >&5
7615 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7616 > if test "${ac_cv_c_inline+set}" = set; then
7617 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7618 > else
7619 >  ac_cv_c_inline=no
7620 > for ac_kw in inline __inline__ __inline; do
7621 >  cat >conftest.$ac_ext <<_ACEOF
7622 > /* confdefs.h.  */
7623 > _ACEOF
7624 > cat confdefs.h >>conftest.$ac_ext
7625 > cat >>conftest.$ac_ext <<_ACEOF
7626 > /* end confdefs.h.  */
7627 > #ifndef __cplusplus
7628 > typedef int foo_t;
7629 > static $ac_kw foo_t static_foo () {return 0; }
7630 > $ac_kw foo_t foo () {return 0; }
7631 > #endif
7632 >
7633 > _ACEOF
7634 > rm -f conftest.$ac_objext
7635 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7636 >  (eval $ac_compile) 2>conftest.er1
7637 >  ac_status=$?
7638 >  grep -v '^ *+' conftest.er1 >conftest.err
7639 >  rm -f conftest.er1
7640 >  cat conftest.err >&5
7641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7642 >  (exit $ac_status); } &&
7643 >         { ac_try='test -z "$ac_c_werror_flag"
7644 >                         || test ! -s conftest.err'
7645 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7646 >  (eval $ac_try) 2>&5
7647 >  ac_status=$?
7648 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7649 >  (exit $ac_status); }; } &&
7650 >         { ac_try='test -s conftest.$ac_objext'
7651 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7652 >  (eval $ac_try) 2>&5
7653 >  ac_status=$?
7654 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7655 >  (exit $ac_status); }; }; then
7656 >  ac_cv_c_inline=$ac_kw; break
7657 > else
7658 >  echo "$as_me: failed program was:" >&5
7659 > sed 's/^/| /' conftest.$ac_ext >&5
7660 >
7661 > fi
7662 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7663 > done
7664 >
7665 > fi
7666 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7667 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7668 >
7669 >
7670 > case $ac_cv_c_inline in
7671 >  inline | yes) ;;
7672 >  *)
7673 >    case $ac_cv_c_inline in
7674 >      no) ac_val=;;
7675 >      *) ac_val=$ac_cv_c_inline;;
7676 >    esac
7677 >    cat >>confdefs.h <<_ACEOF
7678 > #ifndef __cplusplus
7679 > #define inline $ac_val
7680 > #endif
7681 > _ACEOF
7682 >    ;;
7683 > esac
7684 >
7685 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7686 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7687 > if test "${ac_cv_c_restrict+set}" = set; then
7688 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7689 > else
7690 >  ac_cv_c_restrict=no
7691 >   # Try the official restrict keyword, then gcc's __restrict, and
7692 >   # the less common variants.
7693 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7694 >     cat >conftest.$ac_ext <<_ACEOF
7695 > /* confdefs.h.  */
7696 > _ACEOF
7697 > cat confdefs.h >>conftest.$ac_ext
7698 > cat >>conftest.$ac_ext <<_ACEOF
7699 > /* end confdefs.h.  */
7700 > float * $ac_kw x;
7701 > _ACEOF
7702 > rm -f conftest.$ac_objext
7703 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7704 >  (eval $ac_compile) 2>conftest.er1
7705 >  ac_status=$?
7706 >  grep -v '^ *+' conftest.er1 >conftest.err
7707 >  rm -f conftest.er1
7708 >  cat conftest.err >&5
7709 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7710 >  (exit $ac_status); } &&
7711 >         { ac_try='test -z "$ac_c_werror_flag"
7712 >                         || test ! -s conftest.err'
7713 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7714 >  (eval $ac_try) 2>&5
7715 >  ac_status=$?
7716 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7717 >  (exit $ac_status); }; } &&
7718 >         { ac_try='test -s conftest.$ac_objext'
7719 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7720 >  (eval $ac_try) 2>&5
7721 >  ac_status=$?
7722 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7723 >  (exit $ac_status); }; }; then
7724 >  ac_cv_c_restrict=$ac_kw; break
7725 > else
7726 >  echo "$as_me: failed program was:" >&5
7727 > sed 's/^/| /' conftest.$ac_ext >&5
7728 >
7729 > fi
7730 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7731 >   done
7732 >
7733 > fi
7734 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7735 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7736 > case $ac_cv_c_restrict in
7737 >   restrict) ;;
7738 >   no)
7739 > cat >>confdefs.h <<\_ACEOF
7740 > #define restrict
7741 > _ACEOF
7742 > ;;
7743 >   *)  cat >>confdefs.h <<_ACEOF
7744 > #define restrict $ac_cv_c_restrict
7745 > _ACEOF
7746 > ;;
7747 > esac
7748 >
7749 > echo "$as_me:$LINENO: checking for size_t" >&5
7750 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7751 > if test "${ac_cv_type_size_t+set}" = set; then
7752 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7753 > else
7754 >  cat >conftest.$ac_ext <<_ACEOF
7755 > /* confdefs.h.  */
7756 > _ACEOF
7757 > cat confdefs.h >>conftest.$ac_ext
7758 > cat >>conftest.$ac_ext <<_ACEOF
7759 > /* end confdefs.h.  */
7760 > $ac_includes_default
7761 > #ifdef FC_DUMMY_MAIN
7762 > #ifndef FC_DUMMY_MAIN_EQ_F77
7763 > #  ifdef __cplusplus
7764 >     extern "C"
7765 > #  endif
7766 >   int FC_DUMMY_MAIN() { return 1; }
7767 > #endif
7768 > #endif
7769 > int
7770 > main ()
7771 > {
7772 > if ((size_t *) 0)
7773 >  return 0;
7774 > if (sizeof (size_t))
7775 >  return 0;
7776 >  ;
7777 >  return 0;
7778 > }
7779 > _ACEOF
7780 > rm -f conftest.$ac_objext
7781 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7782 >  (eval $ac_compile) 2>conftest.er1
7783 >  ac_status=$?
7784 >  grep -v '^ *+' conftest.er1 >conftest.err
7785 >  rm -f conftest.er1
7786 >  cat conftest.err >&5
7787 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7788 >  (exit $ac_status); } &&
7789 >         { ac_try='test -z "$ac_c_werror_flag"
7790 >                         || test ! -s conftest.err'
7791 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7792 >  (eval $ac_try) 2>&5
7793 >  ac_status=$?
7794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7795 >  (exit $ac_status); }; } &&
7796 >         { ac_try='test -s conftest.$ac_objext'
7797 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7798 >  (eval $ac_try) 2>&5
7799 >  ac_status=$?
7800 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7801 >  (exit $ac_status); }; }; then
7802 >  ac_cv_type_size_t=yes
7803 > else
7804 >  echo "$as_me: failed program was:" >&5
7805 > sed 's/^/| /' conftest.$ac_ext >&5
7806 >
7807 > ac_cv_type_size_t=no
7808 > fi
7809 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7810 > fi
7811 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7812 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7813 > if test $ac_cv_type_size_t = yes; then
7814 >  :
7815 > else
7816 >
7817 > cat >>confdefs.h <<_ACEOF
7818 > #define size_t unsigned
7819 > _ACEOF
7820 >
7821 > fi
7822 >
7823 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7824 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7825 > if test "${ac_cv_header_time+set}" = set; then
7826 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7827 > else
7828 >  cat >conftest.$ac_ext <<_ACEOF
7829 > /* confdefs.h.  */
7830 > _ACEOF
7831 > cat confdefs.h >>conftest.$ac_ext
7832 > cat >>conftest.$ac_ext <<_ACEOF
7833 > /* end confdefs.h.  */
7834 > #include <sys/types.h>
7835 > #include <sys/time.h>
7836 > #include <time.h>
7837 >
7838 > #ifdef FC_DUMMY_MAIN
7839 > #ifndef FC_DUMMY_MAIN_EQ_F77
7840 > #  ifdef __cplusplus
7841 >     extern "C"
7842 > #  endif
7843 >   int FC_DUMMY_MAIN() { return 1; }
7844 > #endif
7845 > #endif
7846 > int
7847 > main ()
7848 > {
7849 > if ((struct tm *) 0)
7850 > return 0;
7851 >  ;
7852 >  return 0;
7853 > }
7854 > _ACEOF
7855 > rm -f conftest.$ac_objext
7856 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7857 >  (eval $ac_compile) 2>conftest.er1
7858 >  ac_status=$?
7859 >  grep -v '^ *+' conftest.er1 >conftest.err
7860 >  rm -f conftest.er1
7861 >  cat conftest.err >&5
7862 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7863 >  (exit $ac_status); } &&
7864 >         { ac_try='test -z "$ac_c_werror_flag"
7865 >                         || test ! -s conftest.err'
7866 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7867 >  (eval $ac_try) 2>&5
7868 >  ac_status=$?
7869 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7870 >  (exit $ac_status); }; } &&
7871 >         { ac_try='test -s conftest.$ac_objext'
7872 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7873 >  (eval $ac_try) 2>&5
7874 >  ac_status=$?
7875 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7876 >  (exit $ac_status); }; }; then
7877 >  ac_cv_header_time=yes
7878 > else
7879 >  echo "$as_me: failed program was:" >&5
7880 > sed 's/^/| /' conftest.$ac_ext >&5
7881 >
7882 > ac_cv_header_time=no
7883 > fi
7884 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7885 > fi
7886 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7887 > echo "${ECHO_T}$ac_cv_header_time" >&6
7888 > if test $ac_cv_header_time = yes; then
7889 >
7890 > cat >>confdefs.h <<\_ACEOF
7891 > #define TIME_WITH_SYS_TIME 1
7892 > _ACEOF
7893 >
7894 > fi
7895 >
7896 > echo "$as_me:$LINENO: checking for clock_t" >&5
7897 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7898 > if test "${ac_cv_type_clock_t+set}" = set; then
7899 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7900 > else
7901 >  cat >conftest.$ac_ext <<_ACEOF
7902 > /* confdefs.h.  */
7903 > _ACEOF
7904 > cat confdefs.h >>conftest.$ac_ext
7905 > cat >>conftest.$ac_ext <<_ACEOF
7906 > /* end confdefs.h.  */
7907 > $ac_includes_default
7908 > #ifdef FC_DUMMY_MAIN
7909 > #ifndef FC_DUMMY_MAIN_EQ_F77
7910 > #  ifdef __cplusplus
7911 >     extern "C"
7912 > #  endif
7913 >   int FC_DUMMY_MAIN() { return 1; }
7914 > #endif
7915 > #endif
7916 > int
7917 > main ()
7918 > {
7919 > if ((clock_t *) 0)
7920 >  return 0;
7921 > if (sizeof (clock_t))
7922 >  return 0;
7923 >  ;
7924 >  return 0;
7925 > }
7926 > _ACEOF
7927 > rm -f conftest.$ac_objext
7928 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7929 >  (eval $ac_compile) 2>conftest.er1
7930 >  ac_status=$?
7931 >  grep -v '^ *+' conftest.er1 >conftest.err
7932 >  rm -f conftest.er1
7933 >  cat conftest.err >&5
7934 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7935 >  (exit $ac_status); } &&
7936 >         { ac_try='test -z "$ac_c_werror_flag"
7937 >                         || test ! -s conftest.err'
7938 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7939 >  (eval $ac_try) 2>&5
7940 >  ac_status=$?
7941 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7942 >  (exit $ac_status); }; } &&
7943 >         { ac_try='test -s conftest.$ac_objext'
7944 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7945 >  (eval $ac_try) 2>&5
7946 >  ac_status=$?
7947 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7948 >  (exit $ac_status); }; }; then
7949 >  ac_cv_type_clock_t=yes
7950 > else
7951 >  echo "$as_me: failed program was:" >&5
7952 > sed 's/^/| /' conftest.$ac_ext >&5
7953 >
7954 > ac_cv_type_clock_t=no
7955 > fi
7956 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7957 > fi
7958 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7959 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7960 > if test $ac_cv_type_clock_t = yes; then
7961 >
7962 > cat >>confdefs.h <<_ACEOF
7963 > #define HAVE_CLOCK_T 1
7964 > _ACEOF
7965 >
7966 >
7967 > fi
7968 >
7969 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7970 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7971 > if test "${ac_cv_c_const+set}" = set; then
7972 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7973 > else
7974 >  cat >conftest.$ac_ext <<_ACEOF
7975 > /* confdefs.h.  */
7976 > _ACEOF
7977 > cat confdefs.h >>conftest.$ac_ext
7978 > cat >>conftest.$ac_ext <<_ACEOF
7979 > /* end confdefs.h.  */
7980 >
7981 > #ifdef FC_DUMMY_MAIN
7982 > #ifndef FC_DUMMY_MAIN_EQ_F77
7983 > #  ifdef __cplusplus
7984 >     extern "C"
7985 > #  endif
7986 >   int FC_DUMMY_MAIN() { return 1; }
7987 > #endif
7988 > #endif
7989 > int
7990 > main ()
7991 > {
7992 > /* FIXME: Include the comments suggested by Paul. */
7993 > #ifndef __cplusplus
7994 >  /* Ultrix mips cc rejects this.  */
7995 >  typedef int charset[2];
7996 >  const charset x;
7997 >  /* SunOS 4.1.1 cc rejects this.  */
7998 >  char const *const *ccp;
7999 >  char **p;
8000 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8001 >  struct point {int x, y;};
8002 >  static struct point const zero = {0,0};
8003 >  /* AIX XL C 1.02.0.0 rejects this.
8004 >     It does not let you subtract one const X* pointer from another in
8005 >     an arm of an if-expression whose if-part is not a constant
8006 >     expression */
8007 >  const char *g = "string";
8008 >  ccp = &g + (g ? g-g : 0);
8009 >  /* HPUX 7.0 cc rejects these. */
8010 >  ++ccp;
8011 >  p = (char**) ccp;
8012 >  ccp = (char const *const *) p;
8013 >  { /* SCO 3.2v4 cc rejects this.  */
8014 >    char *t;
8015 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8016 >
8017 >    *t++ = 0;
8018 >  }
8019 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8020 >    int x[] = {25, 17};
8021 >    const int *foo = &x[0];
8022 >    ++foo;
8023 >  }
8024 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8025 >    typedef const int *iptr;
8026 >    iptr p = 0;
8027 >    ++p;
8028 >  }
8029 >  { /* AIX XL C 1.02.0.0 rejects this saying
8030 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8031 >    struct s { int j; const int *ap[3]; };
8032 >    struct s *b; b->j = 5;
8033 >  }
8034 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8035 >    const int foo = 10;
8036 >  }
8037 > #endif
8038 >
8039 >  ;
8040 >  return 0;
8041 > }
8042 > _ACEOF
8043 > rm -f conftest.$ac_objext
8044 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8045 >  (eval $ac_compile) 2>conftest.er1
8046 >  ac_status=$?
8047 >  grep -v '^ *+' conftest.er1 >conftest.err
8048 >  rm -f conftest.er1
8049 >  cat conftest.err >&5
8050 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8051 >  (exit $ac_status); } &&
8052 >         { ac_try='test -z "$ac_c_werror_flag"
8053 >                         || test ! -s conftest.err'
8054 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8055 >  (eval $ac_try) 2>&5
8056 >  ac_status=$?
8057 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8058 >  (exit $ac_status); }; } &&
8059 >         { ac_try='test -s conftest.$ac_objext'
8060 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8061 >  (eval $ac_try) 2>&5
8062 >  ac_status=$?
8063 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8064 >  (exit $ac_status); }; }; then
8065 >  ac_cv_c_const=yes
8066 > else
8067 >  echo "$as_me: failed program was:" >&5
8068 > sed 's/^/| /' conftest.$ac_ext >&5
8069 >
8070 > ac_cv_c_const=no
8071 > fi
8072 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8073 > fi
8074 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8075 > echo "${ECHO_T}$ac_cv_c_const" >&6
8076 > if test $ac_cv_c_const = no; then
8077 >
8078 > cat >>confdefs.h <<\_ACEOF
8079 > #define const
8080 > _ACEOF
8081 >
8082 > fi
8083 >
8084 > echo "$as_me:$LINENO: checking for inline" >&5
8085 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8086 > if test "${ac_cv_c_inline+set}" = set; then
8087 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8088 > else
8089 >  ac_cv_c_inline=no
8090 > for ac_kw in inline __inline__ __inline; do
8091 >  cat >conftest.$ac_ext <<_ACEOF
8092 > /* confdefs.h.  */
8093 > _ACEOF
8094 > cat confdefs.h >>conftest.$ac_ext
8095 > cat >>conftest.$ac_ext <<_ACEOF
8096 > /* end confdefs.h.  */
8097 > #ifndef __cplusplus
8098 > typedef int foo_t;
8099 > static $ac_kw foo_t static_foo () {return 0; }
8100 > $ac_kw foo_t foo () {return 0; }
8101 > #endif
8102 >
8103 > _ACEOF
8104 > rm -f conftest.$ac_objext
8105 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8106 >  (eval $ac_compile) 2>conftest.er1
8107 >  ac_status=$?
8108 >  grep -v '^ *+' conftest.er1 >conftest.err
8109 >  rm -f conftest.er1
8110 >  cat conftest.err >&5
8111 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8112 >  (exit $ac_status); } &&
8113 >         { ac_try='test -z "$ac_c_werror_flag"
8114 >                         || test ! -s conftest.err'
8115 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8116 >  (eval $ac_try) 2>&5
8117 >  ac_status=$?
8118 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8119 >  (exit $ac_status); }; } &&
8120 >         { ac_try='test -s conftest.$ac_objext'
8121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8122 >  (eval $ac_try) 2>&5
8123 >  ac_status=$?
8124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8125 >  (exit $ac_status); }; }; then
8126 >  ac_cv_c_inline=$ac_kw; break
8127 > else
8128 >  echo "$as_me: failed program was:" >&5
8129 > sed 's/^/| /' conftest.$ac_ext >&5
8130 >
8131 > fi
8132 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8133 > done
8134 >
8135 > fi
8136 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8137 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8138 >
8139 >
8140 > case $ac_cv_c_inline in
8141 >  inline | yes) ;;
8142 >  *)
8143 >    case $ac_cv_c_inline in
8144 >      no) ac_val=;;
8145 >      *) ac_val=$ac_cv_c_inline;;
8146 >    esac
8147 >    cat >>confdefs.h <<_ACEOF
8148 > #ifndef __cplusplus
8149 > #define inline $ac_val
8150 > #endif
8151 > _ACEOF
8152 >    ;;
8153 > esac
8154 >
8155 >
8156 > # Checks for library functions.
8157 >
8158 > for ac_header in stdlib.h
8159 > do
8160 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8161 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8162 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8163 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8164 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8165 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8166 > fi
8167 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8168 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8169 > else
8170 >  # Is the header compilable?
8171 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8172 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8173 > cat >conftest.$ac_ext <<_ACEOF
8174 > /* confdefs.h.  */
8175 > _ACEOF
8176 > cat confdefs.h >>conftest.$ac_ext
8177 > cat >>conftest.$ac_ext <<_ACEOF
8178 > /* end confdefs.h.  */
8179 > $ac_includes_default
8180 > #include <$ac_header>
8181 > _ACEOF
8182 > rm -f conftest.$ac_objext
8183 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8184 >  (eval $ac_compile) 2>conftest.er1
8185 >  ac_status=$?
8186 >  grep -v '^ *+' conftest.er1 >conftest.err
8187 >  rm -f conftest.er1
8188 >  cat conftest.err >&5
8189 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8190 >  (exit $ac_status); } &&
8191 >         { ac_try='test -z "$ac_c_werror_flag"
8192 >                         || test ! -s conftest.err'
8193 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8194 >  (eval $ac_try) 2>&5
8195 >  ac_status=$?
8196 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8197 >  (exit $ac_status); }; } &&
8198 >         { ac_try='test -s conftest.$ac_objext'
8199 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8200 >  (eval $ac_try) 2>&5
8201 >  ac_status=$?
8202 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8203 >  (exit $ac_status); }; }; then
8204 >  ac_header_compiler=yes
8205 > else
8206 >  echo "$as_me: failed program was:" >&5
8207 > sed 's/^/| /' conftest.$ac_ext >&5
8208 >
8209 > ac_header_compiler=no
8210 > fi
8211 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8212 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8213 > echo "${ECHO_T}$ac_header_compiler" >&6
8214 >
8215 > # Is the header present?
8216 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8217 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8218 > cat >conftest.$ac_ext <<_ACEOF
8219 > /* confdefs.h.  */
8220 > _ACEOF
8221 > cat confdefs.h >>conftest.$ac_ext
8222 > cat >>conftest.$ac_ext <<_ACEOF
8223 > /* end confdefs.h.  */
8224 > #include <$ac_header>
8225 > _ACEOF
8226 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8227 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8228 >  ac_status=$?
8229 >  grep -v '^ *+' conftest.er1 >conftest.err
8230 >  rm -f conftest.er1
8231 >  cat conftest.err >&5
8232 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8233 >  (exit $ac_status); } >/dev/null; then
8234 >  if test -s conftest.err; then
8235 >    ac_cpp_err=$ac_c_preproc_warn_flag
8236 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8237 >  else
8238 >    ac_cpp_err=
8239 >  fi
8240 > else
8241 >  ac_cpp_err=yes
8242 > fi
8243 > if test -z "$ac_cpp_err"; then
8244 >  ac_header_preproc=yes
8245 > else
8246 >  echo "$as_me: failed program was:" >&5
8247 > sed 's/^/| /' conftest.$ac_ext >&5
8248 >
8249 >  ac_header_preproc=no
8250 > fi
8251 > rm -f conftest.err conftest.$ac_ext
8252 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8253 > echo "${ECHO_T}$ac_header_preproc" >&6
8254 >
8255 > # So?  What about this header?
8256 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8257 >  yes:no: )
8258 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8259 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8260 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8261 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8262 >    ac_header_preproc=yes
8263 >    ;;
8264 >  no:yes:* )
8265 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8266 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8267 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8268 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8269 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8270 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8271 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8272 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8273 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8274 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8275 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8276 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8277 >    (
8278 >      cat <<\_ASBOX
8279 > ## ------------------------------ ##
8280 > ## Report this to gezelter@nd.edu ##
8281 > ## ------------------------------ ##
8282 > _ASBOX
8283 >    ) |
8284 >      sed "s/^/$as_me: WARNING:     /" >&2
8285 >    ;;
8286 > esac
8287 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8288 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8289 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8290 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8291 > else
8292 >  eval "$as_ac_Header=\$ac_header_preproc"
8293 > fi
8294 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8295 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8296 >
8297 > fi
8298 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8299 >  cat >>confdefs.h <<_ACEOF
8300 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8301 > _ACEOF
8302 >
8303 > fi
8304 >
8305 > done
8306 >
8307 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8308 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8309 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8310 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8311 > else
8312 >  if test "$cross_compiling" = yes; then
8313 >  ac_cv_func_malloc_0_nonnull=no
8314 > else
8315 >  cat >conftest.$ac_ext <<_ACEOF
8316 > /* confdefs.h.  */
8317 > _ACEOF
8318 > cat confdefs.h >>conftest.$ac_ext
8319 > cat >>conftest.$ac_ext <<_ACEOF
8320 > /* end confdefs.h.  */
8321 > #if STDC_HEADERS || HAVE_STDLIB_H
8322 > # include <stdlib.h>
8323 > #else
8324 > char *malloc ();
8325 > #endif
8326 >
8327 > #ifdef FC_DUMMY_MAIN
8328 > #ifndef FC_DUMMY_MAIN_EQ_F77
8329 > #  ifdef __cplusplus
8330 >     extern "C"
8331 > #  endif
8332 >   int FC_DUMMY_MAIN() { return 1; }
8333 > #endif
8334 > #endif
8335 > int
8336 > main ()
8337 > {
8338 > exit (malloc (0) ? 0 : 1);
8339 >  ;
8340 >  return 0;
8341 > }
8342 > _ACEOF
8343 > rm -f conftest$ac_exeext
8344 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8345 >  (eval $ac_link) 2>&5
8346 >  ac_status=$?
8347 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8348 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8349 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8350 >  (eval $ac_try) 2>&5
8351 >  ac_status=$?
8352 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8353 >  (exit $ac_status); }; }; then
8354 >  ac_cv_func_malloc_0_nonnull=yes
8355 > else
8356 >  echo "$as_me: program exited with status $ac_status" >&5
8357 > echo "$as_me: failed program was:" >&5
8358 > sed 's/^/| /' conftest.$ac_ext >&5
8359 >
8360 > ( exit $ac_status )
8361 > ac_cv_func_malloc_0_nonnull=no
8362 > fi
8363 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8364 > fi
8365 > fi
8366 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8367 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8368 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8369 >
8370 > cat >>confdefs.h <<\_ACEOF
8371 > #define HAVE_MALLOC 1
8372 > _ACEOF
8373 >
8374 > else
8375 >  cat >>confdefs.h <<\_ACEOF
8376 > #define HAVE_MALLOC 0
8377 > _ACEOF
8378 >
8379 >   case $LIBOBJS in
8380 >    "malloc.$ac_objext"   | \
8381 >  *" malloc.$ac_objext"   | \
8382 >    "malloc.$ac_objext "* | \
8383 >  *" malloc.$ac_objext "* ) ;;
8384 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8385 > esac
8386 >
8387 >
8388 > cat >>confdefs.h <<\_ACEOF
8389 > #define malloc rpl_malloc
8390 > _ACEOF
8391 >
8392 > fi
8393 >
8394 >
8395 >
8396 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8397 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8398 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8399 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8400 > else
8401 >  if test "$cross_compiling" = yes; then
8402 >  ac_cv_func_memcmp_working=no
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 > $ac_includes_default
8411 > #ifdef FC_DUMMY_MAIN
8412 > #ifndef FC_DUMMY_MAIN_EQ_F77
8413 > #  ifdef __cplusplus
8414 >     extern "C"
8415 > #  endif
8416 >   int FC_DUMMY_MAIN() { return 1; }
8417 > #endif
8418 > #endif
8419 > int
8420 > main ()
8421 > {
8422 >
8423 >  /* Some versions of memcmp are not 8-bit clean.  */
8424 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8425 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8426 >    exit (1);
8427 >
8428 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8429 >     or more and with at least one buffer not starting on a 4-byte boundary.
8430 >     William Lewis provided this test program.   */
8431 >  {
8432 >    char foo[21];
8433 >    char bar[21];
8434 >    int i;
8435 >    for (i = 0; i < 4; i++)
8436 >      {
8437 >        char *a = foo + i;
8438 >        char *b = bar + i;
8439 >        strcpy (a, "--------01111111");
8440 >        strcpy (b, "--------10000000");
8441 >        if (memcmp (a, b, 16) >= 0)
8442 >          exit (1);
8443 >      }
8444 >    exit (0);
8445 >  }
8446 >
8447 >  ;
8448 >  return 0;
8449 > }
8450 > _ACEOF
8451 > rm -f conftest$ac_exeext
8452 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8453 >  (eval $ac_link) 2>&5
8454 >  ac_status=$?
8455 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8456 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8457 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8458 >  (eval $ac_try) 2>&5
8459 >  ac_status=$?
8460 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8461 >  (exit $ac_status); }; }; then
8462 >  ac_cv_func_memcmp_working=yes
8463 > else
8464 >  echo "$as_me: program exited with status $ac_status" >&5
8465 > echo "$as_me: failed program was:" >&5
8466 > sed 's/^/| /' conftest.$ac_ext >&5
8467 >
8468 > ( exit $ac_status )
8469 > ac_cv_func_memcmp_working=no
8470 > fi
8471 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8472 > fi
8473 > fi
8474 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8475 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8476 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8477 >    "memcmp.$ac_objext"   | \
8478 >  *" memcmp.$ac_objext"   | \
8479 >    "memcmp.$ac_objext "* | \
8480 >  *" memcmp.$ac_objext "* ) ;;
8481 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8482 > esac
8483 >
8484 >
8485 >
8486 > for ac_header in stdlib.h
8487 > do
8488 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8489 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8490 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8491 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8492 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8493 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8494 > fi
8495 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8496 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8497 > else
8498 >  # Is the header compilable?
8499 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8500 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8501 > cat >conftest.$ac_ext <<_ACEOF
8502 > /* confdefs.h.  */
8503 > _ACEOF
8504 > cat confdefs.h >>conftest.$ac_ext
8505 > cat >>conftest.$ac_ext <<_ACEOF
8506 > /* end confdefs.h.  */
8507 > $ac_includes_default
8508 > #include <$ac_header>
8509 > _ACEOF
8510 > rm -f conftest.$ac_objext
8511 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8512 >  (eval $ac_compile) 2>conftest.er1
8513 >  ac_status=$?
8514 >  grep -v '^ *+' conftest.er1 >conftest.err
8515 >  rm -f conftest.er1
8516 >  cat conftest.err >&5
8517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8518 >  (exit $ac_status); } &&
8519 >         { ac_try='test -z "$ac_c_werror_flag"
8520 >                         || test ! -s conftest.err'
8521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8522 >  (eval $ac_try) 2>&5
8523 >  ac_status=$?
8524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8525 >  (exit $ac_status); }; } &&
8526 >         { ac_try='test -s conftest.$ac_objext'
8527 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8528 >  (eval $ac_try) 2>&5
8529 >  ac_status=$?
8530 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8531 >  (exit $ac_status); }; }; then
8532 >  ac_header_compiler=yes
8533 > else
8534 >  echo "$as_me: failed program was:" >&5
8535 > sed 's/^/| /' conftest.$ac_ext >&5
8536 >
8537 > ac_header_compiler=no
8538 > fi
8539 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8540 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8541 > echo "${ECHO_T}$ac_header_compiler" >&6
8542 >
8543 > # Is the header present?
8544 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8545 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8546 > cat >conftest.$ac_ext <<_ACEOF
8547 > /* confdefs.h.  */
8548 > _ACEOF
8549 > cat confdefs.h >>conftest.$ac_ext
8550 > cat >>conftest.$ac_ext <<_ACEOF
8551 > /* end confdefs.h.  */
8552 > #include <$ac_header>
8553 > _ACEOF
8554 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8555 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8556 >  ac_status=$?
8557 >  grep -v '^ *+' conftest.er1 >conftest.err
8558 >  rm -f conftest.er1
8559 >  cat conftest.err >&5
8560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8561 >  (exit $ac_status); } >/dev/null; then
8562 >  if test -s conftest.err; then
8563 >    ac_cpp_err=$ac_c_preproc_warn_flag
8564 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8565 >  else
8566 >    ac_cpp_err=
8567 >  fi
8568 > else
8569 >  ac_cpp_err=yes
8570 > fi
8571 > if test -z "$ac_cpp_err"; then
8572 >  ac_header_preproc=yes
8573 > else
8574 >  echo "$as_me: failed program was:" >&5
8575 > sed 's/^/| /' conftest.$ac_ext >&5
8576 >
8577 >  ac_header_preproc=no
8578 > fi
8579 > rm -f conftest.err conftest.$ac_ext
8580 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8581 > echo "${ECHO_T}$ac_header_preproc" >&6
8582 >
8583 > # So?  What about this header?
8584 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8585 >  yes:no: )
8586 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8587 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8588 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8589 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8590 >    ac_header_preproc=yes
8591 >    ;;
8592 >  no:yes:* )
8593 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8594 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8595 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8596 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8598 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8599 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8600 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8601 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8602 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8603 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8604 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8605 >    (
8606 >      cat <<\_ASBOX
8607 > ## ------------------------------ ##
8608 > ## Report this to gezelter@nd.edu ##
8609 > ## ------------------------------ ##
8610 > _ASBOX
8611 >    ) |
8612 >      sed "s/^/$as_me: WARNING:     /" >&2
8613 >    ;;
8614 > esac
8615 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8616 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8617 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8618 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8619 > else
8620 >  eval "$as_ac_Header=\$ac_header_preproc"
8621 > fi
8622 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8623 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8624 >
8625 > fi
8626 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8627 >  cat >>confdefs.h <<_ACEOF
8628 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8629 > _ACEOF
8630 >
8631 > fi
8632 >
8633 > done
8634 >
8635 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8636 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8637 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8639 > else
8640 >  if test "$cross_compiling" = yes; then
8641 >  ac_cv_func_realloc_0_nonnull=no
8642 > else
8643 >  cat >conftest.$ac_ext <<_ACEOF
8644 > /* confdefs.h.  */
8645 > _ACEOF
8646 > cat confdefs.h >>conftest.$ac_ext
8647 > cat >>conftest.$ac_ext <<_ACEOF
8648 > /* end confdefs.h.  */
8649 > #if STDC_HEADERS || HAVE_STDLIB_H
8650 > # include <stdlib.h>
8651 > #else
8652 > char *realloc ();
8653 > #endif
8654 >
8655 > #ifdef FC_DUMMY_MAIN
8656 > #ifndef FC_DUMMY_MAIN_EQ_F77
8657 > #  ifdef __cplusplus
8658 >     extern "C"
8659 > #  endif
8660 >   int FC_DUMMY_MAIN() { return 1; }
8661 > #endif
8662 > #endif
8663 > int
8664 > main ()
8665 > {
8666 > exit (realloc (0, 0) ? 0 : 1);
8667 >  ;
8668 >  return 0;
8669 > }
8670 > _ACEOF
8671 > rm -f conftest$ac_exeext
8672 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8673 >  (eval $ac_link) 2>&5
8674 >  ac_status=$?
8675 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8676 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8677 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8678 >  (eval $ac_try) 2>&5
8679 >  ac_status=$?
8680 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8681 >  (exit $ac_status); }; }; then
8682 >  ac_cv_func_realloc_0_nonnull=yes
8683 > else
8684 >  echo "$as_me: program exited with status $ac_status" >&5
8685 > echo "$as_me: failed program was:" >&5
8686 > sed 's/^/| /' conftest.$ac_ext >&5
8687 >
8688 > ( exit $ac_status )
8689 > ac_cv_func_realloc_0_nonnull=no
8690 > fi
8691 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8692 > fi
8693 > fi
8694 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8695 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8696 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8697 >
8698 > cat >>confdefs.h <<\_ACEOF
8699 > #define HAVE_REALLOC 1
8700 > _ACEOF
8701 >
8702 > else
8703 >  cat >>confdefs.h <<\_ACEOF
8704 > #define HAVE_REALLOC 0
8705 > _ACEOF
8706 >
8707 >   case $LIBOBJS in
8708 >    "realloc.$ac_objext"   | \
8709 >  *" realloc.$ac_objext"   | \
8710 >    "realloc.$ac_objext "* | \
8711 >  *" realloc.$ac_objext "* ) ;;
8712 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8713 > esac
8714 >
8715 >
8716 > cat >>confdefs.h <<\_ACEOF
8717 > #define realloc rpl_realloc
8718 > _ACEOF
8719 >
8720 > fi
8721 >
8722 >
8723 >
8724 >
8725 >
8726 > for ac_header in sys/select.h sys/socket.h
8727 > do
8728 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8729 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8730 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8731 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8732 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8733 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8734 > fi
8735 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8736 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8737 > else
8738 >  # Is the header compilable?
8739 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8740 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8741 > cat >conftest.$ac_ext <<_ACEOF
8742 > /* confdefs.h.  */
8743 > _ACEOF
8744 > cat confdefs.h >>conftest.$ac_ext
8745 > cat >>conftest.$ac_ext <<_ACEOF
8746 > /* end confdefs.h.  */
8747 > $ac_includes_default
8748 > #include <$ac_header>
8749 > _ACEOF
8750 > rm -f conftest.$ac_objext
8751 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8752 >  (eval $ac_compile) 2>conftest.er1
8753 >  ac_status=$?
8754 >  grep -v '^ *+' conftest.er1 >conftest.err
8755 >  rm -f conftest.er1
8756 >  cat conftest.err >&5
8757 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8758 >  (exit $ac_status); } &&
8759 >         { ac_try='test -z "$ac_c_werror_flag"
8760 >                         || test ! -s conftest.err'
8761 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8762 >  (eval $ac_try) 2>&5
8763 >  ac_status=$?
8764 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8765 >  (exit $ac_status); }; } &&
8766 >         { ac_try='test -s conftest.$ac_objext'
8767 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8768 >  (eval $ac_try) 2>&5
8769 >  ac_status=$?
8770 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8771 >  (exit $ac_status); }; }; then
8772 >  ac_header_compiler=yes
8773 > else
8774 >  echo "$as_me: failed program was:" >&5
8775 > sed 's/^/| /' conftest.$ac_ext >&5
8776 >
8777 > ac_header_compiler=no
8778 > fi
8779 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8780 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8781 > echo "${ECHO_T}$ac_header_compiler" >&6
8782 >
8783 > # Is the header present?
8784 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8785 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8786 > cat >conftest.$ac_ext <<_ACEOF
8787 > /* confdefs.h.  */
8788 > _ACEOF
8789 > cat confdefs.h >>conftest.$ac_ext
8790 > cat >>conftest.$ac_ext <<_ACEOF
8791 > /* end confdefs.h.  */
8792 > #include <$ac_header>
8793 > _ACEOF
8794 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8795 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8796 >  ac_status=$?
8797 >  grep -v '^ *+' conftest.er1 >conftest.err
8798 >  rm -f conftest.er1
8799 >  cat conftest.err >&5
8800 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8801 >  (exit $ac_status); } >/dev/null; then
8802 >  if test -s conftest.err; then
8803 >    ac_cpp_err=$ac_c_preproc_warn_flag
8804 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8805 >  else
8806 >    ac_cpp_err=
8807 >  fi
8808 > else
8809 >  ac_cpp_err=yes
8810 > fi
8811 > if test -z "$ac_cpp_err"; then
8812 >  ac_header_preproc=yes
8813 > else
8814 >  echo "$as_me: failed program was:" >&5
8815 > sed 's/^/| /' conftest.$ac_ext >&5
8816 >
8817 >  ac_header_preproc=no
8818 > fi
8819 > rm -f conftest.err conftest.$ac_ext
8820 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8821 > echo "${ECHO_T}$ac_header_preproc" >&6
8822 >
8823 > # So?  What about this header?
8824 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8825 >  yes:no: )
8826 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8827 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8828 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8829 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8830 >    ac_header_preproc=yes
8831 >    ;;
8832 >  no:yes:* )
8833 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8834 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8835 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8836 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8837 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8838 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8839 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8840 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8841 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8842 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8843 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8844 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8845 >    (
8846 >      cat <<\_ASBOX
8847 > ## ------------------------------ ##
8848 > ## Report this to gezelter@nd.edu ##
8849 > ## ------------------------------ ##
8850 > _ASBOX
8851 >    ) |
8852 >      sed "s/^/$as_me: WARNING:     /" >&2
8853 >    ;;
8854 > esac
8855 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8856 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8857 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8858 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8859 > else
8860 >  eval "$as_ac_Header=\$ac_header_preproc"
8861 > fi
8862 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8863 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8864 >
8865 > fi
8866 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8867 >  cat >>confdefs.h <<_ACEOF
8868 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8869 > _ACEOF
8870 >
8871 > fi
8872 >
8873 > done
8874 >
8875 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8876 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8877 > if test "${ac_cv_func_select_args+set}" = set; then
8878 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8879 > else
8880 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8881 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8882 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8883 >   cat >conftest.$ac_ext <<_ACEOF
8884 > /* confdefs.h.  */
8885 > _ACEOF
8886 > cat confdefs.h >>conftest.$ac_ext
8887 > cat >>conftest.$ac_ext <<_ACEOF
8888 > /* end confdefs.h.  */
8889 > $ac_includes_default
8890 > #if HAVE_SYS_SELECT_H
8891 > # include <sys/select.h>
8892 > #endif
8893 > #if HAVE_SYS_SOCKET_H
8894 > # include <sys/socket.h>
8895 > #endif
8896 >
8897 > #ifdef FC_DUMMY_MAIN
8898 > #ifndef FC_DUMMY_MAIN_EQ_F77
8899 > #  ifdef __cplusplus
8900 >     extern "C"
8901 > #  endif
8902 >   int FC_DUMMY_MAIN() { return 1; }
8903 > #endif
8904 > #endif
8905 > int
8906 > main ()
8907 > {
8908 > extern int select ($ac_arg1,
8909 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8910 >                                            $ac_arg5);
8911 >  ;
8912 >  return 0;
8913 > }
8914 > _ACEOF
8915 > rm -f conftest.$ac_objext
8916 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8917 >  (eval $ac_compile) 2>conftest.er1
8918 >  ac_status=$?
8919 >  grep -v '^ *+' conftest.er1 >conftest.err
8920 >  rm -f conftest.er1
8921 >  cat conftest.err >&5
8922 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8923 >  (exit $ac_status); } &&
8924 >         { ac_try='test -z "$ac_c_werror_flag"
8925 >                         || test ! -s conftest.err'
8926 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8927 >  (eval $ac_try) 2>&5
8928 >  ac_status=$?
8929 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8930 >  (exit $ac_status); }; } &&
8931 >         { ac_try='test -s conftest.$ac_objext'
8932 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8933 >  (eval $ac_try) 2>&5
8934 >  ac_status=$?
8935 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8936 >  (exit $ac_status); }; }; then
8937 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8938 > else
8939 >  echo "$as_me: failed program was:" >&5
8940 > sed 's/^/| /' conftest.$ac_ext >&5
8941 >
8942 > fi
8943 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8944 >  done
8945 > done
8946 > done
8947 > # Provide a safe default value.
8948 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8949 >
8950 > fi
8951 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8952 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8953 > ac_save_IFS=$IFS; IFS=','
8954 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8955 > IFS=$ac_save_IFS
8956 > shift
8957 >
8958 > cat >>confdefs.h <<_ACEOF
8959 > #define SELECT_TYPE_ARG1 $1
8960 > _ACEOF
8961 >
8962 >
8963 > cat >>confdefs.h <<_ACEOF
8964 > #define SELECT_TYPE_ARG234 ($2)
8965 > _ACEOF
8966 >
8967 >
8968 > cat >>confdefs.h <<_ACEOF
8969 > #define SELECT_TYPE_ARG5 ($3)
8970 > _ACEOF
8971 >
8972 > rm -f conftest*
8973 >
8974 >
8975 > for ac_func in strftime
8976 > do
8977 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8978 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8979 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8980 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8981 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8982 > else
8983 >  cat >conftest.$ac_ext <<_ACEOF
8984 > /* confdefs.h.  */
8985 > _ACEOF
8986 > cat confdefs.h >>conftest.$ac_ext
8987 > cat >>conftest.$ac_ext <<_ACEOF
8988 > /* end confdefs.h.  */
8989 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8990 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8991 > #define $ac_func innocuous_$ac_func
8992 >
8993 > /* System header to define __stub macros and hopefully few prototypes,
8994 >    which can conflict with char $ac_func (); below.
8995 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8996 >    <limits.h> exists even on freestanding compilers.  */
8997 >
8998 > #ifdef __STDC__
8999 > # include <limits.h>
9000 > #else
9001 > # include <assert.h>
9002 > #endif
9003 >
9004 > #undef $ac_func
9005 >
9006 > /* Override any gcc2 internal prototype to avoid an error.  */
9007 > #ifdef __cplusplus
9008 > extern "C"
9009 > {
9010 > #endif
9011 > /* We use char because int might match the return type of a gcc2
9012 >   builtin and then its argument prototype would still apply.  */
9013 > char $ac_func ();
9014 > /* The GNU C library defines this for functions which it implements
9015 >    to always fail with ENOSYS.  Some functions are actually named
9016 >    something starting with __ and the normal name is an alias.  */
9017 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9018 > choke me
9019 > #else
9020 > char (*f) () = $ac_func;
9021 > #endif
9022 > #ifdef __cplusplus
9023 > }
9024 > #endif
9025 >
9026 > #ifdef FC_DUMMY_MAIN
9027 > #ifndef FC_DUMMY_MAIN_EQ_F77
9028 > #  ifdef __cplusplus
9029 >     extern "C"
9030 > #  endif
9031 >   int FC_DUMMY_MAIN() { return 1; }
9032 > #endif
9033 > #endif
9034 > int
9035 > main ()
9036 > {
9037 > return f != $ac_func;
9038 >  ;
9039 >  return 0;
9040 > }
9041 > _ACEOF
9042 > rm -f conftest.$ac_objext conftest$ac_exeext
9043 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9044 >  (eval $ac_link) 2>conftest.er1
9045 >  ac_status=$?
9046 >  grep -v '^ *+' conftest.er1 >conftest.err
9047 >  rm -f conftest.er1
9048 >  cat conftest.err >&5
9049 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9050 >  (exit $ac_status); } &&
9051 >         { ac_try='test -z "$ac_c_werror_flag"
9052 >                         || test ! -s conftest.err'
9053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9054 >  (eval $ac_try) 2>&5
9055 >  ac_status=$?
9056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9057 >  (exit $ac_status); }; } &&
9058 >         { ac_try='test -s conftest$ac_exeext'
9059 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9060 >  (eval $ac_try) 2>&5
9061 >  ac_status=$?
9062 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9063 >  (exit $ac_status); }; }; then
9064 >  eval "$as_ac_var=yes"
9065 > else
9066 >  echo "$as_me: failed program was:" >&5
9067 > sed 's/^/| /' conftest.$ac_ext >&5
9068 >
9069 > eval "$as_ac_var=no"
9070 > fi
9071 > rm -f conftest.err conftest.$ac_objext \
9072 >      conftest$ac_exeext conftest.$ac_ext
9073 > fi
9074 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9075 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9076 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9077 >  cat >>confdefs.h <<_ACEOF
9078 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9079 > _ACEOF
9080 >
9081 > else
9082 >  # strftime is in -lintl on SCO UNIX.
9083 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9084 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9085 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9086 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9087 > else
9088 >  ac_check_lib_save_LIBS=$LIBS
9089 > LIBS="-lintl  $LIBS"
9090 > cat >conftest.$ac_ext <<_ACEOF
9091 > /* confdefs.h.  */
9092 > _ACEOF
9093 > cat confdefs.h >>conftest.$ac_ext
9094 > cat >>conftest.$ac_ext <<_ACEOF
9095 > /* end confdefs.h.  */
9096 >
9097 > /* Override any gcc2 internal prototype to avoid an error.  */
9098 > #ifdef __cplusplus
9099 > extern "C"
9100 > #endif
9101 > /* We use char because int might match the return type of a gcc2
9102 >   builtin and then its argument prototype would still apply.  */
9103 > char strftime ();
9104 > #ifdef FC_DUMMY_MAIN
9105 > #ifndef FC_DUMMY_MAIN_EQ_F77
9106 > #  ifdef __cplusplus
9107 >     extern "C"
9108 > #  endif
9109 >   int FC_DUMMY_MAIN() { return 1; }
9110 > #endif
9111 > #endif
9112 > int
9113 > main ()
9114 > {
9115 > strftime ();
9116 >  ;
9117 >  return 0;
9118 > }
9119 > _ACEOF
9120 > rm -f conftest.$ac_objext conftest$ac_exeext
9121 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9122 >  (eval $ac_link) 2>conftest.er1
9123 >  ac_status=$?
9124 >  grep -v '^ *+' conftest.er1 >conftest.err
9125 >  rm -f conftest.er1
9126 >  cat conftest.err >&5
9127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9128 >  (exit $ac_status); } &&
9129 >         { ac_try='test -z "$ac_c_werror_flag"
9130 >                         || test ! -s conftest.err'
9131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9132 >  (eval $ac_try) 2>&5
9133 >  ac_status=$?
9134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9135 >  (exit $ac_status); }; } &&
9136 >         { ac_try='test -s conftest$ac_exeext'
9137 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9138 >  (eval $ac_try) 2>&5
9139 >  ac_status=$?
9140 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9141 >  (exit $ac_status); }; }; then
9142 >  ac_cv_lib_intl_strftime=yes
9143 > else
9144 >  echo "$as_me: failed program was:" >&5
9145 > sed 's/^/| /' conftest.$ac_ext >&5
9146 >
9147 > ac_cv_lib_intl_strftime=no
9148 > fi
9149 > rm -f conftest.err conftest.$ac_objext \
9150 >      conftest$ac_exeext conftest.$ac_ext
9151 > LIBS=$ac_check_lib_save_LIBS
9152 > fi
9153 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9154 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9155 > if test $ac_cv_lib_intl_strftime = yes; then
9156 >  cat >>confdefs.h <<\_ACEOF
9157 > #define HAVE_STRFTIME 1
9158 > _ACEOF
9159 >
9160 > LIBS="-lintl $LIBS"
9161 > fi
9162 >
9163 > fi
9164 > done
9165 >
9166 > echo "$as_me:$LINENO: checking for working strtod" >&5
9167 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9168 > if test "${ac_cv_func_strtod+set}" = set; then
9169 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9170 > else
9171 >  if test "$cross_compiling" = yes; then
9172 >  ac_cv_func_strtod=no
9173 > else
9174 >  cat >conftest.$ac_ext <<_ACEOF
9175 > /* confdefs.h.  */
9176 > _ACEOF
9177 > cat confdefs.h >>conftest.$ac_ext
9178 > cat >>conftest.$ac_ext <<_ACEOF
9179 > /* end confdefs.h.  */
9180 >
9181 > double strtod ();
9182 > int
9183 > main()
9184 > {
9185 >  {
9186 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9187 >    char *string = " +69";
9188 >    char *term;
9189 >    double value;
9190 >    value = strtod (string, &term);
9191 >    if (value != 69 || term != (string + 4))
9192 >      exit (1);
9193 >  }
9194 >
9195 >  {
9196 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9197 >       terminating character under some conditions.  */
9198 >    char *string = "NaN";
9199 >    char *term;
9200 >    strtod (string, &term);
9201 >    if (term != string && *(term - 1) == 0)
9202 >      exit (1);
9203 >  }
9204 >  exit (0);
9205 > }
9206 >
9207 > _ACEOF
9208 > rm -f conftest$ac_exeext
9209 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9210 >  (eval $ac_link) 2>&5
9211 >  ac_status=$?
9212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9213 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9214 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9215 >  (eval $ac_try) 2>&5
9216 >  ac_status=$?
9217 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9218 >  (exit $ac_status); }; }; then
9219 >  ac_cv_func_strtod=yes
9220 > else
9221 >  echo "$as_me: program exited with status $ac_status" >&5
9222 > echo "$as_me: failed program was:" >&5
9223 > sed 's/^/| /' conftest.$ac_ext >&5
9224 >
9225 > ( exit $ac_status )
9226 > ac_cv_func_strtod=no
9227 > fi
9228 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9229 > fi
9230 > fi
9231 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9232 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9233 > if test $ac_cv_func_strtod = no; then
9234 >  case $LIBOBJS in
9235 >    "strtod.$ac_objext"   | \
9236 >  *" strtod.$ac_objext"   | \
9237 >    "strtod.$ac_objext "* | \
9238 >  *" strtod.$ac_objext "* ) ;;
9239 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9240 > esac
9241 >
9242 > echo "$as_me:$LINENO: checking for pow" >&5
9243 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9244 > if test "${ac_cv_func_pow+set}" = set; then
9245 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9246 > else
9247 >  cat >conftest.$ac_ext <<_ACEOF
9248 > /* confdefs.h.  */
9249 > _ACEOF
9250 > cat confdefs.h >>conftest.$ac_ext
9251 > cat >>conftest.$ac_ext <<_ACEOF
9252 > /* end confdefs.h.  */
9253 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9254 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9255 > #define pow innocuous_pow
9256 >
9257 > /* System header to define __stub macros and hopefully few prototypes,
9258 >    which can conflict with char pow (); below.
9259 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9260 >    <limits.h> exists even on freestanding compilers.  */
9261 >
9262 > #ifdef __STDC__
9263 > # include <limits.h>
9264 > #else
9265 > # include <assert.h>
9266 > #endif
9267 >
9268 > #undef pow
9269 >
9270 > /* Override any gcc2 internal prototype to avoid an error.  */
9271 > #ifdef __cplusplus
9272 > extern "C"
9273 > {
9274 > #endif
9275 > /* We use char because int might match the return type of a gcc2
9276 >   builtin and then its argument prototype would still apply.  */
9277 > char pow ();
9278 > /* The GNU C library defines this for functions which it implements
9279 >    to always fail with ENOSYS.  Some functions are actually named
9280 >    something starting with __ and the normal name is an alias.  */
9281 > #if defined (__stub_pow) || defined (__stub___pow)
9282 > choke me
9283 > #else
9284 > char (*f) () = pow;
9285 > #endif
9286 > #ifdef __cplusplus
9287 > }
9288 > #endif
9289 >
9290 > #ifdef FC_DUMMY_MAIN
9291 > #ifndef FC_DUMMY_MAIN_EQ_F77
9292 > #  ifdef __cplusplus
9293 >     extern "C"
9294 > #  endif
9295 >   int FC_DUMMY_MAIN() { return 1; }
9296 > #endif
9297 > #endif
9298 > int
9299 > main ()
9300 > {
9301 > return f != pow;
9302 >  ;
9303 >  return 0;
9304 > }
9305 > _ACEOF
9306 > rm -f conftest.$ac_objext conftest$ac_exeext
9307 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9308 >  (eval $ac_link) 2>conftest.er1
9309 >  ac_status=$?
9310 >  grep -v '^ *+' conftest.er1 >conftest.err
9311 >  rm -f conftest.er1
9312 >  cat conftest.err >&5
9313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314 >  (exit $ac_status); } &&
9315 >         { ac_try='test -z "$ac_c_werror_flag"
9316 >                         || test ! -s conftest.err'
9317 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9318 >  (eval $ac_try) 2>&5
9319 >  ac_status=$?
9320 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9321 >  (exit $ac_status); }; } &&
9322 >         { ac_try='test -s conftest$ac_exeext'
9323 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9324 >  (eval $ac_try) 2>&5
9325 >  ac_status=$?
9326 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9327 >  (exit $ac_status); }; }; then
9328 >  ac_cv_func_pow=yes
9329 > else
9330 >  echo "$as_me: failed program was:" >&5
9331 > sed 's/^/| /' conftest.$ac_ext >&5
9332 >
9333 > ac_cv_func_pow=no
9334 > fi
9335 > rm -f conftest.err conftest.$ac_objext \
9336 >      conftest$ac_exeext conftest.$ac_ext
9337 > fi
9338 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9339 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9340 >
9341 > if test $ac_cv_func_pow = no; then
9342 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9343 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9344 > if test "${ac_cv_lib_m_pow+set}" = set; then
9345 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9346 > else
9347 >  ac_check_lib_save_LIBS=$LIBS
9348 > LIBS="-lm  $LIBS"
9349 > cat >conftest.$ac_ext <<_ACEOF
9350 > /* confdefs.h.  */
9351 > _ACEOF
9352 > cat confdefs.h >>conftest.$ac_ext
9353 > cat >>conftest.$ac_ext <<_ACEOF
9354 > /* end confdefs.h.  */
9355 >
9356 > /* Override any gcc2 internal prototype to avoid an error.  */
9357 > #ifdef __cplusplus
9358 > extern "C"
9359 > #endif
9360 > /* We use char because int might match the return type of a gcc2
9361 >   builtin and then its argument prototype would still apply.  */
9362 > char pow ();
9363 > #ifdef FC_DUMMY_MAIN
9364 > #ifndef FC_DUMMY_MAIN_EQ_F77
9365 > #  ifdef __cplusplus
9366 >     extern "C"
9367 > #  endif
9368 >   int FC_DUMMY_MAIN() { return 1; }
9369 > #endif
9370 > #endif
9371 > int
9372 > main ()
9373 > {
9374 > pow ();
9375 >  ;
9376 >  return 0;
9377 > }
9378 > _ACEOF
9379 > rm -f conftest.$ac_objext conftest$ac_exeext
9380 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9381 >  (eval $ac_link) 2>conftest.er1
9382 >  ac_status=$?
9383 >  grep -v '^ *+' conftest.er1 >conftest.err
9384 >  rm -f conftest.er1
9385 >  cat conftest.err >&5
9386 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9387 >  (exit $ac_status); } &&
9388 >         { ac_try='test -z "$ac_c_werror_flag"
9389 >                         || test ! -s conftest.err'
9390 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9391 >  (eval $ac_try) 2>&5
9392 >  ac_status=$?
9393 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9394 >  (exit $ac_status); }; } &&
9395 >         { ac_try='test -s conftest$ac_exeext'
9396 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9397 >  (eval $ac_try) 2>&5
9398 >  ac_status=$?
9399 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9400 >  (exit $ac_status); }; }; then
9401 >  ac_cv_lib_m_pow=yes
9402 > else
9403 >  echo "$as_me: failed program was:" >&5
9404 > sed 's/^/| /' conftest.$ac_ext >&5
9405 >
9406 > ac_cv_lib_m_pow=no
9407 > fi
9408 > rm -f conftest.err conftest.$ac_objext \
9409 >      conftest$ac_exeext conftest.$ac_ext
9410 > LIBS=$ac_check_lib_save_LIBS
9411 > fi
9412 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9413 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9414 > if test $ac_cv_lib_m_pow = yes; then
9415 >  POW_LIB=-lm
9416 > else
9417 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9418 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9419 > fi
9420 >
9421 > fi
9422 >
9423 > fi
9424 >
9425 >
9426 >
9427 >
9428 >
9429 >
9430 >
9431 >
9432 >
9433 >
9434 >
9435 >
9436 >
9437 >
9438 >
9439 >
9440 >
9441 >
9442 >
9443 >
9444 >
9445 >
9446 >
9447 >
9448 >
9449 >
9450 >
9451 >
9452 > 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
9453 > do
9454 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9455 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9456 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9457 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9458 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9459 > else
9460 >  cat >conftest.$ac_ext <<_ACEOF
9461 > /* confdefs.h.  */
9462 > _ACEOF
9463 > cat confdefs.h >>conftest.$ac_ext
9464 > cat >>conftest.$ac_ext <<_ACEOF
9465 > /* end confdefs.h.  */
9466 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9467 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9468 > #define $ac_func innocuous_$ac_func
9469 >
9470 > /* System header to define __stub macros and hopefully few prototypes,
9471 >    which can conflict with char $ac_func (); below.
9472 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9473 >    <limits.h> exists even on freestanding compilers.  */
9474 >
9475 > #ifdef __STDC__
9476 > # include <limits.h>
9477 > #else
9478 > # include <assert.h>
9479 > #endif
9480 >
9481 > #undef $ac_func
9482 >
9483 > /* Override any gcc2 internal prototype to avoid an error.  */
9484 > #ifdef __cplusplus
9485 > extern "C"
9486 > {
9487 > #endif
9488 > /* We use char because int might match the return type of a gcc2
9489 >   builtin and then its argument prototype would still apply.  */
9490 > char $ac_func ();
9491 > /* The GNU C library defines this for functions which it implements
9492 >    to always fail with ENOSYS.  Some functions are actually named
9493 >    something starting with __ and the normal name is an alias.  */
9494 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9495 > choke me
9496 > #else
9497 > char (*f) () = $ac_func;
9498 > #endif
9499 > #ifdef __cplusplus
9500 > }
9501 > #endif
9502 >
9503 > #ifdef FC_DUMMY_MAIN
9504 > #ifndef FC_DUMMY_MAIN_EQ_F77
9505 > #  ifdef __cplusplus
9506 >     extern "C"
9507 > #  endif
9508 >   int FC_DUMMY_MAIN() { return 1; }
9509 > #endif
9510 > #endif
9511 > int
9512 > main ()
9513 > {
9514 > return f != $ac_func;
9515 >  ;
9516 >  return 0;
9517 > }
9518 > _ACEOF
9519 > rm -f conftest.$ac_objext conftest$ac_exeext
9520 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9521 >  (eval $ac_link) 2>conftest.er1
9522 >  ac_status=$?
9523 >  grep -v '^ *+' conftest.er1 >conftest.err
9524 >  rm -f conftest.er1
9525 >  cat conftest.err >&5
9526 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9527 >  (exit $ac_status); } &&
9528 >         { ac_try='test -z "$ac_c_werror_flag"
9529 >                         || test ! -s conftest.err'
9530 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9531 >  (eval $ac_try) 2>&5
9532 >  ac_status=$?
9533 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9534 >  (exit $ac_status); }; } &&
9535 >         { ac_try='test -s conftest$ac_exeext'
9536 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9537 >  (eval $ac_try) 2>&5
9538 >  ac_status=$?
9539 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9540 >  (exit $ac_status); }; }; then
9541 >  eval "$as_ac_var=yes"
9542 > else
9543 >  echo "$as_me: failed program was:" >&5
9544 > sed 's/^/| /' conftest.$ac_ext >&5
9545 >
9546 > eval "$as_ac_var=no"
9547 > fi
9548 > rm -f conftest.err conftest.$ac_objext \
9549 >      conftest$ac_exeext conftest.$ac_ext
9550 > fi
9551 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9552 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9553 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9554 >  cat >>confdefs.h <<_ACEOF
9555 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9556 > _ACEOF
9557 >
9558 > fi
9559 > done
9560 >
9561 >
9562 > # special check for _system_configuration because AIX <4.3.2 do not
9563 > # contain the `physmem' member.
9564 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9565 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9566 > cat >conftest.$ac_ext <<_ACEOF
9567 > /* confdefs.h.  */
9568 > _ACEOF
9569 > cat confdefs.h >>conftest.$ac_ext
9570 > cat >>conftest.$ac_ext <<_ACEOF
9571 > /* end confdefs.h.  */
9572 > #include <sys/systemcfg.h>
9573 > #ifdef FC_DUMMY_MAIN
9574 > #ifndef FC_DUMMY_MAIN_EQ_F77
9575 > #  ifdef __cplusplus
9576 >     extern "C"
9577 > #  endif
9578 >   int FC_DUMMY_MAIN() { return 1; }
9579 > #endif
9580 > #endif
9581 > int
9582 > main ()
9583 > {
9584 > double x = _system_configuration.physmem;
9585 >  ;
9586 >  return 0;
9587 > }
9588 > _ACEOF
9589 > rm -f conftest.$ac_objext
9590 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9591 >  (eval $ac_compile) 2>conftest.er1
9592 >  ac_status=$?
9593 >  grep -v '^ *+' conftest.er1 >conftest.err
9594 >  rm -f conftest.er1
9595 >  cat conftest.err >&5
9596 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9597 >  (exit $ac_status); } &&
9598 >         { ac_try='test -z "$ac_c_werror_flag"
9599 >                         || test ! -s conftest.err'
9600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9601 >  (eval $ac_try) 2>&5
9602 >  ac_status=$?
9603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9604 >  (exit $ac_status); }; } &&
9605 >         { ac_try='test -s conftest.$ac_objext'
9606 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9607 >  (eval $ac_try) 2>&5
9608 >  ac_status=$?
9609 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9610 >  (exit $ac_status); }; }; then
9611 >  echo "$as_me:$LINENO: result: yes" >&5
9612 > echo "${ECHO_T}yes" >&6
9613 >
9614 > cat >>confdefs.h <<\_ACEOF
9615 > #define HAVE__SYSTEM_CONFIGURATION 1
9616 > _ACEOF
9617 >
9618 > else
9619 >  echo "$as_me: failed program was:" >&5
9620 > sed 's/^/| /' conftest.$ac_ext >&5
9621 >
9622 > echo "$as_me:$LINENO: result: no" >&5
9623 > echo "${ECHO_T}no" >&6
9624 > fi
9625 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9626 >
9627 >  # clean out junk possibly left behind by a previous configuration
9628 >  rm -f src/getopt.h
9629 >  # Check for getopt_long support
9630 >
9631 > for ac_header in getopt.h
9632 > do
9633 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9634 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9635 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9636 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9637 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9639 > fi
9640 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9641 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9642 > else
9643 >  # Is the header compilable?
9644 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9645 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9646 > cat >conftest.$ac_ext <<_ACEOF
9647 > /* confdefs.h.  */
9648 > _ACEOF
9649 > cat confdefs.h >>conftest.$ac_ext
9650 > cat >>conftest.$ac_ext <<_ACEOF
9651 > /* end confdefs.h.  */
9652 > $ac_includes_default
9653 > #include <$ac_header>
9654 > _ACEOF
9655 > rm -f conftest.$ac_objext
9656 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9657 >  (eval $ac_compile) 2>conftest.er1
9658 >  ac_status=$?
9659 >  grep -v '^ *+' conftest.er1 >conftest.err
9660 >  rm -f conftest.er1
9661 >  cat conftest.err >&5
9662 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9663 >  (exit $ac_status); } &&
9664 >         { ac_try='test -z "$ac_c_werror_flag"
9665 >                         || test ! -s conftest.err'
9666 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9667 >  (eval $ac_try) 2>&5
9668 >  ac_status=$?
9669 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9670 >  (exit $ac_status); }; } &&
9671 >         { ac_try='test -s conftest.$ac_objext'
9672 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9673 >  (eval $ac_try) 2>&5
9674 >  ac_status=$?
9675 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9676 >  (exit $ac_status); }; }; then
9677 >  ac_header_compiler=yes
9678 > else
9679 >  echo "$as_me: failed program was:" >&5
9680 > sed 's/^/| /' conftest.$ac_ext >&5
9681 >
9682 > ac_header_compiler=no
9683 > fi
9684 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9685 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9686 > echo "${ECHO_T}$ac_header_compiler" >&6
9687 >
9688 > # Is the header present?
9689 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9690 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9691 > cat >conftest.$ac_ext <<_ACEOF
9692 > /* confdefs.h.  */
9693 > _ACEOF
9694 > cat confdefs.h >>conftest.$ac_ext
9695 > cat >>conftest.$ac_ext <<_ACEOF
9696 > /* end confdefs.h.  */
9697 > #include <$ac_header>
9698 > _ACEOF
9699 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9700 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9701 >  ac_status=$?
9702 >  grep -v '^ *+' conftest.er1 >conftest.err
9703 >  rm -f conftest.er1
9704 >  cat conftest.err >&5
9705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9706 >  (exit $ac_status); } >/dev/null; then
9707 >  if test -s conftest.err; then
9708 >    ac_cpp_err=$ac_c_preproc_warn_flag
9709 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9710 >  else
9711 >    ac_cpp_err=
9712 >  fi
9713 > else
9714 >  ac_cpp_err=yes
9715 > fi
9716 > if test -z "$ac_cpp_err"; then
9717 >  ac_header_preproc=yes
9718 > else
9719 >  echo "$as_me: failed program was:" >&5
9720 > sed 's/^/| /' conftest.$ac_ext >&5
9721 >
9722 >  ac_header_preproc=no
9723 > fi
9724 > rm -f conftest.err conftest.$ac_ext
9725 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9726 > echo "${ECHO_T}$ac_header_preproc" >&6
9727 >
9728 > # So?  What about this header?
9729 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9730 >  yes:no: )
9731 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9732 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9733 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9734 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9735 >    ac_header_preproc=yes
9736 >    ;;
9737 >  no:yes:* )
9738 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9739 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9740 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9741 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9742 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9743 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9744 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9745 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9746 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9747 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9748 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9749 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9750 >    (
9751 >      cat <<\_ASBOX
9752 > ## ------------------------------ ##
9753 > ## Report this to gezelter@nd.edu ##
9754 > ## ------------------------------ ##
9755 > _ASBOX
9756 >    ) |
9757 >      sed "s/^/$as_me: WARNING:     /" >&2
9758 >    ;;
9759 > esac
9760 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9761 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9762 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9763 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9764 > else
9765 >  eval "$as_ac_Header=\$ac_header_preproc"
9766 > fi
9767 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9768 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9769 >
9770 > fi
9771 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9772 >  cat >>confdefs.h <<_ACEOF
9773 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9774 > _ACEOF
9775 >
9776 > fi
9777 >
9778 > done
9779 >
9780 >
9781 > for ac_func in getopt_long
9782 > do
9783 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9784 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9785 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9786 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9787 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9788 > else
9789 >  cat >conftest.$ac_ext <<_ACEOF
9790 > /* confdefs.h.  */
9791 > _ACEOF
9792 > cat confdefs.h >>conftest.$ac_ext
9793 > cat >>conftest.$ac_ext <<_ACEOF
9794 > /* end confdefs.h.  */
9795 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9796 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9797 > #define $ac_func innocuous_$ac_func
9798 >
9799 > /* System header to define __stub macros and hopefully few prototypes,
9800 >    which can conflict with char $ac_func (); below.
9801 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9802 >    <limits.h> exists even on freestanding compilers.  */
9803 >
9804 > #ifdef __STDC__
9805 > # include <limits.h>
9806 > #else
9807 > # include <assert.h>
9808 > #endif
9809 >
9810 > #undef $ac_func
9811 >
9812 > /* Override any gcc2 internal prototype to avoid an error.  */
9813 > #ifdef __cplusplus
9814 > extern "C"
9815 > {
9816 > #endif
9817 > /* We use char because int might match the return type of a gcc2
9818 >   builtin and then its argument prototype would still apply.  */
9819 > char $ac_func ();
9820 > /* The GNU C library defines this for functions which it implements
9821 >    to always fail with ENOSYS.  Some functions are actually named
9822 >    something starting with __ and the normal name is an alias.  */
9823 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9824 > choke me
9825 > #else
9826 > char (*f) () = $ac_func;
9827 > #endif
9828 > #ifdef __cplusplus
9829 > }
9830 > #endif
9831 >
9832 > #ifdef FC_DUMMY_MAIN
9833 > #ifndef FC_DUMMY_MAIN_EQ_F77
9834 > #  ifdef __cplusplus
9835 >     extern "C"
9836 > #  endif
9837 >   int FC_DUMMY_MAIN() { return 1; }
9838 > #endif
9839 > #endif
9840 > int
9841 > main ()
9842 > {
9843 > return f != $ac_func;
9844 >  ;
9845 >  return 0;
9846 > }
9847 > _ACEOF
9848 > rm -f conftest.$ac_objext conftest$ac_exeext
9849 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9850 >  (eval $ac_link) 2>conftest.er1
9851 >  ac_status=$?
9852 >  grep -v '^ *+' conftest.er1 >conftest.err
9853 >  rm -f conftest.er1
9854 >  cat conftest.err >&5
9855 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9856 >  (exit $ac_status); } &&
9857 >         { ac_try='test -z "$ac_c_werror_flag"
9858 >                         || test ! -s conftest.err'
9859 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9860 >  (eval $ac_try) 2>&5
9861 >  ac_status=$?
9862 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9863 >  (exit $ac_status); }; } &&
9864 >         { ac_try='test -s conftest$ac_exeext'
9865 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9866 >  (eval $ac_try) 2>&5
9867 >  ac_status=$?
9868 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9869 >  (exit $ac_status); }; }; then
9870 >  eval "$as_ac_var=yes"
9871 > else
9872 >  echo "$as_me: failed program was:" >&5
9873 > sed 's/^/| /' conftest.$ac_ext >&5
9874 >
9875 > eval "$as_ac_var=no"
9876 > fi
9877 > rm -f conftest.err conftest.$ac_objext \
9878 >      conftest$ac_exeext conftest.$ac_ext
9879 > fi
9880 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9881 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9882 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9883 >  cat >>confdefs.h <<_ACEOF
9884 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9885 > _ACEOF
9886 >
9887 > else
9888 >  # FreeBSD has a gnugetopt library for this
9889 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9890 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9891 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9892 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9893 > else
9894 >  ac_check_lib_save_LIBS=$LIBS
9895 > LIBS="-lgnugetopt  $LIBS"
9896 > cat >conftest.$ac_ext <<_ACEOF
9897 > /* confdefs.h.  */
9898 > _ACEOF
9899 > cat confdefs.h >>conftest.$ac_ext
9900 > cat >>conftest.$ac_ext <<_ACEOF
9901 > /* end confdefs.h.  */
9902 >
9903 > /* Override any gcc2 internal prototype to avoid an error.  */
9904 > #ifdef __cplusplus
9905 > extern "C"
9906 > #endif
9907 > /* We use char because int might match the return type of a gcc2
9908 >   builtin and then its argument prototype would still apply.  */
9909 > char getopt_long ();
9910 > #ifdef FC_DUMMY_MAIN
9911 > #ifndef FC_DUMMY_MAIN_EQ_F77
9912 > #  ifdef __cplusplus
9913 >     extern "C"
9914 > #  endif
9915 >   int FC_DUMMY_MAIN() { return 1; }
9916 > #endif
9917 > #endif
9918 > int
9919 > main ()
9920 > {
9921 > getopt_long ();
9922 >  ;
9923 >  return 0;
9924 > }
9925 > _ACEOF
9926 > rm -f conftest.$ac_objext conftest$ac_exeext
9927 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9928 >  (eval $ac_link) 2>conftest.er1
9929 >  ac_status=$?
9930 >  grep -v '^ *+' conftest.er1 >conftest.err
9931 >  rm -f conftest.er1
9932 >  cat conftest.err >&5
9933 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9934 >  (exit $ac_status); } &&
9935 >         { ac_try='test -z "$ac_c_werror_flag"
9936 >                         || test ! -s conftest.err'
9937 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9938 >  (eval $ac_try) 2>&5
9939 >  ac_status=$?
9940 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9941 >  (exit $ac_status); }; } &&
9942 >         { ac_try='test -s conftest$ac_exeext'
9943 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9944 >  (eval $ac_try) 2>&5
9945 >  ac_status=$?
9946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9947 >  (exit $ac_status); }; }; then
9948 >  ac_cv_lib_gnugetopt_getopt_long=yes
9949 > else
9950 >  echo "$as_me: failed program was:" >&5
9951 > sed 's/^/| /' conftest.$ac_ext >&5
9952 >
9953 > ac_cv_lib_gnugetopt_getopt_long=no
9954 > fi
9955 > rm -f conftest.err conftest.$ac_objext \
9956 >      conftest$ac_exeext conftest.$ac_ext
9957 > LIBS=$ac_check_lib_save_LIBS
9958 > fi
9959 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9960 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9961 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9962 >  cat >>confdefs.h <<\_ACEOF
9963 > #define HAVE_GETOPT_LONG 1
9964 > _ACEOF
9965 >
9966 > else
9967 >  # use the GNU replacement
9968 >      case $LIBOBJS in
9969 >    "getopt.$ac_objext"   | \
9970 >  *" getopt.$ac_objext"   | \
9971 >    "getopt.$ac_objext "* | \
9972 >  *" getopt.$ac_objext "* ) ;;
9973 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9974 > esac
9975 >
9976 >      case $LIBOBJS in
9977 >    "getopt1.$ac_objext"   | \
9978 >  *" getopt1.$ac_objext"   | \
9979 >    "getopt1.$ac_objext "* | \
9980 >  *" getopt1.$ac_objext "* ) ;;
9981 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9982 > esac
9983 >
9984 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9985  
9986   fi
5561 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5562  cat >>confdefs.h <<_ACEOF
5563 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5564 _ACEOF
9987  
9988   fi
5567
9989   done
9990  
9991  
9992 + ac_ext=cc
9993 + ac_cpp='$CXXCPP $CPPFLAGS'
9994 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9995 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9996 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9997  
9998  
9999 <
10000 <
10001 < for ac_header in strstream.h iostream.h fstream.h math.h time.h
5576 < do
5577 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5578 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5579 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5580 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5581 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
9999 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10000 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10001 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10002    echo $ECHO_N "(cached) $ECHO_C" >&6
5583 fi
5584 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5585 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10003   else
10004 <  # Is the header compilable?
10005 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
10006 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10007 < cat >conftest.$ac_ext <<_ACEOF
10004 >
10005 >
10006 > ac_ext=cc
10007 > ac_cpp='$CXXCPP $CPPFLAGS'
10008 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10009 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10010 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10011 >
10012 > cat >conftest.$ac_ext <<_ACEOF
10013   /* confdefs.h.  */
10014   _ACEOF
10015   cat confdefs.h >>conftest.$ac_ext
10016   cat >>conftest.$ac_ext <<_ACEOF
10017   /* end confdefs.h.  */
10018 < $ac_includes_default
10019 < #include <$ac_header>
10018 > namespace Outer { namespace Inner { int i = 0; }}
10019 > #ifdef FC_DUMMY_MAIN
10020 > #ifndef FC_DUMMY_MAIN_EQ_F77
10021 > #  ifdef __cplusplus
10022 >     extern "C"
10023 > #  endif
10024 >   int FC_DUMMY_MAIN() { return 1; }
10025 > #endif
10026 > #endif
10027 > int
10028 > main ()
10029 > {
10030 > using namespace Outer::Inner; return i;
10031 >  ;
10032 >  return 0;
10033 > }
10034   _ACEOF
10035   rm -f conftest.$ac_objext
10036   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5605 | Line 10041 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10041    cat conftest.err >&5
10042    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10043    (exit $ac_status); } &&
10044 <         { ac_try='test -z "$ac_c_werror_flag"
10044 >         { ac_try='test -z "$ac_cxx_werror_flag"
10045                           || test ! -s conftest.err'
10046    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10047    (eval $ac_try) 2>&5
# Line 5618 | Line 10054 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10054    ac_status=$?
10055    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10056    (exit $ac_status); }; }; then
10057 <  ac_header_compiler=yes
10057 >  ac_cv_cxx_namespaces=yes
10058   else
10059    echo "$as_me: failed program was:" >&5
10060   sed 's/^/| /' conftest.$ac_ext >&5
10061  
10062 < ac_header_compiler=no
10062 > ac_cv_cxx_namespaces=no
10063   fi
10064   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10065 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10066 < echo "${ECHO_T}$ac_header_compiler" >&6
10065 > ac_ext=cc
10066 > ac_cpp='$CXXCPP $CPPFLAGS'
10067 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10068 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10069 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10070  
5632 # Is the header present?
5633 echo "$as_me:$LINENO: checking $ac_header presence" >&5
5634 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5635 cat >conftest.$ac_ext <<_ACEOF
5636 /* confdefs.h.  */
5637 _ACEOF
5638 cat confdefs.h >>conftest.$ac_ext
5639 cat >>conftest.$ac_ext <<_ACEOF
5640 /* end confdefs.h.  */
5641 #include <$ac_header>
5642 _ACEOF
5643 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5644  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5645  ac_status=$?
5646  grep -v '^ *+' conftest.er1 >conftest.err
5647  rm -f conftest.er1
5648  cat conftest.err >&5
5649  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5650  (exit $ac_status); } >/dev/null; then
5651  if test -s conftest.err; then
5652    ac_cpp_err=$ac_c_preproc_warn_flag
5653    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5654  else
5655    ac_cpp_err=
5656  fi
5657 else
5658  ac_cpp_err=yes
5659 fi
5660 if test -z "$ac_cpp_err"; then
5661  ac_header_preproc=yes
5662 else
5663  echo "$as_me: failed program was:" >&5
5664 sed 's/^/| /' conftest.$ac_ext >&5
10071  
5666  ac_header_preproc=no
10072   fi
10073 < rm -f conftest.err conftest.$ac_ext
10074 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10075 < echo "${ECHO_T}$ac_header_preproc" >&6
10073 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10074 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10075 > if test "$ac_cv_cxx_namespaces" = yes; then
10076  
10077 < # So?  What about this header?
10078 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5674 <  yes:no: )
5675 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5676 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5677 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5678 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5679 <    ac_header_preproc=yes
5680 <    ;;
5681 <  no:yes:* )
5682 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5683 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5684 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5685 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5686 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5687 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5688 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5689 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5690 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5691 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5692 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5693 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5694 <    (
5695 <      cat <<\_ASBOX
5696 < ## ------------------------------ ##
5697 < ## Report this to gezelter@nd.edu ##
5698 < ## ------------------------------ ##
5699 < _ASBOX
5700 <    ) |
5701 <      sed "s/^/$as_me: WARNING:     /" >&2
5702 <    ;;
5703 < esac
5704 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5705 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5706 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5707 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5708 < else
5709 <  eval "$as_ac_Header=\$ac_header_preproc"
5710 < fi
5711 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5712 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5713 <
5714 < fi
5715 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5716 <  cat >>confdefs.h <<_ACEOF
5717 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10077 > cat >>confdefs.h <<\_ACEOF
10078 > #define HAVE_NAMESPACES
10079   _ACEOF
10080  
10081   fi
10082  
5722 done
5723
10083   ac_ext=cc
10084   ac_cpp='$CXXCPP $CPPFLAGS'
10085   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10086   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10087   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5729
5730 ac_ext=cc
5731 ac_cpp='$CXXCPP $CPPFLAGS'
5732 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5733 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5734 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10088   echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10089   echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10090   if test -z "$CXXCPP"; then
# Line 5958 | Line 10311 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10311   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10312  
10313  
10314 + echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10315 + echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10316 + if test "${ac_cv_cxx_have_stl+set}" = set; then
10317 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10318 + else
10319  
10320  
10321  
10322 + ac_ext=cc
10323 + ac_cpp='$CXXCPP $CPPFLAGS'
10324 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10325 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10326 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10327 +
10328 + cat >conftest.$ac_ext <<_ACEOF
10329 + /* confdefs.h.  */
10330 + _ACEOF
10331 + cat confdefs.h >>conftest.$ac_ext
10332 + cat >>conftest.$ac_ext <<_ACEOF
10333 + /* end confdefs.h.  */
10334 + #include <list>
10335 + #include <deque>
10336 + #ifdef HAVE_NAMESPACES
10337 + using namespace std;
10338 + #endif
10339 + #ifdef FC_DUMMY_MAIN
10340 + #ifndef FC_DUMMY_MAIN_EQ_F77
10341 + #  ifdef __cplusplus
10342 +     extern "C"
10343 + #  endif
10344 +   int FC_DUMMY_MAIN() { return 1; }
10345 + #endif
10346 + #endif
10347 + int
10348 + main ()
10349 + {
10350 + list<int> x; x.push_back(5);
10351 + list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10352 +  ;
10353 +  return 0;
10354 + }
10355 + _ACEOF
10356 + rm -f conftest.$ac_objext
10357 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10358 +  (eval $ac_compile) 2>conftest.er1
10359 +  ac_status=$?
10360 +  grep -v '^ *+' conftest.er1 >conftest.err
10361 +  rm -f conftest.er1
10362 +  cat conftest.err >&5
10363 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10364 +  (exit $ac_status); } &&
10365 +         { ac_try='test -z "$ac_cxx_werror_flag"
10366 +                         || test ! -s conftest.err'
10367 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10368 +  (eval $ac_try) 2>&5
10369 +  ac_status=$?
10370 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10371 +  (exit $ac_status); }; } &&
10372 +         { ac_try='test -s conftest.$ac_objext'
10373 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10374 +  (eval $ac_try) 2>&5
10375 +  ac_status=$?
10376 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377 +  (exit $ac_status); }; }; then
10378 +  ac_cv_cxx_have_stl=yes
10379 + else
10380 +  echo "$as_me: failed program was:" >&5
10381 + sed 's/^/| /' conftest.$ac_ext >&5
10382  
10383 + ac_cv_cxx_have_stl=no
10384 + fi
10385 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10386 + ac_ext=cc
10387 + ac_cpp='$CXXCPP $CPPFLAGS'
10388 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10389 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10390 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10391  
10392 < for ac_header in ctype.h iostream fstream sstream strstream
10393 < do
10394 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10395 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10396 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
10397 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10398 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10392 >
10393 > fi
10394 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10395 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10396 > if test "$ac_cv_cxx_have_stl" = yes; then
10397 >
10398 > cat >>confdefs.h <<\_ACEOF
10399 > #define HAVE_STL
10400 > _ACEOF
10401 >
10402 > fi
10403 >
10404 >
10405 >
10406 >  if test "${ac_cv_header_iostream+set}" = set; then
10407 >  echo "$as_me:$LINENO: checking for iostream" >&5
10408 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10409 > if test "${ac_cv_header_iostream+set}" = set; then
10410    echo $ECHO_N "(cached) $ECHO_C" >&6
10411   fi
10412 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10413 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10412 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10413 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10414   else
10415    # Is the header compilable?
10416 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
10417 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10416 > echo "$as_me:$LINENO: checking iostream usability" >&5
10417 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10418   cat >conftest.$ac_ext <<_ACEOF
10419   /* confdefs.h.  */
10420   _ACEOF
# Line 5985 | Line 10422 | $ac_includes_default
10422   cat >>conftest.$ac_ext <<_ACEOF
10423   /* end confdefs.h.  */
10424   $ac_includes_default
10425 < #include <$ac_header>
10425 > #include <iostream>
10426   _ACEOF
10427   rm -f conftest.$ac_objext
10428   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6021 | Line 10458 | echo "${ECHO_T}$ac_header_compiler" >&6
10458   echo "${ECHO_T}$ac_header_compiler" >&6
10459  
10460   # Is the header present?
10461 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
10462 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10461 > echo "$as_me:$LINENO: checking iostream presence" >&5
10462 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10463   cat >conftest.$ac_ext <<_ACEOF
10464   /* confdefs.h.  */
10465   _ACEOF
10466   cat confdefs.h >>conftest.$ac_ext
10467   cat >>conftest.$ac_ext <<_ACEOF
10468   /* end confdefs.h.  */
10469 < #include <$ac_header>
10469 > #include <iostream>
10470   _ACEOF
10471   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10472    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6063 | Line 10500 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
10500   # So?  What about this header?
10501   case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10502    yes:no: )
10503 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10504 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10505 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10506 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10503 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10504 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10505 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10506 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10507      ac_header_preproc=yes
10508      ;;
10509    no:yes:* )
10510 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10511 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10512 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10513 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10514 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10515 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10516 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10517 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10518 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10519 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10520 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10521 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10510 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10511 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10512 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10513 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10514 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10515 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10516 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10517 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10518 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10519 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10520 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10521 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10522      (
10523        cat <<\_ASBOX
10524   ## ------------------------------ ##
# Line 6092 | Line 10529 | esac
10529        sed "s/^/$as_me: WARNING:     /" >&2
10530      ;;
10531   esac
10532 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10533 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10534 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10532 > echo "$as_me:$LINENO: checking for iostream" >&5
10533 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10534 > if test "${ac_cv_header_iostream+set}" = set; then
10535    echo $ECHO_N "(cached) $ECHO_C" >&6
10536   else
10537 <  eval "$as_ac_Header=\$ac_header_preproc"
10537 >  ac_cv_header_iostream=$ac_header_preproc
10538   fi
10539 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10540 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10539 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10540 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10541  
10542   fi
10543 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6107 <  cat >>confdefs.h <<_ACEOF
6108 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6109 < _ACEOF
10543 > if test $ac_cv_header_iostream = yes; then
10544  
6111 fi
10545  
10546 < done
10546 > cat >>confdefs.h <<\_ACEOF
10547 > #define HAVE_IOSTREAM 1
10548 > _ACEOF
10549  
6115 ac_ext=c
6116 ac_cpp='$CPP $CPPFLAGS'
6117 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6118 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6119 ac_compiler_gnu=$ac_cv_c_compiler_gnu
10550  
10551 + else
10552  
10553  
10554 <
6124 < for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
10554 > for ac_header in iostream.h
10555   do
10556   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10557   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6154 | Line 10584 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10584    cat conftest.err >&5
10585    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10586    (exit $ac_status); } &&
10587 <         { ac_try='test -z "$ac_c_werror_flag"
10587 >         { ac_try='test -z "$ac_cxx_werror_flag"
10588                           || test ! -s conftest.err'
10589    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10590    (eval $ac_try) 2>&5
# Line 6198 | Line 10628 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10628    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10629    (exit $ac_status); } >/dev/null; then
10630    if test -s conftest.err; then
10631 <    ac_cpp_err=$ac_c_preproc_warn_flag
10632 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10631 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10632 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10633    else
10634      ac_cpp_err=
10635    fi
# Line 6219 | Line 10649 | echo "${ECHO_T}$ac_header_preproc" >&6
10649   echo "${ECHO_T}$ac_header_preproc" >&6
10650  
10651   # So?  What about this header?
10652 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10652 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10653    yes:no: )
10654      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10655   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6271 | Line 10701 | done
10701   done
10702  
10703  
10704 + fi
10705  
10706  
10707  
10708 < for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
10708 >
10709 >  if test "${ac_cv_header_iomanip+set}" = set; then
10710 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10711 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10712 > if test "${ac_cv_header_iomanip+set}" = set; then
10713 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10714 > fi
10715 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10716 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10717 > else
10718 >  # Is the header compilable?
10719 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10720 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10721 > cat >conftest.$ac_ext <<_ACEOF
10722 > /* confdefs.h.  */
10723 > _ACEOF
10724 > cat confdefs.h >>conftest.$ac_ext
10725 > cat >>conftest.$ac_ext <<_ACEOF
10726 > /* end confdefs.h.  */
10727 > $ac_includes_default
10728 > #include <iomanip>
10729 > _ACEOF
10730 > rm -f conftest.$ac_objext
10731 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10732 >  (eval $ac_compile) 2>conftest.er1
10733 >  ac_status=$?
10734 >  grep -v '^ *+' conftest.er1 >conftest.err
10735 >  rm -f conftest.er1
10736 >  cat conftest.err >&5
10737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10738 >  (exit $ac_status); } &&
10739 >         { ac_try='test -z "$ac_cxx_werror_flag"
10740 >                         || test ! -s conftest.err'
10741 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10742 >  (eval $ac_try) 2>&5
10743 >  ac_status=$?
10744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10745 >  (exit $ac_status); }; } &&
10746 >         { ac_try='test -s conftest.$ac_objext'
10747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10748 >  (eval $ac_try) 2>&5
10749 >  ac_status=$?
10750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10751 >  (exit $ac_status); }; }; then
10752 >  ac_header_compiler=yes
10753 > else
10754 >  echo "$as_me: failed program was:" >&5
10755 > sed 's/^/| /' conftest.$ac_ext >&5
10756 >
10757 > ac_header_compiler=no
10758 > fi
10759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10760 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10761 > echo "${ECHO_T}$ac_header_compiler" >&6
10762 >
10763 > # Is the header present?
10764 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10765 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10766 > cat >conftest.$ac_ext <<_ACEOF
10767 > /* confdefs.h.  */
10768 > _ACEOF
10769 > cat confdefs.h >>conftest.$ac_ext
10770 > cat >>conftest.$ac_ext <<_ACEOF
10771 > /* end confdefs.h.  */
10772 > #include <iomanip>
10773 > _ACEOF
10774 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10775 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10776 >  ac_status=$?
10777 >  grep -v '^ *+' conftest.er1 >conftest.err
10778 >  rm -f conftest.er1
10779 >  cat conftest.err >&5
10780 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10781 >  (exit $ac_status); } >/dev/null; then
10782 >  if test -s conftest.err; then
10783 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10784 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10785 >  else
10786 >    ac_cpp_err=
10787 >  fi
10788 > else
10789 >  ac_cpp_err=yes
10790 > fi
10791 > if test -z "$ac_cpp_err"; then
10792 >  ac_header_preproc=yes
10793 > else
10794 >  echo "$as_me: failed program was:" >&5
10795 > sed 's/^/| /' conftest.$ac_ext >&5
10796 >
10797 >  ac_header_preproc=no
10798 > fi
10799 > rm -f conftest.err conftest.$ac_ext
10800 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10801 > echo "${ECHO_T}$ac_header_preproc" >&6
10802 >
10803 > # So?  What about this header?
10804 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10805 >  yes:no: )
10806 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10807 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10808 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10809 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10810 >    ac_header_preproc=yes
10811 >    ;;
10812 >  no:yes:* )
10813 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10814 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10815 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10816 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10817 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10818 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10819 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10820 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10821 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10822 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10823 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10824 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10825 >    (
10826 >      cat <<\_ASBOX
10827 > ## ------------------------------ ##
10828 > ## Report this to gezelter@nd.edu ##
10829 > ## ------------------------------ ##
10830 > _ASBOX
10831 >    ) |
10832 >      sed "s/^/$as_me: WARNING:     /" >&2
10833 >    ;;
10834 > esac
10835 > echo "$as_me:$LINENO: checking for iomanip" >&5
10836 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10837 > if test "${ac_cv_header_iomanip+set}" = set; then
10838 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10839 > else
10840 >  ac_cv_header_iomanip=$ac_header_preproc
10841 > fi
10842 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10843 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10844 >
10845 > fi
10846 > if test $ac_cv_header_iomanip = yes; then
10847 >
10848 >
10849 > cat >>confdefs.h <<\_ACEOF
10850 > #define HAVE_IOMANIP 1
10851 > _ACEOF
10852 >
10853 >
10854 > else
10855 >
10856 >
10857 > for ac_header in iomanip.h
10858   do
10859   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10860   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6307 | Line 10887 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10887    cat conftest.err >&5
10888    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10889    (exit $ac_status); } &&
10890 <         { ac_try='test -z "$ac_c_werror_flag"
10890 >         { ac_try='test -z "$ac_cxx_werror_flag"
10891                           || test ! -s conftest.err'
10892    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10893    (eval $ac_try) 2>&5
# Line 6351 | Line 10931 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10931    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10932    (exit $ac_status); } >/dev/null; then
10933    if test -s conftest.err; then
10934 <    ac_cpp_err=$ac_c_preproc_warn_flag
10935 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10934 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10935 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10936    else
10937      ac_cpp_err=
10938    fi
# Line 6372 | Line 10952 | echo "${ECHO_T}$ac_header_preproc" >&6
10952   echo "${ECHO_T}$ac_header_preproc" >&6
10953  
10954   # So?  What about this header?
10955 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10955 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10956    yes:no: )
10957      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10958   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6424 | Line 11004 | done
11004   done
11005  
11006  
11007 < for ac_header in machine/hal_sysinfo.h
11007 > fi
11008 >
11009 >
11010 >
11011 >
11012 > for ac_header in cmath
11013   do
11014   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11015   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6457 | Line 11042 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11042    cat conftest.err >&5
11043    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11044    (exit $ac_status); } &&
11045 <         { ac_try='test -z "$ac_c_werror_flag"
11045 >         { ac_try='test -z "$ac_cxx_werror_flag"
11046                           || test ! -s conftest.err'
11047    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11048    (eval $ac_try) 2>&5
# Line 6501 | Line 11086 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11086    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11087    (exit $ac_status); } >/dev/null; then
11088    if test -s conftest.err; then
11089 <    ac_cpp_err=$ac_c_preproc_warn_flag
11090 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11089 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11090 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11091    else
11092      ac_cpp_err=
11093    fi
# Line 6522 | Line 11107 | echo "${ECHO_T}$ac_header_preproc" >&6
11107   echo "${ECHO_T}$ac_header_preproc" >&6
11108  
11109   # So?  What about this header?
11110 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11110 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11111    yes:no: )
11112      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11113   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6576 | Line 11161 | done
11161  
11162  
11163  
11164 <
11165 < for ac_func in rint snprintf sranddev strncasecmp
11166 < do
6582 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6583 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6584 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6585 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11164 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11165 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11166 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11167    echo $ECHO_N "(cached) $ECHO_C" >&6
11168   else
6588  cat >conftest.$ac_ext <<_ACEOF
6589 /* confdefs.h.  */
6590 _ACEOF
6591 cat confdefs.h >>conftest.$ac_ext
6592 cat >>conftest.$ac_ext <<_ACEOF
6593 /* end confdefs.h.  */
6594 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6595   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6596 #define $ac_func innocuous_$ac_func
11169  
11170 < /* System header to define __stub macros and hopefully few prototypes,
11171 <    which can conflict with char $ac_func (); below.
11172 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6601 <    <limits.h> exists even on freestanding compilers.  */
6602 <
6603 < #ifdef __STDC__
6604 < # include <limits.h>
6605 < #else
6606 < # include <assert.h>
6607 < #endif
6608 <
6609 < #undef $ac_func
6610 <
6611 < /* Override any gcc2 internal prototype to avoid an error.  */
6612 < #ifdef __cplusplus
6613 < extern "C"
6614 < {
6615 < #endif
6616 < /* We use char because int might match the return type of a gcc2
6617 <   builtin and then its argument prototype would still apply.  */
6618 < char $ac_func ();
6619 < /* The GNU C library defines this for functions which it implements
6620 <    to always fail with ENOSYS.  Some functions are actually named
6621 <    something starting with __ and the normal name is an alias.  */
6622 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6623 < choke me
6624 < #else
6625 < char (*f) () = $ac_func;
6626 < #endif
6627 < #ifdef __cplusplus
6628 < }
6629 < #endif
6630 <
6631 < int
6632 < main ()
6633 < {
6634 < return f != $ac_func;
6635 <  ;
6636 <  return 0;
6637 < }
6638 < _ACEOF
6639 < rm -f conftest.$ac_objext conftest$ac_exeext
6640 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6641 <  (eval $ac_link) 2>conftest.er1
6642 <  ac_status=$?
6643 <  grep -v '^ *+' conftest.er1 >conftest.err
6644 <  rm -f conftest.er1
6645 <  cat conftest.err >&5
6646 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647 <  (exit $ac_status); } &&
6648 <         { ac_try='test -z "$ac_c_werror_flag"
6649 <                         || test ! -s conftest.err'
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); }; } &&
6655 <         { ac_try='test -s conftest$ac_exeext'
6656 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6657 <  (eval $ac_try) 2>&5
6658 <  ac_status=$?
6659 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6660 <  (exit $ac_status); }; }; then
6661 <  eval "$as_ac_var=yes"
6662 < else
6663 <  echo "$as_me: failed program was:" >&5
6664 < sed 's/^/| /' conftest.$ac_ext >&5
6665 <
6666 < eval "$as_ac_var=no"
6667 < fi
6668 < rm -f conftest.err conftest.$ac_objext \
6669 <      conftest$ac_exeext conftest.$ac_ext
6670 < fi
6671 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6672 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6673 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6674 <  cat >>confdefs.h <<_ACEOF
6675 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6676 < _ACEOF
11170 >      ac_cv_cxx_have_std_iostream=no
11171 >      ac_cv_cxx_need_use_std_iostream=no
11172 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11173  
6678 fi
6679 done
11174  
11175 +        ac_ext=cc
11176 + ac_cpp='$CXXCPP $CPPFLAGS'
11177 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11178 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11179 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11180  
11181 <
6683 <
6684 <
6685 <
6686 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6687 < do
6688 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6689 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6690 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6691 < if eval "test \"\${$as_ac_var+set}\" = set"; then
6692 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6693 < else
6694 <  cat >conftest.$ac_ext <<_ACEOF
11181 >        cat >conftest.$ac_ext <<_ACEOF
11182   /* confdefs.h.  */
11183   _ACEOF
11184   cat confdefs.h >>conftest.$ac_ext
11185   cat >>conftest.$ac_ext <<_ACEOF
11186   /* end confdefs.h.  */
6700 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6701   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6702 #define $ac_func innocuous_$ac_func
11187  
11188 < /* System header to define __stub macros and hopefully few prototypes,
11189 <    which can conflict with char $ac_func (); below.
6706 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6707 <    <limits.h> exists even on freestanding compilers.  */
6708 <
6709 < #ifdef __STDC__
6710 < # include <limits.h>
11188 > #ifdef HAVE_IOSTREAM
11189 > #include <iostream>
11190   #else
11191 < # include <assert.h>
11191 > #include <iostream.h>
11192   #endif
11193  
11194 < #undef $ac_func
11195 <
11196 < /* Override any gcc2 internal prototype to avoid an error.  */
11197 < #ifdef __cplusplus
11198 < extern "C"
11199 < {
11194 > #ifdef FC_DUMMY_MAIN
11195 > #ifndef FC_DUMMY_MAIN_EQ_F77
11196 > #  ifdef __cplusplus
11197 >     extern "C"
11198 > #  endif
11199 >   int FC_DUMMY_MAIN() { return 1; }
11200   #endif
6722 /* We use char because int might match the return type of a gcc2
6723   builtin and then its argument prototype would still apply.  */
6724 char $ac_func ();
6725 /* The GNU C library defines this for functions which it implements
6726    to always fail with ENOSYS.  Some functions are actually named
6727    something starting with __ and the normal name is an alias.  */
6728 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6729 choke me
6730 #else
6731 char (*f) () = $ac_func;
11201   #endif
6733 #ifdef __cplusplus
6734 }
6735 #endif
6736
11202   int
11203   main ()
11204   {
11205 < return f != $ac_func;
6741 <  ;
6742 <  return 0;
6743 < }
6744 < _ACEOF
6745 < rm -f conftest.$ac_objext conftest$ac_exeext
6746 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6747 <  (eval $ac_link) 2>conftest.er1
6748 <  ac_status=$?
6749 <  grep -v '^ *+' conftest.er1 >conftest.err
6750 <  rm -f conftest.er1
6751 <  cat conftest.err >&5
6752 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6753 <  (exit $ac_status); } &&
6754 <         { ac_try='test -z "$ac_c_werror_flag"
6755 <                         || test ! -s conftest.err'
6756 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6757 <  (eval $ac_try) 2>&5
6758 <  ac_status=$?
6759 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6760 <  (exit $ac_status); }; } &&
6761 <         { ac_try='test -s conftest$ac_exeext'
6762 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6763 <  (eval $ac_try) 2>&5
6764 <  ac_status=$?
6765 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6766 <  (exit $ac_status); }; }; then
6767 <  eval "$as_ac_var=yes"
6768 < else
6769 <  echo "$as_me: failed program was:" >&5
6770 < sed 's/^/| /' conftest.$ac_ext >&5
6771 <
6772 < eval "$as_ac_var=no"
6773 < fi
6774 < rm -f conftest.err conftest.$ac_objext \
6775 <      conftest$ac_exeext conftest.$ac_ext
6776 < fi
6777 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6778 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6779 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6780 <  cat >>confdefs.h <<_ACEOF
6781 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6782 < _ACEOF
6783 <
6784 < fi
6785 < done
6786 <
6787 < # special check for _system_configuration because AIX <4.3.2 do not
6788 < # contain the `physmem' member.
6789 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6790 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6791 < cat >conftest.$ac_ext <<_ACEOF
6792 < /* confdefs.h.  */
6793 < _ACEOF
6794 < cat confdefs.h >>conftest.$ac_ext
6795 < cat >>conftest.$ac_ext <<_ACEOF
6796 < /* end confdefs.h.  */
6797 < #include <sys/systemcfg.h>
6798 < int
6799 < main ()
6800 < {
6801 < double x = _system_configuration.physmem;
11205 > std::cout<<"Hello World"<<std::endl;return 0;
11206    ;
11207    return 0;
11208   }
# Line 6812 | Line 11216 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11216    cat conftest.err >&5
11217    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11218    (exit $ac_status); } &&
11219 <         { ac_try='test -z "$ac_c_werror_flag"
11219 >         { ac_try='test -z "$ac_cxx_werror_flag"
11220                           || test ! -s conftest.err'
11221    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11222    (eval $ac_try) 2>&5
# Line 6825 | Line 11229 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11229    ac_status=$?
11230    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11231    (exit $ac_status); }; }; then
11232 <  echo "$as_me:$LINENO: result: yes" >&5
6829 < echo "${ECHO_T}yes" >&6
6830 <
6831 < cat >>confdefs.h <<\_ACEOF
6832 < #define HAVE__SYSTEM_CONFIGURATION 1
6833 < _ACEOF
6834 <
11232 >  ac_cv_cxx_have_std_iostream=yes
11233   else
11234    echo "$as_me: failed program was:" >&5
11235   sed 's/^/| /' conftest.$ac_ext >&5
11236  
6839 echo "$as_me:$LINENO: result: no" >&5
6840 echo "${ECHO_T}no" >&6
11237   fi
11238   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11239 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6844 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6845 < if test "${ac_cv_header_time+set}" = set; then
6846 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6847 < else
6848 <  cat >conftest.$ac_ext <<_ACEOF
11239 >        cat >conftest.$ac_ext <<_ACEOF
11240   /* confdefs.h.  */
11241   _ACEOF
11242   cat confdefs.h >>conftest.$ac_ext
11243   cat >>conftest.$ac_ext <<_ACEOF
11244   /* end confdefs.h.  */
6854 #include <sys/types.h>
6855 #include <sys/time.h>
6856 #include <time.h>
11245  
11246 + #define __USE_STD_IOSTREAM 1
11247 + #ifdef HAVE_IOSTREAM
11248 + #include <iostream>
11249 + #else
11250 + #include <iostream.h>
11251 + #endif
11252 +
11253 + #ifdef FC_DUMMY_MAIN
11254 + #ifndef FC_DUMMY_MAIN_EQ_F77
11255 + #  ifdef __cplusplus
11256 +     extern "C"
11257 + #  endif
11258 +   int FC_DUMMY_MAIN() { return 1; }
11259 + #endif
11260 + #endif
11261   int
11262   main ()
11263   {
11264 < if ((struct tm *) 0)
6862 < return 0;
11264 > std::cout<<"Hello World"<<std::endl;return 0;
11265    ;
11266    return 0;
11267   }
# Line 6873 | Line 11275 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11275    cat conftest.err >&5
11276    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11277    (exit $ac_status); } &&
11278 <         { ac_try='test -z "$ac_c_werror_flag"
11278 >         { ac_try='test -z "$ac_cxx_werror_flag"
11279                           || test ! -s conftest.err'
11280    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11281    (eval $ac_try) 2>&5
# Line 6886 | Line 11288 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11288    ac_status=$?
11289    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11290    (exit $ac_status); }; }; then
11291 <  ac_cv_header_time=yes
11291 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11292   else
11293    echo "$as_me: failed program was:" >&5
11294   sed 's/^/| /' conftest.$ac_ext >&5
11295  
6894 ac_cv_header_time=no
11296   fi
11297   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11298 +        ac_ext=cc
11299 + ac_cpp='$CXXCPP $CPPFLAGS'
11300 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11301 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11302 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11303 +
11304 +      fi
11305 +
11306   fi
11307 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11308 < echo "${ECHO_T}$ac_cv_header_time" >&6
11309 < if test $ac_cv_header_time = yes; then
11307 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11308 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11309 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11310  
11311   cat >>confdefs.h <<\_ACEOF
11312 < #define TIME_WITH_SYS_TIME 1
11312 > #define HAVE_STD_IOSTREAM 1
11313   _ACEOF
11314  
11315 < fi
11315 >  fi
11316 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11317  
11318 + cat >>confdefs.h <<\_ACEOF
11319 + #define __USE_STD_IOSTREAM 1
11320 + _ACEOF
11321  
11322 < echo "$as_me:$LINENO: checking for clock_t" >&5
11323 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11324 < if test "${ac_cv_type_clock_t+set}" = set; then
11322 >  fi
11323 >
11324 >
11325 >
11326 >
11327 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11328 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11329 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11330    echo $ECHO_N "(cached) $ECHO_C" >&6
11331   else
11332 <  cat >conftest.$ac_ext <<_ACEOF
11332 >
11333 >      ac_cv_cxx_have_std_stl=no
11334 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11335 >
11336 >
11337 >        ac_ext=cc
11338 > ac_cpp='$CXXCPP $CPPFLAGS'
11339 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11340 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11341 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11342 >
11343 >        cat >conftest.$ac_ext <<_ACEOF
11344   /* confdefs.h.  */
11345   _ACEOF
11346   cat confdefs.h >>conftest.$ac_ext
11347   cat >>conftest.$ac_ext <<_ACEOF
11348   /* end confdefs.h.  */
11349 < $ac_includes_default
11349 > #include <list>
11350 >
11351 > #ifdef FC_DUMMY_MAIN
11352 > #ifndef FC_DUMMY_MAIN_EQ_F77
11353 > #  ifdef __cplusplus
11354 >     extern "C"
11355 > #  endif
11356 >   int FC_DUMMY_MAIN() { return 1; }
11357 > #endif
11358 > #endif
11359   int
11360   main ()
11361   {
11362 < if ((clock_t *) 0)
6925 <  return 0;
6926 < if (sizeof (clock_t))
6927 <  return 0;
11362 > std::list<int> foo;return 0;
11363    ;
11364    return 0;
11365   }
# Line 6938 | Line 11373 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11373    cat conftest.err >&5
11374    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11375    (exit $ac_status); } &&
11376 <         { ac_try='test -z "$ac_c_werror_flag"
11376 >         { ac_try='test -z "$ac_cxx_werror_flag"
11377                           || test ! -s conftest.err'
11378    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11379    (eval $ac_try) 2>&5
# Line 6951 | Line 11386 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11386    ac_status=$?
11387    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11388    (exit $ac_status); }; }; then
11389 <  ac_cv_type_clock_t=yes
11389 >  ac_cv_cxx_have_std_stl=yes
11390   else
11391    echo "$as_me: failed program was:" >&5
11392   sed 's/^/| /' conftest.$ac_ext >&5
11393  
6959 ac_cv_type_clock_t=no
11394   fi
11395   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11396 +        ac_ext=cc
11397 + ac_cpp='$CXXCPP $CPPFLAGS'
11398 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11399 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11400 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11401 +
11402 +      fi
11403 +
11404   fi
11405 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11406 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11407 < if test $ac_cv_type_clock_t = yes; then
11405 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11406 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11407 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11408  
11409 < cat >>confdefs.h <<_ACEOF
11410 < #define HAVE_CLOCK_T 1
11409 > cat >>confdefs.h <<\_ACEOF
11410 > #define HAVE_STD_STL 1
11411   _ACEOF
11412  
11413 +  fi
11414  
6972 fi
11415  
11416 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11417 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11418 < if test "${ac_cv_c_const+set}" = set; then
11416 >
11417 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11418 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11419 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11420    echo $ECHO_N "(cached) $ECHO_C" >&6
11421   else
11422 <  cat >conftest.$ac_ext <<_ACEOF
11422 >
11423 >    ac_cv_cxx_have_fstream_attach=no
11424 >
11425 >
11426 >    ac_ext=cc
11427 > ac_cpp='$CXXCPP $CPPFLAGS'
11428 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431 >
11432 >    cat >conftest.$ac_ext <<_ACEOF
11433   /* confdefs.h.  */
11434   _ACEOF
11435   cat confdefs.h >>conftest.$ac_ext
11436   cat >>conftest.$ac_ext <<_ACEOF
11437   /* end confdefs.h.  */
11438  
11439 + #ifdef HAVE_IOSTREAM
11440 + #include <fstream>
11441 + #else
11442 + #include <fstream.h>
11443 + #endif
11444 + #ifdef HAVE_STD_IOSTREAM
11445 + using namespace std;
11446 + #endif
11447 +
11448 + #ifdef FC_DUMMY_MAIN
11449 + #ifndef FC_DUMMY_MAIN_EQ_F77
11450 + #  ifdef __cplusplus
11451 +     extern "C"
11452 + #  endif
11453 +   int FC_DUMMY_MAIN() { return 1; }
11454 + #endif
11455 + #endif
11456   int
11457   main ()
11458   {
11459 < /* FIXME: Include the comments suggested by Paul. */
6990 < #ifndef __cplusplus
6991 <  /* Ultrix mips cc rejects this.  */
6992 <  typedef int charset[2];
6993 <  const charset x;
6994 <  /* SunOS 4.1.1 cc rejects this.  */
6995 <  char const *const *ccp;
6996 <  char **p;
6997 <  /* NEC SVR4.0.2 mips cc rejects this.  */
6998 <  struct point {int x, y;};
6999 <  static struct point const zero = {0,0};
7000 <  /* AIX XL C 1.02.0.0 rejects this.
7001 <     It does not let you subtract one const X* pointer from another in
7002 <     an arm of an if-expression whose if-part is not a constant
7003 <     expression */
7004 <  const char *g = "string";
7005 <  ccp = &g + (g ? g-g : 0);
7006 <  /* HPUX 7.0 cc rejects these. */
7007 <  ++ccp;
7008 <  p = (char**) ccp;
7009 <  ccp = (char const *const *) p;
7010 <  { /* SCO 3.2v4 cc rejects this.  */
7011 <    char *t;
7012 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
7013 <
7014 <    *t++ = 0;
7015 <  }
7016 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7017 <    int x[] = {25, 17};
7018 <    const int *foo = &x[0];
7019 <    ++foo;
7020 <  }
7021 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7022 <    typedef const int *iptr;
7023 <    iptr p = 0;
7024 <    ++p;
7025 <  }
7026 <  { /* AIX XL C 1.02.0.0 rejects this saying
7027 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7028 <    struct s { int j; const int *ap[3]; };
7029 <    struct s *b; b->j = 5;
7030 <  }
7031 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7032 <    const int foo = 10;
7033 <  }
7034 < #endif
7035 <
11459 > int fd=0;ofstream s;s.attach(fd);
11460    ;
11461    return 0;
11462   }
# Line 7046 | Line 11470 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11470    cat conftest.err >&5
11471    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11472    (exit $ac_status); } &&
11473 <         { ac_try='test -z "$ac_c_werror_flag"
11473 >         { ac_try='test -z "$ac_cxx_werror_flag"
11474                           || test ! -s conftest.err'
11475    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11476    (eval $ac_try) 2>&5
# Line 7059 | Line 11483 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11483    ac_status=$?
11484    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11485    (exit $ac_status); }; }; then
11486 <  ac_cv_c_const=yes
11486 >  ac_cv_cxx_have_fstream_attach=yes
11487   else
11488    echo "$as_me: failed program was:" >&5
11489   sed 's/^/| /' conftest.$ac_ext >&5
11490  
7067 ac_cv_c_const=no
11491   fi
11492   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11493 +    ac_ext=cc
11494 + ac_cpp='$CXXCPP $CPPFLAGS'
11495 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11496 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11497 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11498 +
11499 +
11500   fi
11501 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
11502 < echo "${ECHO_T}$ac_cv_c_const" >&6
11503 < if test $ac_cv_c_const = no; then
11501 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11502 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11503 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11504  
11505   cat >>confdefs.h <<\_ACEOF
11506 < #define const
11506 > #define HAVE_FSTREAM_ATTACH 1
11507   _ACEOF
11508  
11509 < fi
11509 >  fi
11510  
11511 < echo "$as_me:$LINENO: checking for inline" >&5
11512 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
11513 < if test "${ac_cv_c_inline+set}" = set; then
11511 >
11512 >
11513 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11514 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11515 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11516    echo $ECHO_N "(cached) $ECHO_C" >&6
11517   else
11518 <  ac_cv_c_inline=no
11519 < for ac_kw in inline __inline__ __inline; do
11520 <  cat >conftest.$ac_ext <<_ACEOF
11518 >
11519 >    ac_cv_cxx_have_fstream_open=no
11520 >    ac_cv_cxx_fstream_open_prot=no
11521 >
11522 >
11523 >    ac_ext=cc
11524 > ac_cpp='$CXXCPP $CPPFLAGS'
11525 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11526 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11527 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11528 >
11529 >    # Try with 2 parameters
11530 >    cat >conftest.$ac_ext <<_ACEOF
11531   /* confdefs.h.  */
11532   _ACEOF
11533   cat confdefs.h >>conftest.$ac_ext
11534   cat >>conftest.$ac_ext <<_ACEOF
11535   /* end confdefs.h.  */
11536 < #ifndef __cplusplus
11537 < typedef int foo_t;
11538 < static $ac_kw foo_t static_foo () {return 0; }
11539 < $ac_kw foo_t foo () {return 0; }
11536 >
11537 > #ifdef HAVE_IOSTREAM
11538 > #include <fstream>
11539 > #else
11540 > #include <fstream.h>
11541   #endif
11542 + #ifdef HAVE_STD_IOSTREAM
11543 + using namespace std;
11544 + #endif
11545  
11546 + #ifdef FC_DUMMY_MAIN
11547 + #ifndef FC_DUMMY_MAIN_EQ_F77
11548 + #  ifdef __cplusplus
11549 +     extern "C"
11550 + #  endif
11551 +   int FC_DUMMY_MAIN() { return 1; }
11552 + #endif
11553 + #endif
11554 + int
11555 + main ()
11556 + {
11557 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11558 +  ;
11559 +  return 0;
11560 + }
11561   _ACEOF
11562   rm -f conftest.$ac_objext
11563   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7107 | Line 11568 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11568    cat conftest.err >&5
11569    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11570    (exit $ac_status); } &&
11571 <         { ac_try='test -z "$ac_c_werror_flag"
11571 >         { ac_try='test -z "$ac_cxx_werror_flag"
11572                           || test ! -s conftest.err'
11573    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11574    (eval $ac_try) 2>&5
# Line 7120 | Line 11581 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11581    ac_status=$?
11582    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11583    (exit $ac_status); }; }; then
11584 <  ac_cv_c_inline=$ac_kw; break
11584 >  ac_cv_cxx_have_fstream_open=yes
11585   else
11586    echo "$as_me: failed program was:" >&5
11587   sed 's/^/| /' conftest.$ac_ext >&5
11588  
11589   fi
11590   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11591 < done
11592 <
7132 < fi
7133 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7134 < echo "${ECHO_T}$ac_cv_c_inline" >&6
7135 <
7136 <
7137 < case $ac_cv_c_inline in
7138 <  inline | yes) ;;
7139 <  *)
7140 <    case $ac_cv_c_inline in
7141 <      no) ac_val=;;
7142 <      *) ac_val=$ac_cv_c_inline;;
7143 <    esac
7144 <    cat >>confdefs.h <<_ACEOF
7145 < #ifndef __cplusplus
7146 < #define inline $ac_val
7147 < #endif
7148 < _ACEOF
7149 <    ;;
7150 < esac
7151 <
7152 <
7153 <
7154 <
7155 < for ac_func in rint sranddev
7156 < do
7157 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7158 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7159 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7160 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7161 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7162 < else
7163 <  cat >conftest.$ac_ext <<_ACEOF
11591 >    # Try with mode parameter
11592 >    cat >conftest.$ac_ext <<_ACEOF
11593   /* confdefs.h.  */
11594   _ACEOF
11595   cat confdefs.h >>conftest.$ac_ext
11596   cat >>conftest.$ac_ext <<_ACEOF
11597   /* end confdefs.h.  */
7169 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7170   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7171 #define $ac_func innocuous_$ac_func
11598  
11599 < /* System header to define __stub macros and hopefully few prototypes,
11600 <    which can conflict with char $ac_func (); below.
7175 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7176 <    <limits.h> exists even on freestanding compilers.  */
7177 <
7178 < #ifdef __STDC__
7179 < # include <limits.h>
11599 > #ifdef HAVE_IOSTREAM
11600 > #include <fstream>
11601   #else
11602 < # include <assert.h>
11602 > #include <fstream.h>
11603   #endif
11604 <
11605 < #undef $ac_func
7185 <
7186 < /* Override any gcc2 internal prototype to avoid an error.  */
7187 < #ifdef __cplusplus
7188 < extern "C"
7189 < {
11604 > #ifdef HAVE_STD_IOSTREAM
11605 > using namespace std;
11606   #endif
11607 < /* We use char because int might match the return type of a gcc2
11608 <   builtin and then its argument prototype would still apply.  */
11609 < char $ac_func ();
11610 < /* The GNU C library defines this for functions which it implements
11611 <    to always fail with ENOSYS.  Some functions are actually named
11612 <    something starting with __ and the normal name is an alias.  */
11613 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7198 < choke me
7199 < #else
7200 < char (*f) () = $ac_func;
11607 >
11608 > #ifdef FC_DUMMY_MAIN
11609 > #ifndef FC_DUMMY_MAIN_EQ_F77
11610 > #  ifdef __cplusplus
11611 >     extern "C"
11612 > #  endif
11613 >   int FC_DUMMY_MAIN() { return 1; }
11614   #endif
7202 #ifdef __cplusplus
7203 }
11615   #endif
7205
11616   int
11617   main ()
11618   {
11619 < return f != $ac_func;
11619 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11620    ;
11621    return 0;
11622   }
11623   _ACEOF
11624 < rm -f conftest.$ac_objext conftest$ac_exeext
11625 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11626 <  (eval $ac_link) 2>conftest.er1
11624 > rm -f conftest.$ac_objext
11625 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11626 >  (eval $ac_compile) 2>conftest.er1
11627    ac_status=$?
11628    grep -v '^ *+' conftest.er1 >conftest.err
11629    rm -f conftest.er1
11630    cat conftest.err >&5
11631    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11632    (exit $ac_status); } &&
11633 <         { ac_try='test -z "$ac_c_werror_flag"
11633 >         { ac_try='test -z "$ac_cxx_werror_flag"
11634                           || test ! -s conftest.err'
11635    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11636    (eval $ac_try) 2>&5
11637    ac_status=$?
11638    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639    (exit $ac_status); }; } &&
11640 <         { ac_try='test -s conftest$ac_exeext'
11640 >         { ac_try='test -s conftest.$ac_objext'
11641    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11642    (eval $ac_try) 2>&5
11643    ac_status=$?
11644    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11645    (exit $ac_status); }; }; then
11646 <  eval "$as_ac_var=yes"
11646 >  ac_cv_cxx_fstream_open_prot=yes
11647   else
11648    echo "$as_me: failed program was:" >&5
11649   sed 's/^/| /' conftest.$ac_ext >&5
11650  
7241 eval "$as_ac_var=no"
11651   fi
11652 < rm -f conftest.err conftest.$ac_objext \
11653 <      conftest$ac_exeext conftest.$ac_ext
11652 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11653 >    ac_ext=cc
11654 > ac_cpp='$CXXCPP $CPPFLAGS'
11655 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11656 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11657 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11658 >
11659 >
11660   fi
11661 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11662 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11663 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11664 <  cat >>confdefs.h <<_ACEOF
11665 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11661 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11662 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11663 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11664 >
11665 > cat >>confdefs.h <<\_ACEOF
11666 > #define HAVE_FSTREAM_OPEN 1
11667   _ACEOF
11668  
11669 < fi
11670 < done
11669 >  fi
11670 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11671  
11672 + cat >>confdefs.h <<\_ACEOF
11673 + #define FSTREAM_OPEN_PROT 1
11674 + _ACEOF
11675  
11676 <  # clean out junk possibly left behind by a previous configuration
7258 <  rm -f src/getopt.h
7259 <  # Check for getopt_long support
11676 >  fi
11677  
11678 < for ac_header in getopt.h
11678 >
11679 >
11680 >
11681 >
11682 >
11683 >
11684 > for ac_header in ctype.h iostream fstream sstream strstream
11685   do
11686   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11687   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7291 | Line 11714 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11714    cat conftest.err >&5
11715    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11716    (exit $ac_status); } &&
11717 <         { ac_try='test -z "$ac_c_werror_flag"
11717 >         { ac_try='test -z "$ac_cxx_werror_flag"
11718                           || test ! -s conftest.err'
11719    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11720    (eval $ac_try) 2>&5
# Line 7335 | Line 11758 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11758    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11759    (exit $ac_status); } >/dev/null; then
11760    if test -s conftest.err; then
11761 <    ac_cpp_err=$ac_c_preproc_warn_flag
11762 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11761 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11762 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11763    else
11764      ac_cpp_err=
11765    fi
# Line 7356 | Line 11779 | echo "${ECHO_T}$ac_header_preproc" >&6
11779   echo "${ECHO_T}$ac_header_preproc" >&6
11780  
11781   # So?  What about this header?
11782 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11782 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11783    yes:no: )
11784      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11785   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7407 | Line 11830 | done
11830  
11831   done
11832  
11833 + # AC_CPP_FUNC
11834 + # ------------------ #
11835 + # Checks to see if ANSI C99 CPP variable __func__ works.
11836 + # If not, perhaps __FUNCTION__ works instead.
11837 + # If not, we'll just define __func__ to "".
11838 + # AC_CPP_FUNC
11839  
11840 < for ac_func in getopt_long
11841 < do
11842 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11843 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7415 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7416 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11840 >
11841 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11842 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11843 > if test "${ac_cv_cpp_func+set}" = set; then
11844    echo $ECHO_N "(cached) $ECHO_C" >&6
11845   else
11846    cat >conftest.$ac_ext <<_ACEOF
# Line 7422 | Line 11849 | cat >>conftest.$ac_ext <<_ACEOF
11849   cat confdefs.h >>conftest.$ac_ext
11850   cat >>conftest.$ac_ext <<_ACEOF
11851   /* end confdefs.h.  */
7425 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7426   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7427 #define $ac_func innocuous_$ac_func
11852  
11853 < /* System header to define __stub macros and hopefully few prototypes,
11854 <    which can conflict with char $ac_func (); below.
11855 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11856 <    <limits.h> exists even on freestanding compilers.  */
11857 <
11858 < #ifdef __STDC__
7435 < # include <limits.h>
7436 < #else
7437 < # include <assert.h>
7438 < #endif
7439 <
7440 < #undef $ac_func
7441 <
7442 < /* Override any gcc2 internal prototype to avoid an error.  */
7443 < #ifdef __cplusplus
7444 < extern "C"
7445 < {
7446 < #endif
7447 < /* We use char because int might match the return type of a gcc2
7448 <   builtin and then its argument prototype would still apply.  */
7449 < char $ac_func ();
7450 < /* The GNU C library defines this for functions which it implements
7451 <    to always fail with ENOSYS.  Some functions are actually named
7452 <    something starting with __ and the normal name is an alias.  */
7453 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7454 < choke me
7455 < #else
7456 < char (*f) () = $ac_func;
11853 > #ifdef FC_DUMMY_MAIN
11854 > #ifndef FC_DUMMY_MAIN_EQ_F77
11855 > #  ifdef __cplusplus
11856 >     extern "C"
11857 > #  endif
11858 >   int FC_DUMMY_MAIN() { return 1; }
11859   #endif
7458 #ifdef __cplusplus
7459 }
11860   #endif
7461
11861   int
11862   main ()
11863   {
11864 < return f != $ac_func;
11864 > const char *foo = __func__;
11865    ;
11866    return 0;
11867   }
11868   _ACEOF
11869 < rm -f conftest.$ac_objext conftest$ac_exeext
11870 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11871 <  (eval $ac_link) 2>conftest.er1
11869 > rm -f conftest.$ac_objext
11870 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11871 >  (eval $ac_compile) 2>conftest.er1
11872    ac_status=$?
11873    grep -v '^ *+' conftest.er1 >conftest.err
11874    rm -f conftest.er1
11875    cat conftest.err >&5
11876    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11877    (exit $ac_status); } &&
11878 <         { ac_try='test -z "$ac_c_werror_flag"
11878 >         { ac_try='test -z "$ac_cxx_werror_flag"
11879                           || test ! -s conftest.err'
11880    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11881    (eval $ac_try) 2>&5
11882    ac_status=$?
11883    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11884    (exit $ac_status); }; } &&
11885 <         { ac_try='test -s conftest$ac_exeext'
11885 >         { ac_try='test -s conftest.$ac_objext'
11886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887    (eval $ac_try) 2>&5
11888    ac_status=$?
11889    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11890    (exit $ac_status); }; }; then
11891 <  eval "$as_ac_var=yes"
11891 >  ac_cv_cpp_func=yes
11892   else
11893    echo "$as_me: failed program was:" >&5
11894   sed 's/^/| /' conftest.$ac_ext >&5
11895  
7497 eval "$as_ac_var=no"
7498 fi
7499 rm -f conftest.err conftest.$ac_objext \
7500      conftest$ac_exeext conftest.$ac_ext
7501 fi
7502 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7503 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7504 if test `eval echo '${'$as_ac_var'}'` = yes; then
7505  cat >>confdefs.h <<_ACEOF
7506 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7507 _ACEOF
7508
7509 else
7510  # FreeBSD has a gnugetopt library for this
7511    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7512 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7513 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7514  echo $ECHO_N "(cached) $ECHO_C" >&6
7515 else
7516  ac_check_lib_save_LIBS=$LIBS
7517 LIBS="-lgnugetopt  $LIBS"
11896   cat >conftest.$ac_ext <<_ACEOF
11897   /* confdefs.h.  */
11898   _ACEOF
# Line 7522 | Line 11900 | cat >>conftest.$ac_ext <<_ACEOF
11900   cat >>conftest.$ac_ext <<_ACEOF
11901   /* end confdefs.h.  */
11902  
11903 < /* Override any gcc2 internal prototype to avoid an error.  */
11904 < #ifdef __cplusplus
11905 < extern "C"
11903 > #ifdef FC_DUMMY_MAIN
11904 > #ifndef FC_DUMMY_MAIN_EQ_F77
11905 > #  ifdef __cplusplus
11906 >     extern "C"
11907 > #  endif
11908 >   int FC_DUMMY_MAIN() { return 1; }
11909   #endif
11910 < /* We use char because int might match the return type of a gcc2
7530 <   builtin and then its argument prototype would still apply.  */
7531 < char getopt_long ();
11910 > #endif
11911   int
11912   main ()
11913   {
11914 < getopt_long ();
11914 > const char *foo = __FUNCTION__;
11915    ;
11916    return 0;
11917   }
11918   _ACEOF
11919 < rm -f conftest.$ac_objext conftest$ac_exeext
11920 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11921 <  (eval $ac_link) 2>conftest.er1
11919 > rm -f conftest.$ac_objext
11920 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11921 >  (eval $ac_compile) 2>conftest.er1
11922    ac_status=$?
11923    grep -v '^ *+' conftest.er1 >conftest.err
11924    rm -f conftest.er1
11925    cat conftest.err >&5
11926    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11927    (exit $ac_status); } &&
11928 <         { ac_try='test -z "$ac_c_werror_flag"
11928 >         { ac_try='test -z "$ac_cxx_werror_flag"
11929                           || test ! -s conftest.err'
11930    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11931    (eval $ac_try) 2>&5
11932    ac_status=$?
11933    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11934    (exit $ac_status); }; } &&
11935 <         { ac_try='test -s conftest$ac_exeext'
11935 >         { ac_try='test -s conftest.$ac_objext'
11936    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11937    (eval $ac_try) 2>&5
11938    ac_status=$?
11939    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11940    (exit $ac_status); }; }; then
11941 <  ac_cv_lib_gnugetopt_getopt_long=yes
11941 >  ac_cv_cpp_func=__FUNCTION__
11942   else
11943    echo "$as_me: failed program was:" >&5
11944   sed 's/^/| /' conftest.$ac_ext >&5
11945  
11946 < ac_cv_lib_gnugetopt_getopt_long=no
11946 > ac_cv_cpp_func=no
11947   fi
11948 < rm -f conftest.err conftest.$ac_objext \
7570 <      conftest$ac_exeext conftest.$ac_ext
7571 < LIBS=$ac_check_lib_save_LIBS
11948 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11949   fi
11950 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11951 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11952 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11953 <  cat >>confdefs.h <<\_ACEOF
11954 < #define HAVE_GETOPT_LONG 1
11950 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11951 > fi
11952 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11953 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11954 > if test $ac_cv_cpp_func = __FUNCTION__; then
11955 >
11956 > cat >>confdefs.h <<\_ACEOF
11957 > #define __func__ __FUNCTION__
11958   _ACEOF
11959  
11960 < else
7581 <  # use the GNU replacement
7582 <      case $LIBOBJS in
7583 <    "getopt.$ac_objext"   | \
7584 <  *" getopt.$ac_objext"   | \
7585 <    "getopt.$ac_objext "* | \
7586 <  *" getopt.$ac_objext "* ) ;;
7587 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7588 < esac
11960 > elif test $ac_cv_cpp_func = no; then
11961  
11962 <      case $LIBOBJS in
11963 <    "getopt1.$ac_objext"   | \
11964 <  *" getopt1.$ac_objext"   | \
7593 <    "getopt1.$ac_objext "* | \
7594 <  *" getopt1.$ac_objext "* ) ;;
7595 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7596 < esac
11962 > cat >>confdefs.h <<\_ACEOF
11963 > #define __func__ ""
11964 > _ACEOF
11965  
7598                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7599
11966   fi
11967  
7602 fi
7603 done
11968  
11969  
11970  
11971 +
11972   case $debug in
11973    1)
11974       ;;
# Line 7612 | Line 11977 | case $debug in
11977  
11978  
11979  
11980 + # Try to determine "good" native compiler flags if none specified on command
11981 + # line
11982  
11983 + if test "$ac_test_FFLAGS" != "set"; then
11984 +  FCFLAGS=""
11985 +  case "${host_cpu}-${host_os}" in
11986  
11987 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11988 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11989 +                fi;;
11990 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11991 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11992 +                fi;;
11993 +   powerpc*-aix*)
11994 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11995 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11996 +                echo "*******************************************************"
11997 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11998 +                echo "*  recommended that you use                           *"
11999 +                echo "*                                                     *"
12000 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12001 +                echo "*                                 ^^^                 *"
12002 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12003 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12004 +                echo "*******************************************************"
12005 +        fi;;
12006 +   *darwin*)
12007 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12008 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12009 +        fi
12010 +        if test "$FC" = ifort; then
12011 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12012 +        fi;;
12013 +  esac
12014 +
12015 +  if test -n "$CPU_FLAGS"; then
12016 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12017 +  fi
12018 +
12019 +  if test -z "$FCFLAGS"; then
12020 +        echo ""
12021 +        echo "*********************************************************"
12022 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12023 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12024 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12025 +        echo "*********************************************************"
12026 +        echo ""
12027 +        FCFLAGS="-O3"
12028 +  fi
12029 +
12030 +
12031 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12032 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12033 + if test "${ac_guessed_f90flags+set}" = set; then
12034 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12035 + else
12036 +
12037 +
12038 +
12039 + ac_ext=${FC_SRCEXT-f}
12040 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12041 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12042 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12043 +
12044 + echo 'program main' > conftest.$ac_ext
12045 + echo 'end program main' >> conftest.$ac_ext
12046 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12047 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12048 +  (eval $ac_compile) 2>&5
12049 +  ac_status=$?
12050 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12051 +  (exit $ac_status); }; then
12052 +        ac_guessed_f90flags=yes
12053 + else
12054 +        ac_guessed_f90flags=no
12055 + fi
12056 + rm -f conftest*
12057 + ac_ext=cc
12058 + ac_cpp='$CXXCPP $CPPFLAGS'
12059 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12060 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12061 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12062 +
12063 +
12064 + fi
12065 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12066 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12067 + if test "$ac_guessed_f90flags" = yes; then
12068 +        :
12069 +
12070 + else
12071 +        :
12072 +
12073 +        echo ""
12074 +        echo "**********************************************************"
12075 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12076 +        echo "* your compiler.                                        *"
12077 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12078 +        echo "*********************************************************"
12079 +        echo ""
12080 +        FCFLAGS=""
12081 +
12082 + fi
12083 +
12084 +
12085 + fi
12086 +
12087 +
12088 +
12089 +
12090 +
12091 +
12092 +
12093   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12094   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12095   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 7622 | Line 12098 | cat > conftest.c <<EOF
12098  
12099   cat > conftest.c <<EOF
12100   #ifdef __GNUC__
12101 <  #ifndef __INTEL_COMPILER
12101 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12102 >     no;
12103 >  #else
12104       yes;
12105    #endif
12106   #endif
# Line 7660 | Line 12138 | if test "$ac_test_CFLAGS" != "set"; then
12138                      CFLAGS="-O"
12139                  fi;;
12140    sparc-solaris2*) if test "$CC" = cc; then
12141 <                    CFLAGS="-native -fast -xO5 -dalign"
12141 >                    CFLAGS="-O -dalign"
12142                   fi;;
12143  
12144    alpha*-osf*)  if test "$CC" = cc; then
# Line 7690 | Line 12168 | if test "$ac_test_CFLAGS" != "set"; then
12168     *darwin*)
12169          if test "$CC" = xlc -o "$CC" = cc; then
12170                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12171 +        fi
12172 +        if test "$CC" = icc; then
12173 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12174          fi;;
12175    esac
12176  
# Line 7703 | Line 12184 | if test "$ac_test_CFLAGS" != "set"; then
12184      # -malign-double for x86 systems
12185  
12186  
12187 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12188 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12187 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12188 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12189   if test "${ac_align_double+set}" = set; then
12190    echo $ECHO_N "(cached) $ECHO_C" >&6
12191   else
12192    echo 'void f(){}' > conftest.c
12193 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12193 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12194          ac_align_double=yes
12195   else
12196          ac_align_double=no
# Line 7730 | Line 12211 | fi
12211      # -fstrict-aliasing for gcc-2.95+
12212  
12213  
12214 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12215 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12214 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12215 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12216   if test "${ac_fstrict_aliasing+set}" = set; then
12217    echo $ECHO_N "(cached) $ECHO_C" >&6
12218   else
12219    echo 'void f(){}' > conftest.c
12220 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12220 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12221          ac_fstrict_aliasing=yes
12222   else
12223          ac_fstrict_aliasing=no
# Line 7761 | Line 12242 | fi
12242                    case "${host_cpu}" in
12243            i586*)
12244  
12245 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12246 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12245 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12246 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12247   if test "${ac_cpu_pentium+set}" = set; then
12248    echo $ECHO_N "(cached) $ECHO_C" >&6
12249   else
12250    echo 'void f(){}' > conftest.c
12251 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12251 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12252          ac_cpu_pentium=yes
12253   else
12254          ac_cpu_pentium=no
# Line 7784 | Line 12265 | else
12265          :
12266  
12267  
12268 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12269 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12268 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12269 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12270   if test "${ac_pentium+set}" = set; then
12271    echo $ECHO_N "(cached) $ECHO_C" >&6
12272   else
12273    echo 'void f(){}' > conftest.c
12274 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12274 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12275          ac_pentium=yes
12276   else
12277          ac_pentium=no
# Line 7813 | Line 12294 | fi
12294                    ;;
12295            i686*)
12296  
12297 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12298 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12297 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12298 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12299   if test "${ac_cpu_pentiumpro+set}" = set; then
12300    echo $ECHO_N "(cached) $ECHO_C" >&6
12301   else
12302    echo 'void f(){}' > conftest.c
12303 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12303 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12304          ac_cpu_pentiumpro=yes
12305   else
12306          ac_cpu_pentiumpro=no
# Line 7836 | Line 12317 | else
12317          :
12318  
12319  
12320 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12321 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12320 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12321 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12322   if test "${ac_pentiumpro+set}" = set; then
12323    echo $ECHO_N "(cached) $ECHO_C" >&6
12324   else
12325    echo 'void f(){}' > conftest.c
12326 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12326 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12327          ac_pentiumpro=yes
12328   else
12329          ac_pentiumpro=no
# Line 7869 | Line 12350 | fi
12350                  if test -n "$is60x"; then
12351  
12352  
12353 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12354 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12353 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12354 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12355   if test "${ac_m_cpu_60x+set}" = set; then
12356    echo $ECHO_N "(cached) $ECHO_C" >&6
12357   else
12358    echo 'void f(){}' > conftest.c
12359 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12359 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12360          ac_m_cpu_60x=yes
12361   else
12362          ac_m_cpu_60x=no
# Line 7927 | Line 12408 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12408          :
12409  
12410  
12411 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12412 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12411 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12412 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12413   if test "${ac_m_cpu_750+set}" = set; then
12414    echo $ECHO_N "(cached) $ECHO_C" >&6
12415   else
12416    echo 'void f(){}' > conftest.c
12417 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12417 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12418          ac_m_cpu_750=yes
12419   else
12420          ac_m_cpu_750=no
# Line 7960 | Line 12441 | fi
12441                  if test -z "$CPU_FLAGS"; then
12442  
12443  
12444 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12445 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12444 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12445 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12446   if test "${ac_m_cpu_powerpc+set}" = set; then
12447    echo $ECHO_N "(cached) $ECHO_C" >&6
12448   else
12449    echo 'void f(){}' > conftest.c
12450 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12450 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12451          ac_m_cpu_powerpc=yes
12452   else
12453          ac_m_cpu_powerpc=no
# Line 7988 | Line 12469 | fi
12469                  if test -z "$CPU_FLAGS"; then
12470  
12471  
12472 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12473 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12472 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12473 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12474   if test "${ac_m_powerpc+set}" = set; then
12475    echo $ECHO_N "(cached) $ECHO_C" >&6
12476   else
12477    echo 'void f(){}' > conftest.c
12478 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12478 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12479          ac_m_powerpc=yes
12480   else
12481          ac_m_powerpc=no
# Line 8033 | Line 12514 | fi
12514  
12515  
12516  
12517 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12518 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12517 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12518 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12519   if test "${ac_guessed_cflags+set}" = set; then
12520    echo $ECHO_N "(cached) $ECHO_C" >&6
12521   else
12522    echo 'void f(){}' > conftest.c
12523 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12523 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12524          ac_guessed_cflags=yes
12525   else
12526          ac_guessed_cflags=no
# Line 8083 | Line 12564 | cat > conftest.cpp <<EOF
12564  
12565   cat > conftest.cpp <<EOF
12566   #ifdef __GNUC__
12567 <  #ifndef __INTEL_COMPILER
12567 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12568 >     no;
12569 >  #else
12570       yes;
12571    #endif
12572   #endif
# Line 8121 | Line 12604 | if test "$ac_test_CXXFLAGS" != "set"; then
12604                      CXXFLAGS="-O"
12605                  fi;;
12606    sparc-solaris2*) if test "$CXX" = CC; then
12607 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12607 >                    CXXFLAGS="-features=extensions -O -dalign"
12608                   fi;;
12609     rs6000*-aix*)  if test "$CXX" = xlC; then
12610                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8142 | Line 12625 | if test "$ac_test_CXXFLAGS" != "set"; then
12625     *darwin*)
12626          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12627                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12628 +        fi
12629 +        if test "$CXX" = icpc; then
12630 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12631          fi;;
12632    esac
12633  
# Line 8155 | Line 12641 | if test "$ac_test_CXXFLAGS" != "set"; then
12641      # -malign-double for x86 systems
12642  
12643  
12644 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12645 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12644 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12645 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12646   if test "${ac_align_double+set}" = set; then
12647    echo $ECHO_N "(cached) $ECHO_C" >&6
12648   else
12649    echo 'void f(){}' > conftest.cpp
12650 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12650 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12651          ac_align_double=yes
12652   else
12653          ac_align_double=no
# Line 8182 | Line 12668 | fi
12668      # -fstrict-aliasing for gcc-2.95+
12669  
12670  
12671 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12672 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12671 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12672 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12673   if test "${ac_fstrict_aliasing+set}" = set; then
12674    echo $ECHO_N "(cached) $ECHO_C" >&6
12675   else
12676    echo 'void f(){}' > conftest.cpp
12677 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12677 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12678          ac_fstrict_aliasing=yes
12679   else
12680          ac_fstrict_aliasing=no
# Line 8213 | Line 12699 | fi
12699                    case "${host_cpu}" in
12700            i586*)
12701  
12702 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12703 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12702 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12703 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12704   if test "${ac_cpu_pentium+set}" = set; then
12705    echo $ECHO_N "(cached) $ECHO_C" >&6
12706   else
12707    echo 'void f(){}' > conftest.cpp
12708 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12708 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12709          ac_cpu_pentium=yes
12710   else
12711          ac_cpu_pentium=no
# Line 8236 | Line 12722 | else
12722          :
12723  
12724  
12725 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12726 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12725 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12726 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12727   if test "${ac_pentium+set}" = set; then
12728    echo $ECHO_N "(cached) $ECHO_C" >&6
12729   else
12730    echo 'void f(){}' > conftest.cpp
12731 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12731 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12732          ac_pentium=yes
12733   else
12734          ac_pentium=no
# Line 8265 | Line 12751 | fi
12751                    ;;
12752            i686*)
12753  
12754 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12755 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12754 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12755 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12756   if test "${ac_cpu_pentiumpro+set}" = set; then
12757    echo $ECHO_N "(cached) $ECHO_C" >&6
12758   else
12759    echo 'void f(){}' > conftest.cpp
12760 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12760 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12761          ac_cpu_pentiumpro=yes
12762   else
12763          ac_cpu_pentiumpro=no
# Line 8288 | Line 12774 | else
12774          :
12775  
12776  
12777 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12778 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12777 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12778 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12779   if test "${ac_pentiumpro+set}" = set; then
12780    echo $ECHO_N "(cached) $ECHO_C" >&6
12781   else
12782    echo 'void f(){}' > conftest.cpp
12783 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12783 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12784          ac_pentiumpro=yes
12785   else
12786          ac_pentiumpro=no
# Line 8321 | Line 12807 | fi
12807                  if test -n "$is60x"; then
12808  
12809  
12810 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12811 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12810 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12811 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12812   if test "${ac_m_cpu_60x+set}" = set; then
12813    echo $ECHO_N "(cached) $ECHO_C" >&6
12814   else
12815    echo 'void f(){}' > conftest.cpp
12816 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12816 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12817          ac_m_cpu_60x=yes
12818   else
12819          ac_m_cpu_60x=no
8334 fi
8335 rm -f conftest*
8336
8337 fi
8338 echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
8339 echo "${ECHO_T}$ac_m_cpu_60x" >&6
8340 if test "$ac_m_cpu_60x" = yes; then
8341        :
8342        CPU_FLAGS=-mcpu=$cputype
8343 else
8344        :
8345
8346 fi
8347
8348                elif test "$cputype" = 750; then
8349
8350
8351 echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
8352 echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
8353 if test "${ac_cv_prog_gxx_2_95+set}" = set; then
8354  echo $ECHO_N "(cached) $ECHO_C" >&6
8355 else
8356
8357 cat > conftest.cpp <<EOF
8358 #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8359 #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8360     yes;
8361 #  endif
8362 #endif
8363 EOF
8364 if { ac_try='${CXX-c++} -E conftest.cpp'
8365  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8366  (eval $ac_try) 2>&5
8367  ac_status=$?
8368  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8369  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8370  ac_cv_prog_gxx_2_95=yes
8371 else
8372  ac_cv_prog_gxx_2_95=no
8373 fi
8374
8375 fi
8376 echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8377 echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8378 if test "$ac_cv_prog_gxx_2_95" = yes; then
8379        :
8380
8381
8382 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
8383 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
8384 if test "${ac_m_cpu_750+set}" = set; then
8385  echo $ECHO_N "(cached) $ECHO_C" >&6
8386 else
8387  echo 'void f(){}' > conftest.cpp
8388 if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
8389        ac_m_cpu_750=yes
8390 else
8391        ac_m_cpu_750=no
8392 fi
8393 rm -f conftest*
8394
8395 fi
8396 echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
8397 echo "${ECHO_T}$ac_m_cpu_750" >&6
8398 if test "$ac_m_cpu_750" = yes; then
8399        :
8400        CPU_FLAGS=-mcpu=750
8401 else
8402        :
8403
8404 fi
8405
8406 else
8407        :
8408
8409 fi
8410
8411                fi
8412                if test -z "$CPU_FLAGS"; then
8413
8414
8415 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
8416 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
8417 if test "${ac_m_cpu_powerpc+set}" = set; then
8418  echo $ECHO_N "(cached) $ECHO_C" >&6
8419 else
8420  echo 'void f(){}' > conftest.cpp
8421 if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
8422        ac_m_cpu_powerpc=yes
8423 else
8424        ac_m_cpu_powerpc=no
8425 fi
8426 rm -f conftest*
8427
8428 fi
8429 echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
8430 echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
8431 if test "$ac_m_cpu_powerpc" = yes; then
8432        :
8433        CPU_FLAGS=-mcpu=powerpc
8434 else
8435        :
8436
8437 fi
8438
8439                fi
8440                if test -z "$CPU_FLAGS"; then
8441
8442
8443 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
8444 echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
8445 if test "${ac_m_powerpc+set}" = set; then
8446  echo $ECHO_N "(cached) $ECHO_C" >&6
8447 else
8448  echo 'void f(){}' > conftest.cpp
8449 if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
8450        ac_m_powerpc=yes
8451 else
8452        ac_m_powerpc=no
8453 fi
8454 rm -f conftest*
8455
8456 fi
8457 echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
8458 echo "${ECHO_T}$ac_m_powerpc" >&6
8459 if test "$ac_m_powerpc" = yes; then
8460        :
8461        CPU_FLAGS=-mpowerpc
8462 else
8463        :
8464
8465 fi
8466
8467                fi
8468          esac
8469  fi
8470
8471  if test -n "$CPU_FLAGS"; then
8472        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
8473  fi
8474
8475  if test -z "$CXXFLAGS"; then
8476        echo ""
8477        echo "**********************************************************"
8478        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
8479        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8480        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
8481        echo "**********************************************************"
8482        echo ""
8483        CXXFLAGS="-O3"
8484  fi
8485
8486
8487
8488 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
8489 echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
8490 if test "${ac_guessed_cxxflags+set}" = set; then
8491  echo $ECHO_N "(cached) $ECHO_C" >&6
8492 else
8493  echo 'void f(){}' > conftest.cpp
8494 if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
8495        ac_guessed_cxxflags=yes
8496 else
8497        ac_guessed_cxxflags=no
12820   fi
12821   rm -f conftest*
12822  
12823 < fi
12824 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12825 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12826 < if test "$ac_guessed_cxxflags" = yes; then
12827 <        :
12828 <
8507 < else
8508 <        :
8509 <
8510 <        echo ""
8511 <        echo "**********************************************************"
8512 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
8513 <        echo "* your compiler.                                         *"
8514 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8515 <        echo "**********************************************************"
8516 <        echo ""
8517 <        CXXFLAGS=""
8518 <
8519 < fi
8520 <
8521 <
8522 < fi
8523 <
8524 <
8525 <
8526 <
8527 <
8528 < # Try to determine "good" native compiler flags if none specified on command
8529 < # line
8530 <
8531 < if test x"$F90FLAGS" = x ; then
8532 <  F90FLAGS=""
8533 <  case "${host_cpu}-${host_os}" in
8534 <
8535 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8536 <                    F90FLAGS="-O"
8537 <                fi;;
8538 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8539 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8540 <                fi;;
8541 <   powerpc*-aix*)
8542 <        if test "$F90" = f90 -o "$F90" = xlf90; then
8543 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8544 <                echo "*******************************************************"
8545 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8546 <                echo "*  recommended that you use                           *"
8547 <                echo "*                                                     *"
8548 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8549 <                echo "*                                 ^^^                 *"
8550 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8551 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8552 <                echo "*******************************************************"
8553 <        fi;;
8554 <   *darwin*)
8555 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8556 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8557 <        fi;;
8558 <  esac
8559 <
8560 <  if test -n "$CPU_FLAGS"; then
8561 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
8562 <  fi
8563 <
8564 <  if test -z "$F90FLAGS"; then
8565 <        echo ""
8566 <        echo "**********************************************************"
8567 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8568 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8569 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8570 <        echo "**********************************************************"
8571 <        echo ""
8572 <        F90FLAGS="-O3"
8573 <  fi
8574 <
8575 <
8576 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8577 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8578 < if test "${ac_guessed_f90flags+set}" = set; then
8579 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8580 < else
8581 <
8582 <
8583 <
8584 < ac_ext=f90
8585 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8586 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8587 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8588 <
8589 < echo 'program main' > conftest.$ac_ext
8590 < echo 'end program main' >> conftest.$ac_ext
8591 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8592 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8593 <  (eval $ac_compile) 2>&5
8594 <  ac_status=$?
8595 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8596 <  (exit $ac_status); }; then
8597 <        ac_guessed_f90flags=yes
8598 < else
8599 <        ac_guessed_f90flags=no
8600 < fi
8601 < rm -f conftest*
8602 < ac_ext=c
8603 < ac_cpp='$CPP $CPPFLAGS'
8604 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8605 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8606 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8607 <
8608 <
8609 < fi
8610 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8611 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
8612 < if test "$ac_guessed_f90flags" = yes; then
8613 <        :
8614 <
8615 < else
8616 <        :
8617 <
8618 <        echo ""
8619 <        echo "**********************************************************"
8620 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8621 <        echo "* your compiler.                                         *"
8622 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8623 <        echo "**********************************************************"
8624 <        echo ""
8625 <        F90FLAGS=""
8626 <
8627 < fi
8628 <
8629 <
8630 < fi
8631 <
8632 <     ;;
8633 < esac
8634 <
8635 < # Find a good install program.  We prefer a C program (faster),
8636 < # so one script is as good as another.  But avoid the broken or
8637 < # incompatible versions:
8638 < # SysV /etc/install, /usr/sbin/install
8639 < # SunOS /usr/etc/install
8640 < # IRIX /sbin/install
8641 < # AIX /bin/install
8642 < # AmigaOS /C/install, which installs bootblocks on floppy discs
8643 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8644 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8645 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8646 < # OS/2's system install, which has a completely different semantic
8647 < # ./install, which can be erroneously created by make from ./install.sh.
8648 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8649 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8650 < if test -z "$INSTALL"; then
8651 < if test "${ac_cv_path_install+set}" = set; then
8652 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8653 < else
8654 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8655 < for as_dir in $PATH
8656 < do
8657 <  IFS=$as_save_IFS
8658 <  test -z "$as_dir" && as_dir=.
8659 <  # Account for people who put trailing slashes in PATH elements.
8660 < case $as_dir/ in
8661 <  ./ | .// | /cC/* | \
8662 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8663 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8664 <  /usr/ucb/* ) ;;
8665 <  *)
8666 <    # OSF1 and SCO ODT 3.0 have their own names for install.
8667 <    # Don't use installbsd from OSF since it installs stuff as root
8668 <    # by default.
8669 <    for ac_prog in ginstall scoinst install; do
8670 <      for ac_exec_ext in '' $ac_executable_extensions; do
8671 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8672 <          if test $ac_prog = install &&
8673 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8674 <            # AIX install.  It has an incompatible calling convention.
8675 <            :
8676 <          elif test $ac_prog = install &&
8677 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8678 <            # program-specific install script used by HP pwplus--don't use.
8679 <            :
8680 <          else
8681 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8682 <            break 3
8683 <          fi
8684 <        fi
8685 <      done
8686 <    done
8687 <    ;;
8688 < esac
8689 < done
8690 <
8691 <
8692 < fi
8693 <  if test "${ac_cv_path_install+set}" = set; then
8694 <    INSTALL=$ac_cv_path_install
8695 <  else
8696 <    # As a last resort, use the slow shell script.  We don't cache a
8697 <    # path for INSTALL within a source directory, because that will
8698 <    # break other packages using the cache if that directory is
8699 <    # removed, or if the path is relative.
8700 <    INSTALL=$ac_install_sh
8701 <  fi
8702 < fi
8703 < echo "$as_me:$LINENO: result: $INSTALL" >&5
8704 < echo "${ECHO_T}$INSTALL" >&6
8705 <
8706 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8707 < # It thinks the first close brace ends the variable substitution.
8708 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8709 <
8710 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8711 <
8712 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8713 <
8714 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
8715 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8716 < LN_S=$as_ln_s
8717 < if test "$LN_S" = "ln -s"; then
8718 <  echo "$as_me:$LINENO: result: yes" >&5
8719 < echo "${ECHO_T}yes" >&6
12823 > fi
12824 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
12825 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
12826 > if test "$ac_m_cpu_60x" = yes; then
12827 >        :
12828 >        CPU_FLAGS=-mcpu=$cputype
12829   else
12830 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
12831 < echo "${ECHO_T}no, using $LN_S" >&6
12830 >        :
12831 >
12832   fi
12833  
12834 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
12835 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
12836 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
12837 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
12834 >                elif test "$cputype" = 750; then
12835 >
12836 >
12837 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
12838 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
12839 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
12840    echo $ECHO_N "(cached) $ECHO_C" >&6
12841   else
12842 <  cat >conftest.make <<\_ACEOF
12843 < all:
12844 <        @echo 'ac_maketemp="$(MAKE)"'
12845 < _ACEOF
12846 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
12847 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
12848 < if test -n "$ac_maketemp"; then
12849 <  eval ac_cv_prog_make_${ac_make}_set=yes
12842 >
12843 > cat > conftest.cpp <<EOF
12844 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12845 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12846 >     yes;
12847 > #  endif
12848 > #endif
12849 > EOF
12850 > if { ac_try='${CXX-c++} -E conftest.cpp'
12851 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12852 >  (eval $ac_try) 2>&5
12853 >  ac_status=$?
12854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12855 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12856 >  ac_cv_prog_gxx_2_95=yes
12857   else
12858 <  eval ac_cv_prog_make_${ac_make}_set=no
12858 >  ac_cv_prog_gxx_2_95=no
12859   fi
12860 < rm -f conftest.make
12860 >
12861   fi
12862 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
12863 <  echo "$as_me:$LINENO: result: yes" >&5
12864 < echo "${ECHO_T}yes" >&6
12865 <  SET_MAKE=
8748 < else
8749 <  echo "$as_me:$LINENO: result: no" >&5
8750 < echo "${ECHO_T}no" >&6
8751 <  SET_MAKE="MAKE=${MAKE-make}"
8752 < fi
12862 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12863 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12864 > if test "$ac_cv_prog_gxx_2_95" = yes; then
12865 >        :
12866  
12867 < if test -n "$ac_tool_prefix"; then
12868 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
12869 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
12870 < echo "$as_me:$LINENO: checking for $ac_word" >&5
8758 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8759 < if test "${ac_cv_prog_RANLIB+set}" = set; then
12867 >
12868 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12869 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12870 > if test "${ac_m_cpu_750+set}" = set; then
12871    echo $ECHO_N "(cached) $ECHO_C" >&6
12872   else
12873 <  if test -n "$RANLIB"; then
12874 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
12873 >  echo 'void f(){}' > conftest.cpp
12874 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12875 >        ac_m_cpu_750=yes
12876   else
12877 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8766 < for as_dir in $PATH
8767 < do
8768 <  IFS=$as_save_IFS
8769 <  test -z "$as_dir" && as_dir=.
8770 <  for ac_exec_ext in '' $ac_executable_extensions; do
8771 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8772 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8773 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8774 <    break 2
8775 <  fi
8776 < done
8777 < done
8778 <
12877 >        ac_m_cpu_750=no
12878   fi
12879 < fi
8781 < RANLIB=$ac_cv_prog_RANLIB
8782 < if test -n "$RANLIB"; then
8783 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
8784 < echo "${ECHO_T}$RANLIB" >&6
8785 < else
8786 <  echo "$as_me:$LINENO: result: no" >&5
8787 < echo "${ECHO_T}no" >&6
8788 < fi
12879 > rm -f conftest*
12880  
12881   fi
12882 < if test -z "$ac_cv_prog_RANLIB"; then
12883 <  ac_ct_RANLIB=$RANLIB
12884 <  # Extract the first word of "ranlib", so it can be a program name with args.
12885 < set dummy ranlib; ac_word=$2
12886 < echo "$as_me:$LINENO: checking for $ac_word" >&5
8796 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8797 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
8798 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12882 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12883 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12884 > if test "$ac_m_cpu_750" = yes; then
12885 >        :
12886 >        CPU_FLAGS=-mcpu=750
12887   else
12888 <  if test -n "$ac_ct_RANLIB"; then
8801 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
8802 < else
8803 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804 < for as_dir in $PATH
8805 < do
8806 <  IFS=$as_save_IFS
8807 <  test -z "$as_dir" && as_dir=.
8808 <  for ac_exec_ext in '' $ac_executable_extensions; do
8809 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
8811 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812 <    break 2
8813 <  fi
8814 < done
8815 < done
12888 >        :
12889  
8817  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
12890   fi
8819 fi
8820 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
8821 if test -n "$ac_ct_RANLIB"; then
8822  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
8823 echo "${ECHO_T}$ac_ct_RANLIB" >&6
8824 else
8825  echo "$as_me:$LINENO: result: no" >&5
8826 echo "${ECHO_T}no" >&6
8827 fi
12891  
8829  RANLIB=$ac_ct_RANLIB
12892   else
12893 <  RANLIB="$ac_cv_prog_RANLIB"
12893 >        :
12894 >
12895   fi
12896  
12897 < for ac_prog in 'bison -y' byacc
12898 < do
12899 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12900 < set dummy $ac_prog; ac_word=$2
12901 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12902 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12903 < if test "${ac_cv_prog_YACC+set}" = set; then
12897 >                fi
12898 >                if test -z "$CPU_FLAGS"; then
12899 >
12900 >
12901 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12902 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12903 > if test "${ac_m_cpu_powerpc+set}" = set; then
12904    echo $ECHO_N "(cached) $ECHO_C" >&6
12905   else
12906 <  if test -n "$YACC"; then
12907 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
12906 >  echo 'void f(){}' > conftest.cpp
12907 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12908 >        ac_m_cpu_powerpc=yes
12909   else
12910 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12911 < for as_dir in $PATH
12912 < do
8849 <  IFS=$as_save_IFS
8850 <  test -z "$as_dir" && as_dir=.
8851 <  for ac_exec_ext in '' $ac_executable_extensions; do
8852 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8853 <    ac_cv_prog_YACC="$ac_prog"
8854 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8855 <    break 2
8856 <  fi
8857 < done
8858 < done
12910 >        ac_m_cpu_powerpc=no
12911 > fi
12912 > rm -f conftest*
12913  
12914   fi
12915 < fi
12916 < YACC=$ac_cv_prog_YACC
12917 < if test -n "$YACC"; then
12918 <  echo "$as_me:$LINENO: result: $YACC" >&5
12919 < echo "${ECHO_T}$YACC" >&6
12915 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12916 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12917 > if test "$ac_m_cpu_powerpc" = yes; then
12918 >        :
12919 >        CPU_FLAGS=-mcpu=powerpc
12920   else
12921 <  echo "$as_me:$LINENO: result: no" >&5
12922 < echo "${ECHO_T}no" >&6
12921 >        :
12922 >
12923   fi
12924  
12925 <  test -n "$YACC" && break
12926 < done
8873 < test -n "$YACC" || YACC="yacc"
12925 >                fi
12926 >                if test -z "$CPU_FLAGS"; then
12927  
12928 < for ac_prog in flex lex
12929 < do
12930 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12931 < set dummy $ac_prog; ac_word=$2
8879 < echo "$as_me:$LINENO: checking for $ac_word" >&5
8880 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8881 < if test "${ac_cv_prog_LEX+set}" = set; then
12928 >
12929 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12930 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12931 > if test "${ac_m_powerpc+set}" = set; then
12932    echo $ECHO_N "(cached) $ECHO_C" >&6
12933   else
12934 <  if test -n "$LEX"; then
12935 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12934 >  echo 'void f(){}' > conftest.cpp
12935 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12936 >        ac_m_powerpc=yes
12937   else
12938 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12939 < for as_dir in $PATH
12940 < do
8890 <  IFS=$as_save_IFS
8891 <  test -z "$as_dir" && as_dir=.
8892 <  for ac_exec_ext in '' $ac_executable_extensions; do
8893 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8894 <    ac_cv_prog_LEX="$ac_prog"
8895 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8896 <    break 2
8897 <  fi
8898 < done
8899 < done
12938 >        ac_m_powerpc=no
12939 > fi
12940 > rm -f conftest*
12941  
12942   fi
12943 < fi
12944 < LEX=$ac_cv_prog_LEX
12945 < if test -n "$LEX"; then
12946 <  echo "$as_me:$LINENO: result: $LEX" >&5
12947 < echo "${ECHO_T}$LEX" >&6
12943 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12944 > echo "${ECHO_T}$ac_m_powerpc" >&6
12945 > if test "$ac_m_powerpc" = yes; then
12946 >        :
12947 >        CPU_FLAGS=-mpowerpc
12948   else
12949 <  echo "$as_me:$LINENO: result: no" >&5
12950 < echo "${ECHO_T}no" >&6
12949 >        :
12950 >
12951   fi
12952  
12953 <  test -n "$LEX" && break
12954 < done
12955 < test -n "$LEX" || LEX=":"
12953 >                fi
12954 >          esac
12955 >  fi
12956  
12957 < if test -z "$LEXLIB"
12958 < then
12959 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8919 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8920 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8921 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8922 < else
8923 <  ac_check_lib_save_LIBS=$LIBS
8924 < LIBS="-lfl  $LIBS"
8925 < cat >conftest.$ac_ext <<_ACEOF
8926 < /* confdefs.h.  */
8927 < _ACEOF
8928 < cat confdefs.h >>conftest.$ac_ext
8929 < cat >>conftest.$ac_ext <<_ACEOF
8930 < /* end confdefs.h.  */
12957 >  if test -n "$CPU_FLAGS"; then
12958 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12959 >  fi
12960  
12961 < /* Override any gcc2 internal prototype to avoid an error.  */
12962 < #ifdef __cplusplus
12963 < extern "C"
12964 < #endif
12965 < /* We use char because int might match the return type of a gcc2
12966 <   builtin and then its argument prototype would still apply.  */
12967 < char yywrap ();
12968 < int
12969 < main ()
12970 < {
8942 < yywrap ();
8943 <  ;
8944 <  return 0;
8945 < }
8946 < _ACEOF
8947 < rm -f conftest.$ac_objext conftest$ac_exeext
8948 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8949 <  (eval $ac_link) 2>conftest.er1
8950 <  ac_status=$?
8951 <  grep -v '^ *+' conftest.er1 >conftest.err
8952 <  rm -f conftest.er1
8953 <  cat conftest.err >&5
8954 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8955 <  (exit $ac_status); } &&
8956 <         { ac_try='test -z "$ac_c_werror_flag"
8957 <                         || test ! -s conftest.err'
8958 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8959 <  (eval $ac_try) 2>&5
8960 <  ac_status=$?
8961 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8962 <  (exit $ac_status); }; } &&
8963 <         { ac_try='test -s conftest$ac_exeext'
8964 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8965 <  (eval $ac_try) 2>&5
8966 <  ac_status=$?
8967 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8968 <  (exit $ac_status); }; }; then
8969 <  ac_cv_lib_fl_yywrap=yes
8970 < else
8971 <  echo "$as_me: failed program was:" >&5
8972 < sed 's/^/| /' conftest.$ac_ext >&5
12961 >  if test -z "$CXXFLAGS"; then
12962 >        echo ""
12963 >        echo "**********************************************************"
12964 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12965 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12966 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12967 >        echo "**********************************************************"
12968 >        echo ""
12969 >        CXXFLAGS="-O3"
12970 >  fi
12971  
8974 ac_cv_lib_fl_yywrap=no
8975 fi
8976 rm -f conftest.err conftest.$ac_objext \
8977      conftest$ac_exeext conftest.$ac_ext
8978 LIBS=$ac_check_lib_save_LIBS
8979 fi
8980 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8981 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8982 if test $ac_cv_lib_fl_yywrap = yes; then
8983  LEXLIB="-lfl"
8984 else
8985  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8986 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8987 if test "${ac_cv_lib_l_yywrap+set}" = set; then
8988  echo $ECHO_N "(cached) $ECHO_C" >&6
8989 else
8990  ac_check_lib_save_LIBS=$LIBS
8991 LIBS="-ll  $LIBS"
8992 cat >conftest.$ac_ext <<_ACEOF
8993 /* confdefs.h.  */
8994 _ACEOF
8995 cat confdefs.h >>conftest.$ac_ext
8996 cat >>conftest.$ac_ext <<_ACEOF
8997 /* end confdefs.h.  */
12972  
8999 /* Override any gcc2 internal prototype to avoid an error.  */
9000 #ifdef __cplusplus
9001 extern "C"
9002 #endif
9003 /* We use char because int might match the return type of a gcc2
9004   builtin and then its argument prototype would still apply.  */
9005 char yywrap ();
9006 int
9007 main ()
9008 {
9009 yywrap ();
9010  ;
9011  return 0;
9012 }
9013 _ACEOF
9014 rm -f conftest.$ac_objext conftest$ac_exeext
9015 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9016  (eval $ac_link) 2>conftest.er1
9017  ac_status=$?
9018  grep -v '^ *+' conftest.er1 >conftest.err
9019  rm -f conftest.er1
9020  cat conftest.err >&5
9021  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022  (exit $ac_status); } &&
9023         { ac_try='test -z "$ac_c_werror_flag"
9024                         || test ! -s conftest.err'
9025  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9026  (eval $ac_try) 2>&5
9027  ac_status=$?
9028  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9029  (exit $ac_status); }; } &&
9030         { ac_try='test -s conftest$ac_exeext'
9031  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9032  (eval $ac_try) 2>&5
9033  ac_status=$?
9034  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9035  (exit $ac_status); }; }; then
9036  ac_cv_lib_l_yywrap=yes
9037 else
9038  echo "$as_me: failed program was:" >&5
9039 sed 's/^/| /' conftest.$ac_ext >&5
12973  
12974 < ac_cv_lib_l_yywrap=no
12975 < fi
12976 < rm -f conftest.err conftest.$ac_objext \
9044 <      conftest$ac_exeext conftest.$ac_ext
9045 < LIBS=$ac_check_lib_save_LIBS
9046 < fi
9047 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9048 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9049 < if test $ac_cv_lib_l_yywrap = yes; then
9050 <  LEXLIB="-ll"
9051 < fi
9052 <
9053 < fi
9054 <
9055 < fi
9056 <
9057 < if test "x$LEX" != "x:"; then
9058 <  echo "$as_me:$LINENO: checking lex output file root" >&5
9059 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9060 < if test "${ac_cv_prog_lex_root+set}" = set; then
12974 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12975 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12976 > if test "${ac_guessed_cxxflags+set}" = set; then
12977    echo $ECHO_N "(cached) $ECHO_C" >&6
12978   else
12979 <  # The minimal lex program is just a single line: %%.  But some broken lexes
12980 < # (Solaris, I think it was) want two %% lines, so accommodate them.
12981 < cat >conftest.l <<_ACEOF
9066 < %%
9067 < %%
9068 < _ACEOF
9069 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9070 <  (eval $LEX conftest.l) 2>&5
9071 <  ac_status=$?
9072 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073 <  (exit $ac_status); }
9074 < if test -f lex.yy.c; then
9075 <  ac_cv_prog_lex_root=lex.yy
9076 < elif test -f lexyy.c; then
9077 <  ac_cv_prog_lex_root=lexyy
12979 >  echo 'void f(){}' > conftest.cpp
12980 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12981 >        ac_guessed_cxxflags=yes
12982   else
12983 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9080 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9081 <   { (exit 1); exit 1; }; }
12983 >        ac_guessed_cxxflags=no
12984   fi
12985 < fi
9084 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9085 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9086 < rm -f conftest.l
9087 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12985 > rm -f conftest*
12986  
9089 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9090 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9091 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9092  echo $ECHO_N "(cached) $ECHO_C" >&6
9093 else
9094  # POSIX says lex can declare yytext either as a pointer or an array; the
9095 # default is implementation-dependent. Figure out which it is, since
9096 # not all implementations provide the %pointer and %array declarations.
9097 ac_cv_prog_lex_yytext_pointer=no
9098 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9099 ac_save_LIBS=$LIBS
9100 LIBS="$LIBS $LEXLIB"
9101 cat >conftest.$ac_ext <<_ACEOF
9102 `cat $LEX_OUTPUT_ROOT.c`
9103 _ACEOF
9104 rm -f conftest.$ac_objext conftest$ac_exeext
9105 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9106  (eval $ac_link) 2>conftest.er1
9107  ac_status=$?
9108  grep -v '^ *+' conftest.er1 >conftest.err
9109  rm -f conftest.er1
9110  cat conftest.err >&5
9111  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9112  (exit $ac_status); } &&
9113         { ac_try='test -z "$ac_c_werror_flag"
9114                         || test ! -s conftest.err'
9115  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9116  (eval $ac_try) 2>&5
9117  ac_status=$?
9118  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9119  (exit $ac_status); }; } &&
9120         { ac_try='test -s conftest$ac_exeext'
9121  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9122  (eval $ac_try) 2>&5
9123  ac_status=$?
9124  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9125  (exit $ac_status); }; }; then
9126  ac_cv_prog_lex_yytext_pointer=yes
9127 else
9128  echo "$as_me: failed program was:" >&5
9129 sed 's/^/| /' conftest.$ac_ext >&5
9130
12987   fi
12988 < rm -f conftest.err conftest.$ac_objext \
12989 <      conftest$ac_exeext conftest.$ac_ext
12990 < LIBS=$ac_save_LIBS
12991 < rm -f "${LEX_OUTPUT_ROOT}.c"
12988 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12989 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12990 > if test "$ac_guessed_cxxflags" = yes; then
12991 >        :
12992  
12993 < fi
12994 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9139 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9140 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
9141 <
9142 < cat >>confdefs.h <<\_ACEOF
9143 < #define YYTEXT_POINTER 1
9144 < _ACEOF
9145 <
9146 < fi
12993 > else
12994 >        :
12995  
12996 < fi
12996 >        echo ""
12997 >        echo "**********************************************************"
12998 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12999 >        echo "* your compiler.                                         *"
13000 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13001 >        echo "**********************************************************"
13002 >        echo ""
13003 >        CXXFLAGS=""
13004  
9150   # Extract the first word of "perl", so it can be a program name with args.
9151 set dummy perl; ac_word=$2
9152 echo "$as_me:$LINENO: checking for $ac_word" >&5
9153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9154 if test "${ac_cv_path_PERLINTERP+set}" = set; then
9155  echo $ECHO_N "(cached) $ECHO_C" >&6
9156 else
9157  case $PERLINTERP in
9158  [\\/]* | ?:[\\/]*)
9159  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9160  ;;
9161  *)
9162  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9163 for as_dir in $PATH
9164 do
9165  IFS=$as_save_IFS
9166  test -z "$as_dir" && as_dir=.
9167  for ac_exec_ext in '' $ac_executable_extensions; do
9168  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9169    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9170    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9171    break 2
9172  fi
9173 done
9174 done
9175
9176  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9177  ;;
9178 esac
13005   fi
9180 PERLINTERP=$ac_cv_path_PERLINTERP
13006  
9182 if test -n "$PERLINTERP"; then
9183  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9184 echo "${ECHO_T}$PERLINTERP" >&6
9185 else
9186  echo "$as_me:$LINENO: result: no" >&5
9187 echo "${ECHO_T}no" >&6
9188 fi
13007  
9190   ac_cv_path_perlinterp="$PERLINTERP"
9191   _sHpB='#!'
9192
9193
9194 # Check whether --with-perl-shebang or --without-perl-shebang was given.
9195 if test "${with_perl_shebang+set}" = set; then
9196  withval="$with_perl_shebang"
9197  opt_perl_shebang="$withval"
9198 else
9199                opt_perl_shebang="not_set"
9200 fi;
9201   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9202 echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9203 if test "${ax_cv_opt_perl_shebang+set}" = set; then
9204  echo $ECHO_N "(cached) $ECHO_C" >&6
9205 else
9206   case "$opt_perl_shebang" in
9207                      not_set  ) ax_cv_opt_perl_shebang=''
9208                               ;;
9209                         *     )
9210        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9211                    esac
9212
13008   fi
9214 echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9215 echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9216   if test "A$ax_cv_opt_perl_shebang" != "A"
9217     then
9218       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9219       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9220              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9221 echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
13009  
13010 < # Automatic detection of sharpbang formula starts here
9224 <     else
9225 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
9226 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9227 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9228 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9229 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9230 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9231 < else
9232 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9233 <        if test "x$_somian_kspb_perl" == x
9234 <          then _somian_ksbp_warn_empty='durnit'
9235 <          else
9236 <          case "A$_somian_kspb_perl" in
9237 <                 A#!*perl* )
9238 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9239 <                        ;;
9240 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9241 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9242 <          esac
9243 <        fi
9244 <
9245 < fi
9246 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
9247 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
9248 < # The above prints Checking ... result message to user.
9249 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9250 <
9251 <    if test A${_somian_ksbp_warn_empty+set} == Aset
9252 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9253 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9254 <    fi
9255 < # Inform user after printing result value
9256 <    if test A${_somian_ksbp_warn_defau+set} == Aset
9257 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9258 < echo "$as_me: Maybe Not good -" >&6;}
9259 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9260 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9261 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
9262 < echo "$as_me: OK Good result - " >&6;}
9263 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9264 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9265 <    fi
9266 <  fi
9267 <
9268 < # Extract the first word of "ar", so it can be a program name with args.
9269 < set dummy ar; ac_word=$2
9270 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9271 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9272 < if test "${ac_cv_prog_AR+set}" = set; then
9273 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9274 < else
9275 <  if test -n "$AR"; then
9276 <  ac_cv_prog_AR="$AR" # Let the user override the test.
9277 < else
9278 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9279 < for as_dir in $PATH
9280 < do
9281 <  IFS=$as_save_IFS
9282 <  test -z "$as_dir" && as_dir=.
9283 <  for ac_exec_ext in '' $ac_executable_extensions; do
9284 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9285 <    ac_cv_prog_AR="ar"
9286 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9287 <    break 2
9288 <  fi
9289 < done
9290 < done
9291 <
9292 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
9293 < fi
9294 < fi
9295 < AR=$ac_cv_prog_AR
9296 < if test -n "$AR"; then
9297 <  echo "$as_me:$LINENO: result: $AR" >&5
9298 < echo "${ECHO_T}$AR" >&6
9299 < else
9300 <  echo "$as_me:$LINENO: result: no" >&5
9301 < echo "${ECHO_T}no" >&6
9302 < fi
9303 <
9304 < if test "$AR" = "NONE"; then
9305 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9306 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9307 <   { (exit 1); exit 1; }; }
9308 <  cat >confcache <<\_ACEOF
9309 < # This file is a shell script that caches the results of configure
9310 < # tests run on this system so they can be shared between configure
9311 < # scripts and configure runs, see configure's option --config-cache.
9312 < # It is not useful on other systems.  If it contains results you don't
9313 < # want to keep, you may remove or edit it.
9314 < #
9315 < # config.status only pays attention to the cache file if you give it
9316 < # the --recheck option to rerun configure.
9317 < #
9318 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
9319 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
9320 < # following values.
9321 <
9322 < _ACEOF
9323 <
9324 < # The following way of writing the cache mishandles newlines in values,
9325 < # but we know of no workaround that is simple, portable, and efficient.
9326 < # So, don't put newlines in cache variables' values.
9327 < # Ultrix sh set writes to stderr and can't be redirected directly,
9328 < # and sets the high bit in the cache file unless we assign to the vars.
9329 < {
9330 <  (set) 2>&1 |
9331 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9332 <    *ac_space=\ *)
9333 <      # `set' does not quote correctly, so add quotes (double-quote
9334 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
9335 <      sed -n \
9336 <        "s/'/'\\\\''/g;
9337 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9338 <      ;;
9339 <    *)
9340 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
9341 <      sed -n \
9342 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9343 <      ;;
9344 <    esac;
9345 < } |
9346 <  sed '
9347 <     t clear
9348 <     : clear
9349 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9350 <     t end
9351 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9352 <     : end' >>confcache
9353 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
9354 <  if test -w $cache_file; then
9355 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9356 <    cat confcache >$cache_file
9357 <  else
9358 <    echo "not updating unwritable cache $cache_file"
9359 <  fi
9360 < fi
9361 < rm -f confcache
9362 <  exit 1
9363 < fi
9364 <
9365 < # Extract the first word of "ps", so it can be a program name with args.
9366 < set dummy ps; ac_word=$2
9367 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9368 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9369 < if test "${ac_cv_path_PS+set}" = set; then
9370 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9371 < else
9372 <  case $PS in
9373 <  [\\/]* | ?:[\\/]*)
9374 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
9375 <  ;;
9376 <  *)
9377 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9378 < for as_dir in $PATH
9379 < do
9380 <  IFS=$as_save_IFS
9381 <  test -z "$as_dir" && as_dir=.
9382 <  for ac_exec_ext in '' $ac_executable_extensions; do
9383 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9384 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9385 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9386 <    break 2
9387 <  fi
9388 < done
9389 < done
9390 <
9391 <  ;;
13010 >     ;;
13011   esac
9393 fi
9394 PS=$ac_cv_path_PS
13012  
9396 if test -n "$PS"; then
9397  echo "$as_me:$LINENO: result: $PS" >&5
9398 echo "${ECHO_T}$PS" >&6
9399 else
9400  echo "$as_me:$LINENO: result: no" >&5
9401 echo "${ECHO_T}no" >&6
9402 fi
13013  
9404 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9405 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9406 if test "${ac_cv_prog_ps_syntax+set}" = set; then
9407  echo $ECHO_N "(cached) $ECHO_C" >&6
9408 else
9409
9410        if $PS ax -o rss > /dev/null 2>&1; then
9411                ac_cv_prog_ps_ax=yes
9412        else
9413                ac_cv_prog_ps_ax=no
9414        fi
9415        if $PS -ef -o rss > /dev/null 2>&1; then
9416                ac_cv_prog_ps_ef=yes
9417        else
9418                ac_cv_prog_ps_ef=no
9419        fi
9420        if test "$ac_cv_prog_ps_ax" = yes; then
9421                ac_cv_prog_ps_syntax=BSD
9422        else
9423                if test "$ac_cv_prog_ps_ef" = yes; then
9424                        ac_cv_prog_ps_syntax=POSIX
9425                else
9426                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9427 echo "$as_me: error: Could not determine ps syntax" >&2;}
9428   { (exit 1); exit 1; }; }
9429                fi
9430        fi
9431
9432 fi
9433 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9434 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9435
9436
9437 cat >>confdefs.h <<_ACEOF
9438 #define PSCOMMAND $PS
9439 _ACEOF
9440
9441
13014   cat >>confdefs.h <<\_ACEOF
13015   #define OBAPI
13016   _ACEOF
13017  
9446
9447
9448 if test "$ac_cv_prog_ps_syntax" = BSD; then
9449
9450 cat >>confdefs.h <<\_ACEOF
9451 #define PSTYPE_IS_BSD 1
9452 _ACEOF
9453
9454 else
9455   if test "$ac_cv_prog_ps_syntax" = POSIX; then
9456
9457 cat >>confdefs.h <<\_ACEOF
9458 #define PSTYPE_IS_POSIX 1
9459 _ACEOF
13018  
9461   else
9462       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9463 echo "$as_me: error: Unknown ps syntax type!" >&2;}
9464   { (exit 1); exit 1; }; }
9465   fi
9466 fi
13019  
13020  
13021   # Check whether --with-mpi or --without-mpi was given.
# Line 9521 | Line 13073 | rm -f conftest*
13073   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13074   have_mpif_h=0
13075   rm -f conftest*
13076 < cat >conftest.f90 <<EOF
13076 > cat >conftest.$ac_ext <<EOF
13077   program main
13078     include 'mpif.h'
13079   end
13080   EOF
13081 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13081 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13082          echo "$as_me:$LINENO: result: yes" >&5
13083   echo "${ECHO_T}yes" >&6
13084          MPI_F90_INC="$MPI_INC_DIR"
# Line 9580 | Line 13132 | char MPI_Init ();
13132   /* We use char because int might match the return type of a gcc2
13133     builtin and then its argument prototype would still apply.  */
13134   char MPI_Init ();
13135 + #ifdef FC_DUMMY_MAIN
13136 + #ifndef FC_DUMMY_MAIN_EQ_F77
13137 + #  ifdef __cplusplus
13138 +     extern "C"
13139 + #  endif
13140 +   int FC_DUMMY_MAIN() { return 1; }
13141 + #endif
13142 + #endif
13143   int
13144   main ()
13145   {
# Line 9650 | Line 13210 | char MPI_Init ();
13210   /* We use char because int might match the return type of a gcc2
13211     builtin and then its argument prototype would still apply.  */
13212   char MPI_Init ();
13213 + #ifdef FC_DUMMY_MAIN
13214 + #ifndef FC_DUMMY_MAIN_EQ_F77
13215 + #  ifdef __cplusplus
13216 +     extern "C"
13217 + #  endif
13218 +   int FC_DUMMY_MAIN() { return 1; }
13219 + #endif
13220 + #endif
13221   int
13222   main ()
13223   {
# Line 9721 | Line 13289 | char MPI_Init ();
13289   /* We use char because int might match the return type of a gcc2
13290     builtin and then its argument prototype would still apply.  */
13291   char MPI_Init ();
13292 + #ifdef FC_DUMMY_MAIN
13293 + #ifndef FC_DUMMY_MAIN_EQ_F77
13294 + #  ifdef __cplusplus
13295 +     extern "C"
13296 + #  endif
13297 +   int FC_DUMMY_MAIN() { return 1; }
13298 + #endif
13299 + #endif
13300   int
13301   main ()
13302   {
# Line 9792 | Line 13368 | char MPI_Init ();
13368   /* We use char because int might match the return type of a gcc2
13369     builtin and then its argument prototype would still apply.  */
13370   char MPI_Init ();
13371 + #ifdef FC_DUMMY_MAIN
13372 + #ifndef FC_DUMMY_MAIN_EQ_F77
13373 + #  ifdef __cplusplus
13374 +     extern "C"
13375 + #  endif
13376 +   int FC_DUMMY_MAIN() { return 1; }
13377 + #endif
13378 + #endif
13379   int
13380   main ()
13381   {
# Line 9836 | Line 13420 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
13420   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13421   echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13422   if test $ac_cv_lib_mpich_MPI_Init = yes; then
13423 <  MPI_LIB="-lmpich -lpmpich"
13423 >  MPI_LIB="-lpmpich -lmpich"
13424   fi
13425  
13426   fi
# Line 9864 | Line 13448 | char MPI_Init ();
13448   /* We use char because int might match the return type of a gcc2
13449     builtin and then its argument prototype would still apply.  */
13450   char MPI_Init ();
13451 + #ifdef FC_DUMMY_MAIN
13452 + #ifndef FC_DUMMY_MAIN_EQ_F77
13453 + #  ifdef __cplusplus
13454 +     extern "C"
13455 + #  endif
13456 +   int FC_DUMMY_MAIN() { return 1; }
13457 + #endif
13458 + #endif
13459   int
13460   main ()
13461   {
# Line 9940 | Line 13532 | fi
13532  
13533  
13534  
9943
13535   USE_CGAL=no
13536   cgal_makefile=auto
13537  
# Line 10282 | Line 13873 | cat >>conftest.$ac_ext <<_ACEOF
13873   cat >>conftest.$ac_ext <<_ACEOF
13874   /* end confdefs.h.  */
13875   #include <CGAL/Cartesian.h>
13876 + #ifdef FC_DUMMY_MAIN
13877 + #ifndef FC_DUMMY_MAIN_EQ_F77
13878 + #  ifdef __cplusplus
13879 +     extern "C"
13880 + #  endif
13881 +   int FC_DUMMY_MAIN() { return 1; }
13882 + #endif
13883 + #endif
13884   int
13885   main ()
13886   {
# Line 10387 | Line 13986 | CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13986  
13987  
13988  
10390
13989   # Check whether --enable-doxygen or --disable-doxygen was given.
13990   if test "${enable_doxygen+set}" = set; then
13991    enableval="$enable_doxygen"
# Line 10529 | Line 14127 | fi
14127  
14128  
14129  
10532 OBJEXT=".$OBJEXT"
14130  
10534 OOPSE=oopse
14131  
10536 if test "x${prefix}" = "xNONE"
10537 then
10538  OOPSE_HOME=${ac_default_prefix}/oopse
10539 else
10540  OOPSE_HOME=${prefix}/oopse
10541 fi
10542 # Check whether --enable-oopse-home or --disable-oopse-home was given.
10543 if test "${enable_oopse_home+set}" = set; then
10544  enableval="$enable_oopse_home"
10545  OOPSE_HOME="${enableval}"
10546 fi;
14132  
10548 case "x$INSTALL" in
10549   x/*) ;;
10550   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10551 esac
14133  
10553 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14134  
10555 CFLAGS=${CFLAGS-""}
10556 CXXFLAGS=${CXXFLAGS-""}
10557 CPPFLAGS=${CPPFLAGS-""}
10558 FFLAGS=${FFLAGS-""}
10559 F90FLAGS=${F90FLAGS-""}
10560 LDFLAGS=${LDFLAGS-""}
10561 DEBUG=${DEBUG-"-g"}
14135  
10563 case $debug in
10564  1)
10565     FFLAGS="$DEBUG $FFLAGS"
10566     F90FLAGS="$DEBUG $F90FLAGS"
10567     ;;
10568  *)
10569     ;;
10570 esac
10571
10572
10573
10574
10575
10576
10577
10578
10579
10580
10581
10582
14136  
14137  
14138  
14139  
14140  
10588
10589          ac_config_headers="$ac_config_headers src/config.h"
14141  
14142                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14143  
# Line 10953 | Line 14504 | cat >&5 <<_CSEOF
14504   } >&5
14505   cat >&5 <<_CSEOF
14506  
14507 < This file was extended by OOPSE $as_me 2.0, which was
14507 > This file was extended by OOPSE $as_me 3.0, which was
14508   generated by GNU Autoconf 2.59.  Invocation command line was
14509  
14510    CONFIG_FILES    = $CONFIG_FILES
# Line 11016 | Line 14567 | ac_cs_version="\\
14567  
14568   cat >>$CONFIG_STATUS <<_ACEOF
14569   ac_cs_version="\\
14570 < OOPSE config.status 2.0
14570 > OOPSE config.status 3.0
14571   configured by $0, generated by GNU Autoconf 2.59,
14572    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14573  
# Line 11210 | Line 14761 | s,@LIBS@,$LIBS,;t t
14761   s,@ECHO_N@,$ECHO_N,;t t
14762   s,@ECHO_T@,$ECHO_T,;t t
14763   s,@LIBS@,$LIBS,;t t
11213 s,@PROGNAME@,$PROGNAME,;t t
11214 s,@debug@,$debug,;t t
14764   s,@build@,$build,;t t
14765   s,@build_cpu@,$build_cpu,;t t
14766   s,@build_vendor@,$build_vendor,;t t
# Line 11220 | Line 14769 | s,@host_os@,$host_os,;t t
14769   s,@host_cpu@,$host_cpu,;t t
14770   s,@host_vendor@,$host_vendor,;t t
14771   s,@host_os@,$host_os,;t t
14772 < s,@CC@,$CC,;t t
14773 < s,@CFLAGS@,$CFLAGS,;t t
14772 > s,@PROGNAME@,$PROGNAME,;t t
14773 > s,@debug@,$debug,;t t
14774 > s,@CXX@,$CXX,;t t
14775 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14776   s,@LDFLAGS@,$LDFLAGS,;t t
14777   s,@CPPFLAGS@,$CPPFLAGS,;t t
14778 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14778 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14779   s,@EXEEXT@,$EXEEXT,;t t
14780   s,@OBJEXT@,$OBJEXT,;t t
14781 < s,@CXX@,$CXX,;t t
14782 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14783 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14781 > s,@CC@,$CC,;t t
14782 > s,@CFLAGS@,$CFLAGS,;t t
14783 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14784 > s,@FC@,$FC,;t t
14785 > s,@FCFLAGS@,$FCFLAGS,;t t
14786 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14787   s,@CPP@,$CPP,;t t
14788   s,@EGREP@,$EGREP,;t t
11235 s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11236 s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11237 s,@F90@,$F90,;t t
11238 s,@F90FLAGS@,$F90FLAGS,;t t
11239 s,@ac_ct_F90@,$ac_ct_F90,;t t
11240 s,@PREPFLAG@,$PREPFLAG,;t t
11241 s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11242 s,@F90LIBS@,$F90LIBS,;t t
11243 s,@F90_FUNC@,$F90_FUNC,;t t
11244 s,@F90_FUNC_@,$F90_FUNC_,;t t
11245 s,@MOD@,$MOD,;t t
11246 s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11247 s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11248 s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11249 s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
11250 s,@CXXCPP@,$CXXCPP,;t t
11251 s,@LIBOBJS@,$LIBOBJS,;t t
11252 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11253 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11254 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14789   s,@LN_S@,$LN_S,;t t
14790   s,@SET_MAKE@,$SET_MAKE,;t t
14791   s,@RANLIB@,$RANLIB,;t t
14792   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11259 s,@YACC@,$YACC,;t t
11260 s,@LEX@,$LEX,;t t
11261 s,@LEXLIB@,$LEXLIB,;t t
11262 s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14793   s,@PERLINTERP@,$PERLINTERP,;t t
14794   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14795 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14796 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14797 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14798   s,@AR@,$AR,;t t
14799   s,@PS@,$PS,;t t
14800 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14801 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14802 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14803 + s,@FCLIBS@,$FCLIBS,;t t
14804 + s,@FC_FUNC@,$FC_FUNC,;t t
14805 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14806 + s,@MOD@,$MOD,;t t
14807 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14808 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14809 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14810 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14811 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14812 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14813 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14814 + s,@LIBOBJS@,$LIBOBJS,;t t
14815 + s,@POW_LIB@,$POW_LIB,;t t
14816 + s,@CXXCPP@,$CXXCPP,;t t
14817 + s,@__func__@,$__func__,;t t
14818   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14819   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14820   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11288 | Line 14839 | s,@SUBDIRS@,$SUBDIRS,;t t
14839   s,@OOPSE@,$OOPSE,;t t
14840   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14841   s,@SUBDIRS@,$SUBDIRS,;t t
11291 s,@FFLAGS@,$FFLAGS,;t t
14842   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14843   CEOF
14844  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines