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

Comparing trunk/OOPSE-3.0/configure (file contents):
Revision 2453 by gezelter, Thu Nov 17 20:39:59 2005 UTC vs.
Revision 2752 by gezelter, Tue May 16 02:06:37 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_VERSION='2.0'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX 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 CPP EGREP CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 – ac_env_CC_set=${CC+set}
757 – ac_env_CC_value=$CC
758 – ac_cv_env_CC_set=${CC+set}
759 – ac_cv_env_CC_value=$CC
760 – ac_env_CFLAGS_set=${CFLAGS+set}
761 – ac_env_CFLAGS_value=$CFLAGS
762 – ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 – ac_cv_env_CFLAGS_value=$CFLAGS
764 – ac_env_LDFLAGS_set=${LDFLAGS+set}
765 – ac_env_LDFLAGS_value=$LDFLAGS
766 – ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 – ac_cv_env_LDFLAGS_value=$LDFLAGS
768 – ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 – ac_env_CPPFLAGS_value=$CPPFLAGS
770 – ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 – ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_env_F90_set=${F90+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_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877 –  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884    --with-zlib=DIR root directory path of zlib installation defaults to
885                      /usr/local or /usr if not found in /usr/local
886    --without-zlib to disable zlib usage completely
887 <  --with-perl-shebang     override what perl thinks is the way for the kernel
886 <                          to start it (seldom needed)
887 >  --without-fftw          if you turn this off you cannot compute undulation spectra
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889    --with-cgal-makefile=FILE  CGAL makefile that should be used
890  
891   Some influential environment variables:
892 <  CC          C compiler command
893 <  CFLAGS      C compiler flags
892 >  CXX         C++ compiler command
893 >  CXXFLAGS    C++ compiler flags
894    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895                nonstandard directory <lib dir>
896    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897                headers in a nonstandard directory <include dir>
898 <  CXX         C++ compiler command
899 <  CXXFLAGS    C++ compiler flags
900 <  F90         Fortran 90 compiler command
901 <  F90FLAGS    Fortran 90 compiler flags
898 >  CC          C compiler command
899 >  CFLAGS      C compiler flags
900 >  FC          Fortran compiler command
901 >  FCFLAGS     Fortran compiler flags
902    CPP         C preprocessor
903    CXXCPP      C++ preprocessor
904  
# Line 1000 | Line 1001 | OOPSE configure 2.0
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1004 > OOPSE configure 3.0
1005   generated by GNU Autoconf 2.59
1006  
1007   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1015 | It was created by OOPSE $as_me 2.0, which was
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1018 > It was created by OOPSE $as_me 3.0, which was
1019   generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
# Line 1376 | Line 1377 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1378  
1379  
1380 < # This file is part of Autoconf.                       -*- Autoconf -*-
1380 < # Programming languages support.
1381 < # Copyright 2000, 2001
1382 < # Free Software Foundation, Inc.
1383 < #
1384 < # This program is free software; you can redistribute it and/or modify
1385 < # it under the terms of the GNU General Public License as published by
1386 < # the Free Software Foundation; either version 2, or (at your option)
1387 < # any later version.
1388 < #
1389 < # This program is distributed in the hope that it will be useful,
1390 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 < # GNU General Public License for more details.
1393 < #
1394 < # You should have received a copy of the GNU General Public License
1395 < # along with this program; if not, write to the Free Software
1396 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 < # 02111-1307, USA.
1398 < #
1399 < # As a special exception, the Free Software Foundation gives unlimited
1400 < # permission to copy, distribute and modify the configure scripts that
1401 < # are the output of Autoconf.  You need not follow the terms of the GNU
1402 < # General Public License when using or distributing such scripts, even
1403 < # though portions of the text of Autoconf appear in them.  The GNU
1404 < # General Public License (GPL) does govern all other use of the material
1405 < # that constitutes the Autoconf program.
1406 < #
1407 < # Certain portions of the Autoconf source text are designed to be copied
1408 < # (in certain cases, depending on the input) into the output of
1409 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 < # source text consists of comments plus executable code that decides which
1411 < # of the data portions to output in any given case.  We call these
1412 < # comments and executable code the "non-data" portions.  Autoconf never
1413 < # copies any of the non-data portions into its output.
1414 < #
1415 < # This special exception to the GPL applies to versions of Autoconf
1416 < # released by the Free Software Foundation.  When you make and
1417 < # distribute a modified version of Autoconf, you may extend this special
1418 < # exception to the GPL to apply to your modified version as well, *unless*
1419 < # your modified version has the potential to copy into its output some
1420 < # of the text that was the non-data portion of the version that you started
1421 < # with.  (In other words, unless your change moves or copies text from
1422 < # the non-data portions to the data portions.)  If your modification has
1423 < # such potential, you must delete any notice of this special exception
1424 < # to the GPL from your modified version.
1425 < #
1426 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 < # many others).
1428 <
1429 <
1430 < # Table of Contents:
1431 < #
1432 < # 1. Language selection
1433 < #    and routines to produce programs in a given language.
1434 < #  a. Fortran 77 (to be moved from aclang.m4)
1435 < #  b. Fortran 90
1436 < #  c. Fortran 95
1437 < #
1438 < # 2. Producing programs in a given language.
1439 < #  a. Fortran 77 (to be moved from aclang.m4)
1440 < #  b. Fortran 90
1441 < #  c. Fortran 95
1442 < #
1443 < # 3. Looking for a compiler
1444 < #    And possibly the associated preprocessor.
1445 < #  a. Fortran 77 (to be moved from aclang.m4)
1446 < #  b. Fortran 90
1447 < #  c. Fortran 95
1448 < #
1449 < # 4. Compilers' characteristics.
1450 < #  a. Fortran 77 (to be moved from aclang.m4)
1451 < #  b. Fortran 90
1452 < #  c. Fortran 95
1453 <
1454 < # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 < # ---------------------------------------------------------------------------
1456 < #
1457 < # Processing the elements of a list is tedious in shell programming,
1458 < # as lists tend to be implemented as space delimited strings.
1459 < #
1460 < # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 < # if ELEMENT is a member of LIST, otherwise it executes
1462 < # ACTION-IF-NOT-FOUND.
1463 < # _AC_LIST_MEMBER_IF
1464 <
1465 <
1466 <
1467 < # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 < # -------------------------------------------------
1469 < #
1470 < # Specifying options to the compiler (whether it be the C, C++ or
1471 < # Fortran 77 compiler) that are meant for the linker is compiler
1472 < # dependent.  This macro lets you give options to the compiler that
1473 < # are meant for the linker in a portable, compiler-independent way.
1474 < #
1475 < # This macro take two arguments, a list of linker options that the
1476 < # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 < # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 < # appended to the shell variable in a compiler-dependent way.
1479 < #
1480 < # For example, if the selected language is C, then this:
1481 < #
1482 < #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 < #
1484 < # will expand into this if the selected C compiler is gcc:
1485 < #
1486 < #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 < #
1488 < # otherwise, it will expand into this:
1489 < #
1490 < #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 < #
1492 < # You are encouraged to add support for compilers that this macro
1493 < # doesn't currently support.
1494 < # FIXME: Get rid of this macro.
1495 < # _AC_LINKER_OPTION
1496 <
1497 <
1498 <
1499 < ## ----------------------- ##
1500 < ## 1. Language selection.  ##
1501 < ## ----------------------- ##
1502 <
1503 < # ----------------------------- #
1504 < # 1b. The Fortran 90 language.  #
1505 < # ----------------------------- #
1506 <
1507 < # AC_LANG(Fortran 90)
1508 < # -------------------
1509 <
1510 <
1511 <
1512 < # _AC_LANG_ABBREV(Fortran 90)
1513 < # ---------------------------
1514 <
1515 <
1516 <
1517 < # ----------------------------- #
1518 < # 1c. The Fortran 95 language.  #
1519 < # ----------------------------- #
1520 <
1521 < # AC_LANG(Fortran 95)
1522 < # -------------------
1523 <
1524 <
1525 <
1526 < # _AC_LANG_ABBREV(Fortran 95)
1527 < # ---------------------------
1528 <
1529 <
1530 <
1531 < ## ---------------------- ##
1532 < ## 2.Producing programs.  ##
1533 < ## ---------------------- ##
1534 <
1535 < # ------------------------ #
1536 < # 2b. Fortran 90 sources.  #
1537 < # ------------------------ #
1538 <
1539 < # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 < # --------------------------------
1541 <
1542 <
1543 <
1544 < # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 < # -----------------------------------------------
1546 <
1547 <
1548 < # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 < # --------------------------------------------
1550 <
1551 <
1552 <
1553 < # ------------------------ #
1554 < # 2c. Fortran 95 sources.  #
1555 < # ------------------------ #
1556 <
1557 < # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 < # --------------------------------
1559 <
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1561 – # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 – # -----------------------------------------------
1382  
1383  
1565 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 – # --------------------------------------------
1384  
1385  
1386  
1570 – ## -------------------------------------------- ##
1571 – ## 3. Looking for Compilers and Preprocessors.  ##
1572 – ## -------------------------------------------- ##
1387  
1574 – # ----------------------------- #
1575 – # 3b. The Fortran 90 compiler.  #
1576 – # ----------------------------- #
1388  
1389  
1579 – # AC_LANG_PREPROC(Fortran 90)
1580 – # ---------------------------
1581 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1390  
1391  
1392  
1585 – # AC_LANG_COMPILER(Fortran 90)
1586 – # ----------------------------
1587 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 – # AC_REQUIRE'able.
1393  
1394  
1395  
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
1396  
1397  
1609 – # ----------------------------- #
1610 – # 3c. The Fortran 95 compiler.  #
1611 – # ----------------------------- #
1398  
1399  
1614 – # AC_LANG_PREPROC(Fortran 95)
1615 – # ---------------------------
1616 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1400  
1401  
1402  
1620 – # AC_LANG_COMPILER(Fortran 95)
1621 – # ----------------------------
1622 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 – # AC_REQUIRE'able.
1403  
1404  
1405  
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
1406  
1407  
1641 – ## ------------------------------- ##
1642 – ## 4. Compilers' characteristics.  ##
1643 – ## ------------------------------- ##
1408  
1409  
1646 – # ---------------------------------------- #
1647 – # 4b. Fortan 90 compiler characteristics.  #
1648 – # ---------------------------------------- #
1410  
1411  
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
1412  
1413  
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
1414  
1415  
1672 – # AC_F90_LIBRARY_LDFLAGS
1673 – # ----------------------
1674 – #
1675 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 – # intrinsic and run-time libraries that are required to successfully
1677 – # link a Fortran 90 program or shared library.  The output variable
1678 – # F90LIBS is set to these flags.
1679 – #
1680 – # This macro is intended to be used in those situations when it is
1681 – # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 – # program or shared library.
1683 – #
1684 – # For example, if object files from a C++ and Fortran 90 compiler must
1685 – # be linked together, then the C++ compiler/linker must be used for
1686 – # linking (since special C++-ish things need to happen at link time
1687 – # like calling global constructors, instantiating templates, enabling
1688 – # exception support, etc.).
1689 – #
1690 – # However, the Fortran 90 intrinsic and run-time libraries must be
1691 – # linked in as well, but the C++ compiler/linker doesn't know how to
1692 – # add these Fortran 90 libraries.  Hence, the macro
1693 – # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 – # libraries.
1695 – #
1696 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 – # AC_F90_LIBRARY_LDFLAGS
1416  
1417 + # ACX_CHECK_FFTW()
1418 + # ----------------
1419 + # This macro checks for fftw header files and libraries,
1420 + # including the possible prefixing with s or d to determine precision.
1421 + # Arg 1 is the fftw header/library name to check for, without
1422 + # prefix or anything else (e.g. rfftw_mpi for real MPI transforms)
1423 + # Arg 2 is the size of the real variable used.
1424  
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
1425  
1717 – # The replacement is empty.
1426  
1427  
1428  
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
1429  
1430  
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
1431  
1432  
1738 – # ---------------------------------------- #
1739 – # 4c. Fortan 95 compiler characteristics.  #
1740 – # ---------------------------------------- #
1433  
1434  
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
1435  
1753 –
1754 – # _AC_PROG_F95_V
1755 – # --------------
1436   #
1757 – # Determine the flag that causes the Fortran 95 compiler to print
1758 – # information of library and object files (normally -v)
1759 – # Needed for AC_F95_LIBRARY_FLAGS
1760 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 – # _AC_PROG_F95_V
1762 –
1763 –
1764 – # AC_F95_LIBRARY_LDFLAGS
1765 – # ----------------------
1437   #
1767 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 – # intrinsic and run-time libraries that are required to successfully
1769 – # link a Fortran 95 program or shared library.  The output variable
1770 – # F95LIBS is set to these flags.
1438   #
1772 – # This macro is intended to be used in those situations when it is
1773 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 – # program or shared library.
1775 – #
1776 – # For example, if object files from a C++ and Fortran 95 compiler must
1777 – # be linked together, then the C++ compiler/linker must be used for
1778 – # linking (since special C++-ish things need to happen at link time
1779 – # like calling global constructors, instantiating templates, enabling
1780 – # exception support, etc.).
1781 – #
1782 – # However, the Fortran 95 intrinsic and run-time libraries must be
1783 – # linked in as well, but the C++ compiler/linker doesn't know how to
1784 – # add these Fortran 95 libraries.  Hence, the macro
1785 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 – # libraries.
1787 – #
1788 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 – # AC_F95_LIBRARY_LDFLAGS
1439  
1440  
1792 – # _AC_F95_NAME_MANGLING
1793 – # ---------------------
1794 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 – #
1796 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 – # by commas:
1798 – #
1799 – # lower case / upper case:
1800 – #    case translation of the Fortan 95 symbols
1801 – # underscore / no underscore:
1802 – #    whether the compiler appends "_" to symbol names
1803 – # extra underscore / no extra underscore:
1804 – #    whether the compiler appends an extra "_" to symbol names already
1805 – #    containing at least one underscore
1806 – #
1807 – # _AC_F95_NAME_MANGLING
1808 –
1809 – # The replacement is empty.
1810 –
1811 –
1812 –
1813 – # AC_F95_WRAPPERS
1814 – # ---------------
1815 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816 – # properly mangle the names of C identifiers, and C identifiers with
1817 – # underscores, respectively, so that they match the name mangling
1818 – # scheme used by the Fortran 95 compiler.
1819 – # AC_F95_WRAPPERS
1820 –
1821 –
1822 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823 – # ------------------------------------
1824 – # For a Fortran subroutine of given NAME, define a shell variable
1825 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826 – # argument is not supplied, it defaults to NAME.
1827 – # AC_F95_FUNC
1828 –
1441   # AC_F90_MODULE_NAMES
1442   # -------------------
1443   #
# Line 1868 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480  
1481  
1482  
1871 –
1872 –
1873 –
1874 –
1875 –
1876 –
1877 –
1878 –
1879 –
1880 –
1881 –
1882 –
1883 –
1884 –
1885 –
1886 –
1887 –
1888 – #
1889 – #
1890 – #
1891 –
1892 –
1893 –
1894 –
1895 –
1896 –
1897 –
1898 –
1899 – # set program name
1900 – PROGNAME="oopse"
1901 –
1902 –
1903 – # there are two ways to do debugging.  One with the --enable-debug flag
1904 – # and one using the DEBUG environment variable
1905 –
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
1913 –
1914 – cat >>confdefs.h <<\_ACEOF
1915 – #define debug 1
1916 – _ACEOF
1917 –
1918 –  msg="$msg, debug mode"
1919 – fi
1920 –
1921 –
1483   # who am i
1484   # Make sure we can run config.sub.
1485   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1977 | Line 1538 | ac_ext=c
1538  
1539  
1540  
1541 < ac_ext=c
1542 < ac_cpp='$CPP $CPPFLAGS'
1543 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1544 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1545 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1541 > # set program name
1542 > PROGNAME="oopse"
1543 >
1544 >
1545 >
1546 >
1547 > OBJEXT=".$OBJEXT"
1548 >
1549 > OOPSE=oopse
1550 >
1551 > if test "x${prefix}" = "xNONE"
1552 > then
1553 >  OOPSE_HOME=${ac_default_prefix}/oopse
1554 > else
1555 >  OOPSE_HOME=${prefix}/oopse
1556 > fi
1557 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1558 > if test "${enable_oopse_home+set}" = set; then
1559 >  enableval="$enable_oopse_home"
1560 >  OOPSE_HOME="${enableval}"
1561 > fi;
1562 >
1563 > # there are two ways to do debugging.  One with the --enable-debug flag
1564 > # and one using the DEBUG environment variable
1565 >
1566 > debug=0
1567 > # Check whether --enable-debug or --disable-debug was given.
1568 > if test "${enable_debug+set}" = set; then
1569 >  enableval="$enable_debug"
1570 >  debug=1
1571 > fi;
1572 > if test "${DEBUG}"; then
1573 >
1574 > cat >>confdefs.h <<\_ACEOF
1575 > #define debug 1
1576 > _ACEOF
1577 >
1578 >  msg="$msg, debug mode"
1579 > fi
1580 >
1581 >
1582 > # Checks for programs.
1583 > ac_ext=cc
1584 > ac_cpp='$CXXCPP $CPPFLAGS'
1585 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1586 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1587 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1588   if test -n "$ac_tool_prefix"; then
1589 <  for ac_prog in icc xlc gcc cc
1589 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1590    do
1591      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1592   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1593   echo "$as_me:$LINENO: checking for $ac_word" >&5
1594   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1595 < if test "${ac_cv_prog_CC+set}" = set; then
1595 > if test "${ac_cv_prog_CXX+set}" = set; then
1596    echo $ECHO_N "(cached) $ECHO_C" >&6
1597   else
1598 <  if test -n "$CC"; then
1599 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1598 >  if test -n "$CXX"; then
1599 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1600   else
1601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1602   for as_dir in $PATH
# Line 2002 | Line 1605 | do
1605    test -z "$as_dir" && as_dir=.
1606    for ac_exec_ext in '' $ac_executable_extensions; do
1607    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1608 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1608 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1609      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1610      break 2
1611    fi
# Line 2011 | Line 1614 | CC=$ac_cv_prog_CC
1614  
1615   fi
1616   fi
1617 < CC=$ac_cv_prog_CC
1618 < if test -n "$CC"; then
1619 <  echo "$as_me:$LINENO: result: $CC" >&5
1620 < echo "${ECHO_T}$CC" >&6
1617 > CXX=$ac_cv_prog_CXX
1618 > if test -n "$CXX"; then
1619 >  echo "$as_me:$LINENO: result: $CXX" >&5
1620 > echo "${ECHO_T}$CXX" >&6
1621   else
1622    echo "$as_me:$LINENO: result: no" >&5
1623   echo "${ECHO_T}no" >&6
1624   fi
1625  
1626 <    test -n "$CC" && break
1626 >    test -n "$CXX" && break
1627    done
1628   fi
1629 < if test -z "$CC"; then
1630 <  ac_ct_CC=$CC
1631 <  for ac_prog in icc xlc gcc cc
1629 > if test -z "$CXX"; then
1630 >  ac_ct_CXX=$CXX
1631 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1632   do
1633    # Extract the first word of "$ac_prog", so it can be a program name with args.
1634   set dummy $ac_prog; ac_word=$2
1635   echo "$as_me:$LINENO: checking for $ac_word" >&5
1636   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1637 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1637 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1638    echo $ECHO_N "(cached) $ECHO_C" >&6
1639   else
1640 <  if test -n "$ac_ct_CC"; then
1641 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1640 >  if test -n "$ac_ct_CXX"; then
1641 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1642   else
1643   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644   for as_dir in $PATH
# Line 2044 | Line 1647 | do
1647    test -z "$as_dir" && as_dir=.
1648    for ac_exec_ext in '' $ac_executable_extensions; do
1649    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1650 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1650 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1651      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1652      break 2
1653    fi
# Line 2053 | Line 1656 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1656  
1657   fi
1658   fi
1659 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1660 < if test -n "$ac_ct_CC"; then
1661 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1662 < echo "${ECHO_T}$ac_ct_CC" >&6
1659 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1660 > if test -n "$ac_ct_CXX"; then
1661 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1662 > echo "${ECHO_T}$ac_ct_CXX" >&6
1663   else
1664    echo "$as_me:$LINENO: result: no" >&5
1665   echo "${ECHO_T}no" >&6
1666   fi
1667  
1668 <  test -n "$ac_ct_CC" && break
1668 >  test -n "$ac_ct_CXX" && break
1669   done
1670 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1671  
1672 <  CC=$ac_ct_CC
1672 >  CXX=$ac_ct_CXX
1673   fi
1674  
1675  
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 –
1676   # Provide some information about the compiler.
1677   echo "$as_me:$LINENO:" \
1678 <     "checking for C compiler version" >&5
1678 >     "checking for C++ compiler version" >&5
1679   ac_compiler=`set X $ac_compile; echo $2`
1680   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1681    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2115 | Line 1713 | echo "$as_me:$LINENO: checking for C compiler default
1713   # Try to create an executable without -o first, disregard a.out.
1714   # It will help us diagnose broken compilers, and finding out an intuition
1715   # of exeext.
1716 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1717 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1716 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1717 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1718   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1719   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1720    (eval $ac_link_default) 2>&5
# Line 2159 | Line 1757 | sed 's/^/| /' conftest.$ac_ext >&5
1757    echo "$as_me: failed program was:" >&5
1758   sed 's/^/| /' conftest.$ac_ext >&5
1759  
1760 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1760 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1761   See \`config.log' for more details." >&5
1762 < echo "$as_me: error: C compiler cannot create executables
1762 > echo "$as_me: error: C++ compiler cannot create executables
1763   See \`config.log' for more details." >&2;}
1764     { (exit 77); exit 77; }; }
1765   fi
# Line 2172 | Line 1770 | echo "$as_me:$LINENO: checking whether the C compiler
1770  
1771   # Check the compiler produces executables we can run.  If not, either
1772   # the compiler is broken, or we cross compile.
1773 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1774 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1773 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1774 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1775   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1776   # If not cross compiling, check that we can run a simple program.
1777   if test "$cross_compiling" != yes; then
# Line 2188 | Line 1786 | if test "$cross_compiling" != yes; then
1786      if test "$cross_compiling" = maybe; then
1787          cross_compiling=yes
1788      else
1789 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1789 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1790   If you meant to cross compile, use \`--host'.
1791   See \`config.log' for more details." >&5
1792 < echo "$as_me: error: cannot run C compiled programs.
1792 > echo "$as_me: error: cannot run C++ compiled programs.
1793   If you meant to cross compile, use \`--host'.
1794   See \`config.log' for more details." >&2;}
1795     { (exit 1); exit 1; }; }
# Line 2296 | Line 1894 | echo "$as_me:$LINENO: checking whether we are using th
1894   echo "${ECHO_T}$ac_cv_objext" >&6
1895   OBJEXT=$ac_cv_objext
1896   ac_objext=$OBJEXT
1897 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1898 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1899 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1897 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1898 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1899 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1900    echo $ECHO_N "(cached) $ECHO_C" >&6
1901   else
1902    cat >conftest.$ac_ext <<_ACEOF
# Line 2328 | Line 1926 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1926    cat conftest.err >&5
1927    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1928    (exit $ac_status); } &&
1929 <         { ac_try='test -z "$ac_c_werror_flag"
1929 >         { ac_try='test -z "$ac_cxx_werror_flag"
1930                           || test ! -s conftest.err'
1931    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1932    (eval $ac_try) 2>&5
# Line 2349 | Line 1947 | ac_cv_c_compiler_gnu=$ac_compiler_gnu
1947   ac_compiler_gnu=no
1948   fi
1949   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1950 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
1950 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1951  
1952   fi
1953 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1954 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1955 < GCC=`test $ac_compiler_gnu = yes && echo yes`
1956 < ac_test_CFLAGS=${CFLAGS+set}
1957 < ac_save_CFLAGS=$CFLAGS
1958 < CFLAGS="-g"
1959 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1960 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1961 < if test "${ac_cv_prog_cc_g+set}" = set; then
1953 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1954 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1955 > GXX=`test $ac_compiler_gnu = yes && echo yes`
1956 > ac_test_CXXFLAGS=${CXXFLAGS+set}
1957 > ac_save_CXXFLAGS=$CXXFLAGS
1958 > CXXFLAGS="-g"
1959 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1960 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1961 > if test "${ac_cv_prog_cxx_g+set}" = set; then
1962    echo $ECHO_N "(cached) $ECHO_C" >&6
1963   else
1964    cat >conftest.$ac_ext <<_ACEOF
# Line 2387 | Line 1985 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1985    cat conftest.err >&5
1986    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1987    (exit $ac_status); } &&
1988 <         { ac_try='test -z "$ac_c_werror_flag"
1988 >         { ac_try='test -z "$ac_cxx_werror_flag"
1989                           || test ! -s conftest.err'
1990    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1991    (eval $ac_try) 2>&5
# Line 2400 | Line 1998 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1998    ac_status=$?
1999    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2000    (exit $ac_status); }; }; then
2001 <  ac_cv_prog_cc_g=yes
2001 >  ac_cv_prog_cxx_g=yes
2002   else
2003    echo "$as_me: failed program was:" >&5
2004   sed 's/^/| /' conftest.$ac_ext >&5
2005  
2006 < ac_cv_prog_cc_g=no
2006 > ac_cv_prog_cxx_g=no
2007   fi
2008   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2009   fi
2010 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2011 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2012 < if test "$ac_test_CFLAGS" = set; then
2013 <  CFLAGS=$ac_save_CFLAGS
2014 < elif test $ac_cv_prog_cc_g = yes; then
2015 <  if test "$GCC" = yes; then
2016 <    CFLAGS="-g -O2"
2010 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2011 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2012 > if test "$ac_test_CXXFLAGS" = set; then
2013 >  CXXFLAGS=$ac_save_CXXFLAGS
2014 > elif test $ac_cv_prog_cxx_g = yes; then
2015 >  if test "$GXX" = yes; then
2016 >    CXXFLAGS="-g -O2"
2017    else
2018 <    CFLAGS="-g"
2018 >    CXXFLAGS="-g"
2019    fi
2020   else
2021 <  if test "$GCC" = yes; then
2022 <    CFLAGS="-O2"
2021 >  if test "$GXX" = yes; then
2022 >    CXXFLAGS="-O2"
2023    else
2024 <    CFLAGS=
2024 >    CXXFLAGS=
2025    fi
2026   fi
2027 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2430 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2431 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2432 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2433 < else
2434 <  ac_cv_prog_cc_stdc=no
2435 < ac_save_CC=$CC
2436 < cat >conftest.$ac_ext <<_ACEOF
2437 < /* confdefs.h.  */
2438 < _ACEOF
2439 < cat confdefs.h >>conftest.$ac_ext
2440 < cat >>conftest.$ac_ext <<_ACEOF
2441 < /* end confdefs.h.  */
2442 < #include <stdarg.h>
2443 < #include <stdio.h>
2444 < #include <sys/types.h>
2445 < #include <sys/stat.h>
2446 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2447 < struct buf { int x; };
2448 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2449 < static char *e (p, i)
2450 <     char **p;
2451 <     int i;
2452 < {
2453 <  return p[i];
2454 < }
2455 < static char *f (char * (*g) (char **, int), char **p, ...)
2456 < {
2457 <  char *s;
2458 <  va_list v;
2459 <  va_start (v,p);
2460 <  s = g (p, va_arg (v,int));
2461 <  va_end (v);
2462 <  return s;
2463 < }
2464 <
2465 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2466 <   function prototypes and stuff, but not '\xHH' hex character constants.
2467 <   These don't provoke an error unfortunately, instead are silently treated
2468 <   as 'x'.  The following induces an error, until -std1 is added to get
2469 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2470 <   array size at least.  It's necessary to write '\x00'==0 to get something
2471 <   that's true only with -std1.  */
2472 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2473 <
2474 < int test (int i, double x);
2475 < struct s1 {int (*f) (int a);};
2476 < struct s2 {int (*f) (double a);};
2477 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2478 < int argc;
2479 < char **argv;
2480 < int
2481 < main ()
2482 < {
2483 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2484 <  ;
2485 <  return 0;
2486 < }
2487 < _ACEOF
2488 < # Don't try gcc -ansi; that turns off useful extensions and
2489 < # breaks some systems' header files.
2490 < # AIX                   -qlanglvl=ansi
2491 < # Ultrix and OSF/1      -std1
2492 < # HP-UX 10.20 and later -Ae
2493 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2494 < # SVR4                  -Xc -D__EXTENSIONS__
2495 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2496 < do
2497 <  CC="$ac_save_CC $ac_arg"
2498 <  rm -f conftest.$ac_objext
2499 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2500 <  (eval $ac_compile) 2>conftest.er1
2501 <  ac_status=$?
2502 <  grep -v '^ *+' conftest.er1 >conftest.err
2503 <  rm -f conftest.er1
2504 <  cat conftest.err >&5
2505 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2506 <  (exit $ac_status); } &&
2507 <         { ac_try='test -z "$ac_c_werror_flag"
2508 <                         || test ! -s conftest.err'
2509 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2510 <  (eval $ac_try) 2>&5
2511 <  ac_status=$?
2512 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2513 <  (exit $ac_status); }; } &&
2514 <         { ac_try='test -s conftest.$ac_objext'
2515 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2516 <  (eval $ac_try) 2>&5
2517 <  ac_status=$?
2518 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519 <  (exit $ac_status); }; }; then
2520 <  ac_cv_prog_cc_stdc=$ac_arg
2521 < break
2522 < else
2523 <  echo "$as_me: failed program was:" >&5
2524 < sed 's/^/| /' conftest.$ac_ext >&5
2525 <
2526 < fi
2527 < rm -f conftest.err conftest.$ac_objext
2528 < done
2529 < rm -f conftest.$ac_ext conftest.$ac_objext
2530 < CC=$ac_save_CC
2531 <
2532 < fi
2533 <
2534 < case "x$ac_cv_prog_cc_stdc" in
2535 <  x|xno)
2536 <    echo "$as_me:$LINENO: result: none needed" >&5
2537 < echo "${ECHO_T}none needed" >&6 ;;
2538 <  *)
2539 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2540 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2541 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2542 < esac
2543 <
2544 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2545 < # in C++ we need to declare it.  In case someone uses the same compiler
2546 < # for both compiling C and C++ we need to have the C++ compiler decide
2547 < # the declaration of exit, since it's the most demanding environment.
2548 < cat >conftest.$ac_ext <<_ACEOF
2549 < #ifndef __cplusplus
2550 <  choke me
2551 < #endif
2552 < _ACEOF
2553 < rm -f conftest.$ac_objext
2554 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2555 <  (eval $ac_compile) 2>conftest.er1
2556 <  ac_status=$?
2557 <  grep -v '^ *+' conftest.er1 >conftest.err
2558 <  rm -f conftest.er1
2559 <  cat conftest.err >&5
2560 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2561 <  (exit $ac_status); } &&
2562 <         { ac_try='test -z "$ac_c_werror_flag"
2563 <                         || test ! -s conftest.err'
2564 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2565 <  (eval $ac_try) 2>&5
2566 <  ac_status=$?
2567 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2568 <  (exit $ac_status); }; } &&
2569 <         { ac_try='test -s conftest.$ac_objext'
2570 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2571 <  (eval $ac_try) 2>&5
2572 <  ac_status=$?
2573 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2574 <  (exit $ac_status); }; }; then
2575 <  for ac_declaration in \
2027 > for ac_declaration in \
2028     '' \
2029     'extern "C" void std::exit (int) throw (); using std::exit;' \
2030     'extern "C" void std::exit (int); using std::exit;' \
# Line 2605 | Line 2057 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2057    cat conftest.err >&5
2058    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2059    (exit $ac_status); } &&
2060 <         { ac_try='test -z "$ac_c_werror_flag"
2060 >         { ac_try='test -z "$ac_cxx_werror_flag"
2061                           || test ! -s conftest.err'
2062    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2063    (eval $ac_try) 2>&5
# Line 2650 | Line 2102 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2102    cat conftest.err >&5
2103    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104    (exit $ac_status); } &&
2105 <         { ac_try='test -z "$ac_c_werror_flag"
2105 >         { ac_try='test -z "$ac_cxx_werror_flag"
2106                           || test ! -s conftest.err'
2107    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108    (eval $ac_try) 2>&5
# Line 2678 | Line 2130 | else
2130    echo '#endif'             >>confdefs.h
2131   fi
2132  
2681 – else
2682 –  echo "$as_me: failed program was:" >&5
2683 – sed 's/^/| /' conftest.$ac_ext >&5
2684 –
2685 – fi
2686 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2133   ac_ext=c
2134   ac_cpp='$CPP $CPPFLAGS'
2135   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2136   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2137   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2138  
2139 <
2140 < ac_ext=cc
2141 < ac_cpp='$CXXCPP $CPPFLAGS'
2142 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2143 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2698 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2139 > ac_ext=c
2140 > ac_cpp='$CPP $CPPFLAGS'
2141 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2142 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2143 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2144   if test -n "$ac_tool_prefix"; then
2145 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2145 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2146    do
2147      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2148   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2149   echo "$as_me:$LINENO: checking for $ac_word" >&5
2150   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2151 < if test "${ac_cv_prog_CXX+set}" = set; then
2151 > if test "${ac_cv_prog_CC+set}" = set; then
2152    echo $ECHO_N "(cached) $ECHO_C" >&6
2153   else
2154 <  if test -n "$CXX"; then
2155 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2154 >  if test -n "$CC"; then
2155 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2156   else
2157   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2158   for as_dir in $PATH
# Line 2716 | Line 2161 | do
2161    test -z "$as_dir" && as_dir=.
2162    for ac_exec_ext in '' $ac_executable_extensions; do
2163    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2164 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2164 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2165      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2166      break 2
2167    fi
# Line 2725 | Line 2170 | CXX=$ac_cv_prog_CXX
2170  
2171   fi
2172   fi
2173 < CXX=$ac_cv_prog_CXX
2174 < if test -n "$CXX"; then
2175 <  echo "$as_me:$LINENO: result: $CXX" >&5
2176 < echo "${ECHO_T}$CXX" >&6
2173 > CC=$ac_cv_prog_CC
2174 > if test -n "$CC"; then
2175 >  echo "$as_me:$LINENO: result: $CC" >&5
2176 > echo "${ECHO_T}$CC" >&6
2177   else
2178    echo "$as_me:$LINENO: result: no" >&5
2179   echo "${ECHO_T}no" >&6
2180   fi
2181  
2182 <    test -n "$CXX" && break
2182 >    test -n "$CC" && break
2183    done
2184   fi
2185 < if test -z "$CXX"; then
2186 <  ac_ct_CXX=$CXX
2187 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2185 > if test -z "$CC"; then
2186 >  ac_ct_CC=$CC
2187 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2188   do
2189    # Extract the first word of "$ac_prog", so it can be a program name with args.
2190   set dummy $ac_prog; ac_word=$2
2191   echo "$as_me:$LINENO: checking for $ac_word" >&5
2192   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2193 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2193 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2194    echo $ECHO_N "(cached) $ECHO_C" >&6
2195   else
2196 <  if test -n "$ac_ct_CXX"; then
2197 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2196 >  if test -n "$ac_ct_CC"; then
2197 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2198   else
2199   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2200   for as_dir in $PATH
# Line 2758 | Line 2203 | do
2203    test -z "$as_dir" && as_dir=.
2204    for ac_exec_ext in '' $ac_executable_extensions; do
2205    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2206 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2206 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2207      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2208      break 2
2209    fi
# Line 2767 | Line 2212 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2212  
2213   fi
2214   fi
2215 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2216 < if test -n "$ac_ct_CXX"; then
2217 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2218 < echo "${ECHO_T}$ac_ct_CXX" >&6
2215 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2216 > if test -n "$ac_ct_CC"; then
2217 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2218 > echo "${ECHO_T}$ac_ct_CC" >&6
2219   else
2220    echo "$as_me:$LINENO: result: no" >&5
2221   echo "${ECHO_T}no" >&6
2222   fi
2223  
2224 <  test -n "$ac_ct_CXX" && break
2224 >  test -n "$ac_ct_CC" && break
2225   done
2781 – test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2226  
2227 <  CXX=$ac_ct_CXX
2227 >  CC=$ac_ct_CC
2228   fi
2229  
2230  
2231 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2232 + See \`config.log' for more details." >&5
2233 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2234 + See \`config.log' for more details." >&2;}
2235 +   { (exit 1); exit 1; }; }
2236 +
2237   # Provide some information about the compiler.
2238   echo "$as_me:$LINENO:" \
2239 <     "checking for C++ compiler version" >&5
2239 >     "checking for C compiler version" >&5
2240   ac_compiler=`set X $ac_compile; echo $2`
2241   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2242    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2804 | Line 2254 | echo "$as_me:$LINENO: checking whether we are using th
2254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2255    (exit $ac_status); }
2256  
2257 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2258 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2259 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2257 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2258 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2259 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2260    echo $ECHO_N "(cached) $ECHO_C" >&6
2261   else
2262    cat >conftest.$ac_ext <<_ACEOF
# Line 2836 | Line 2286 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2286    cat conftest.err >&5
2287    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2288    (exit $ac_status); } &&
2289 <         { ac_try='test -z "$ac_cxx_werror_flag"
2289 >         { ac_try='test -z "$ac_c_werror_flag"
2290                           || test ! -s conftest.err'
2291    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2292    (eval $ac_try) 2>&5
# Line 2857 | Line 2307 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2307   ac_compiler_gnu=no
2308   fi
2309   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2310 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2310 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2311  
2312   fi
2313 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2314 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2315 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2316 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2317 < ac_save_CXXFLAGS=$CXXFLAGS
2318 < CXXFLAGS="-g"
2319 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2320 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2321 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2313 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2314 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2315 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2316 > ac_test_CFLAGS=${CFLAGS+set}
2317 > ac_save_CFLAGS=$CFLAGS
2318 > CFLAGS="-g"
2319 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2320 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2321 > if test "${ac_cv_prog_cc_g+set}" = set; then
2322    echo $ECHO_N "(cached) $ECHO_C" >&6
2323   else
2324    cat >conftest.$ac_ext <<_ACEOF
# Line 2895 | Line 2345 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2345    cat conftest.err >&5
2346    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2347    (exit $ac_status); } &&
2348 <         { ac_try='test -z "$ac_cxx_werror_flag"
2348 >         { ac_try='test -z "$ac_c_werror_flag"
2349                           || test ! -s conftest.err'
2350    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2351    (eval $ac_try) 2>&5
# Line 2908 | Line 2358 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2358    ac_status=$?
2359    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2360    (exit $ac_status); }; }; then
2361 <  ac_cv_prog_cxx_g=yes
2361 >  ac_cv_prog_cc_g=yes
2362   else
2363    echo "$as_me: failed program was:" >&5
2364   sed 's/^/| /' conftest.$ac_ext >&5
2365  
2366 < ac_cv_prog_cxx_g=no
2366 > ac_cv_prog_cc_g=no
2367   fi
2368   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2369   fi
2370 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2371 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2372 < if test "$ac_test_CXXFLAGS" = set; then
2373 <  CXXFLAGS=$ac_save_CXXFLAGS
2374 < elif test $ac_cv_prog_cxx_g = yes; then
2375 <  if test "$GXX" = yes; then
2376 <    CXXFLAGS="-g -O2"
2370 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2371 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2372 > if test "$ac_test_CFLAGS" = set; then
2373 >  CFLAGS=$ac_save_CFLAGS
2374 > elif test $ac_cv_prog_cc_g = yes; then
2375 >  if test "$GCC" = yes; then
2376 >    CFLAGS="-g -O2"
2377    else
2378 <    CXXFLAGS="-g"
2378 >    CFLAGS="-g"
2379    fi
2380   else
2381 <  if test "$GXX" = yes; then
2382 <    CXXFLAGS="-O2"
2381 >  if test "$GCC" = yes; then
2382 >    CFLAGS="-O2"
2383    else
2384 <    CXXFLAGS=
2384 >    CFLAGS=
2385    fi
2386   fi
2387 < for ac_declaration in \
2388 <   '' \
2389 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2390 <   'extern "C" void std::exit (int); using std::exit;' \
2391 <   'extern "C" void exit (int) throw ();' \
2392 <   'extern "C" void exit (int);' \
2393 <   'void exit (int);'
2394 < do
2945 <  cat >conftest.$ac_ext <<_ACEOF
2387 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2388 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2389 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2391 > else
2392 >  ac_cv_prog_cc_stdc=no
2393 > ac_save_CC=$CC
2394 > cat >conftest.$ac_ext <<_ACEOF
2395   /* confdefs.h.  */
2396   _ACEOF
2397   cat confdefs.h >>conftest.$ac_ext
2398   cat >>conftest.$ac_ext <<_ACEOF
2399   /* end confdefs.h.  */
2400 < $ac_declaration
2401 < #include <stdlib.h>
2402 < int
2403 < main ()
2404 < {
2405 < exit (42);
2406 <  ;
2407 <  return 0;
2408 < }
2409 < _ACEOF
2400 > #include <stdarg.h>
2401 > #include <stdio.h>
2402 > #include <sys/types.h>
2403 > #include <sys/stat.h>
2404 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2405 > struct buf { int x; };
2406 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2407 > static char *e (p, i)
2408 >     char **p;
2409 >     int i;
2410 > {
2411 >  return p[i];
2412 > }
2413 > static char *f (char * (*g) (char **, int), char **p, ...)
2414 > {
2415 >  char *s;
2416 >  va_list v;
2417 >  va_start (v,p);
2418 >  s = g (p, va_arg (v,int));
2419 >  va_end (v);
2420 >  return s;
2421 > }
2422 >
2423 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2424 >   function prototypes and stuff, but not '\xHH' hex character constants.
2425 >   These don't provoke an error unfortunately, instead are silently treated
2426 >   as 'x'.  The following induces an error, until -std1 is added to get
2427 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2428 >   array size at least.  It's necessary to write '\x00'==0 to get something
2429 >   that's true only with -std1.  */
2430 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2431 >
2432 > int test (int i, double x);
2433 > struct s1 {int (*f) (int a);};
2434 > struct s2 {int (*f) (double a);};
2435 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2436 > int argc;
2437 > char **argv;
2438 > int
2439 > main ()
2440 > {
2441 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2442 >  ;
2443 >  return 0;
2444 > }
2445 > _ACEOF
2446 > # Don't try gcc -ansi; that turns off useful extensions and
2447 > # breaks some systems' header files.
2448 > # AIX                   -qlanglvl=ansi
2449 > # Ultrix and OSF/1      -std1
2450 > # HP-UX 10.20 and later -Ae
2451 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2452 > # SVR4                  -Xc -D__EXTENSIONS__
2453 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2454 > do
2455 >  CC="$ac_save_CC $ac_arg"
2456 >  rm -f conftest.$ac_objext
2457 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2458 >  (eval $ac_compile) 2>conftest.er1
2459 >  ac_status=$?
2460 >  grep -v '^ *+' conftest.er1 >conftest.err
2461 >  rm -f conftest.er1
2462 >  cat conftest.err >&5
2463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2464 >  (exit $ac_status); } &&
2465 >         { ac_try='test -z "$ac_c_werror_flag"
2466 >                         || test ! -s conftest.err'
2467 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468 >  (eval $ac_try) 2>&5
2469 >  ac_status=$?
2470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471 >  (exit $ac_status); }; } &&
2472 >         { ac_try='test -s conftest.$ac_objext'
2473 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474 >  (eval $ac_try) 2>&5
2475 >  ac_status=$?
2476 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477 >  (exit $ac_status); }; }; then
2478 >  ac_cv_prog_cc_stdc=$ac_arg
2479 > break
2480 > else
2481 >  echo "$as_me: failed program was:" >&5
2482 > sed 's/^/| /' conftest.$ac_ext >&5
2483 >
2484 > fi
2485 > rm -f conftest.err conftest.$ac_objext
2486 > done
2487 > rm -f conftest.$ac_ext conftest.$ac_objext
2488 > CC=$ac_save_CC
2489 >
2490 > fi
2491 >
2492 > case "x$ac_cv_prog_cc_stdc" in
2493 >  x|xno)
2494 >    echo "$as_me:$LINENO: result: none needed" >&5
2495 > echo "${ECHO_T}none needed" >&6 ;;
2496 >  *)
2497 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2500 > esac
2501 >
2502 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2503 > # in C++ we need to declare it.  In case someone uses the same compiler
2504 > # for both compiling C and C++ we need to have the C++ compiler decide
2505 > # the declaration of exit, since it's the most demanding environment.
2506 > cat >conftest.$ac_ext <<_ACEOF
2507 > #ifndef __cplusplus
2508 >  choke me
2509 > #endif
2510 > _ACEOF
2511   rm -f conftest.$ac_objext
2512   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513    (eval $ac_compile) 2>conftest.er1
# Line 2967 | Line 2517 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2517    cat conftest.err >&5
2518    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519    (exit $ac_status); } &&
2520 <         { ac_try='test -z "$ac_cxx_werror_flag"
2520 >         { ac_try='test -z "$ac_c_werror_flag"
2521 >                         || test ! -s conftest.err'
2522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2523 >  (eval $ac_try) 2>&5
2524 >  ac_status=$?
2525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2526 >  (exit $ac_status); }; } &&
2527 >         { ac_try='test -s conftest.$ac_objext'
2528 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2529 >  (eval $ac_try) 2>&5
2530 >  ac_status=$?
2531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532 >  (exit $ac_status); }; }; then
2533 >  for ac_declaration in \
2534 >   '' \
2535 >   'extern "C" void std::exit (int) throw (); using std::exit;' \
2536 >   'extern "C" void std::exit (int); using std::exit;' \
2537 >   'extern "C" void exit (int) throw ();' \
2538 >   'extern "C" void exit (int);' \
2539 >   'void exit (int);'
2540 > do
2541 >  cat >conftest.$ac_ext <<_ACEOF
2542 > /* confdefs.h.  */
2543 > _ACEOF
2544 > cat confdefs.h >>conftest.$ac_ext
2545 > cat >>conftest.$ac_ext <<_ACEOF
2546 > /* end confdefs.h.  */
2547 > $ac_declaration
2548 > #include <stdlib.h>
2549 > int
2550 > main ()
2551 > {
2552 > exit (42);
2553 >  ;
2554 >  return 0;
2555 > }
2556 > _ACEOF
2557 > rm -f conftest.$ac_objext
2558 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2559 >  (eval $ac_compile) 2>conftest.er1
2560 >  ac_status=$?
2561 >  grep -v '^ *+' conftest.er1 >conftest.err
2562 >  rm -f conftest.er1
2563 >  cat conftest.err >&5
2564 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565 >  (exit $ac_status); } &&
2566 >         { ac_try='test -z "$ac_c_werror_flag"
2567                           || test ! -s conftest.err'
2568    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2569    (eval $ac_try) 2>&5
# Line 3012 | Line 2608 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2608    cat conftest.err >&5
2609    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610    (exit $ac_status); } &&
2611 <         { ac_try='test -z "$ac_cxx_werror_flag"
2611 >         { ac_try='test -z "$ac_c_werror_flag"
2612                           || test ! -s conftest.err'
2613    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2614    (eval $ac_try) 2>&5
# Line 3040 | Line 2636 | ac_ext=c
2636    echo '#endif'             >>confdefs.h
2637   fi
2638  
2639 + else
2640 +  echo "$as_me: failed program was:" >&5
2641 + sed 's/^/| /' conftest.$ac_ext >&5
2642 +
2643 + fi
2644 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645   ac_ext=c
2646   ac_cpp='$CPP $CPPFLAGS'
2647   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650  
2651 <
2652 < OOPSE_TEMPLATE_FLAGS=""
2653 < if test $ac_cv_cxx_compiler_gnu = no; then
2654 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3053 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3054 <  echo 'void f(){}' > conftest.cc
3055 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3056 <    echo "$as_me:$LINENO: result: yes" >&5
3057 < echo "${ECHO_T}yes" >&6
3058 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3059 <  else
3060 <    echo "$as_me:$LINENO: result: no" >&5
3061 < echo "${ECHO_T}no" >&6
3062 <  fi
3063 <  rm -f conftest*
3064 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3065 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3066 <  echo 'void f(){}' > conftest.cc
3067 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3068 <    echo "$as_me:$LINENO: result: yes" >&5
3069 < echo "${ECHO_T}yes" >&6
3070 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3071 <  else
3072 <    echo "$as_me:$LINENO: result: no" >&5
3073 < echo "${ECHO_T}no" >&6
3074 <  fi
3075 <  rm -f conftest*
3076 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3077 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3078 <  echo 'void f(){}' > conftest.cc
3079 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3080 <    echo "$as_me:$LINENO: result: yes" >&5
3081 < echo "${ECHO_T}yes" >&6
3082 <    OOPSE_TEMPLATE_FLAGS="-pto"
3083 <  else
3084 <    echo "$as_me:$LINENO: result: no" >&5
3085 < echo "${ECHO_T}no" >&6
3086 <  fi
3087 <  rm -f conftest*
3088 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3089 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3090 <  echo 'void f(){}' > conftest.cc
3091 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3092 <    echo "$as_me:$LINENO: result: yes" >&5
3093 < echo "${ECHO_T}yes" >&6
3094 <
3095 <
3096 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3097 <  else
3098 <    echo "$as_me:$LINENO: result: no" >&5
3099 < echo "${ECHO_T}no" >&6
3100 <  fi
3101 < fi
3102 <
3103 <
3104 <
3105 <
3106 < ac_ext=f90
3107 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3108 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3109 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2651 > ac_ext=${FC_SRCEXT-f}
2652 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2653 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2654 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2655   if test -n "$ac_tool_prefix"; then
2656 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2656 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2657    do
2658      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2659   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2660   echo "$as_me:$LINENO: checking for $ac_word" >&5
2661   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2662 < if test "${ac_cv_prog_F90+set}" = set; then
2662 > if test "${ac_cv_prog_FC+set}" = set; then
2663    echo $ECHO_N "(cached) $ECHO_C" >&6
2664   else
2665 <  if test -n "$F90"; then
2666 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2665 >  if test -n "$FC"; then
2666 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2667   else
2668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2669   for as_dir in $PATH
# Line 3127 | Line 2672 | do
2672    test -z "$as_dir" && as_dir=.
2673    for ac_exec_ext in '' $ac_executable_extensions; do
2674    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2675 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2675 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2676      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2677      break 2
2678    fi
# Line 3136 | Line 2681 | F90=$ac_cv_prog_F90
2681  
2682   fi
2683   fi
2684 < F90=$ac_cv_prog_F90
2685 < if test -n "$F90"; then
2686 <  echo "$as_me:$LINENO: result: $F90" >&5
2687 < echo "${ECHO_T}$F90" >&6
2684 > FC=$ac_cv_prog_FC
2685 > if test -n "$FC"; then
2686 >  echo "$as_me:$LINENO: result: $FC" >&5
2687 > echo "${ECHO_T}$FC" >&6
2688   else
2689    echo "$as_me:$LINENO: result: no" >&5
2690   echo "${ECHO_T}no" >&6
2691   fi
2692  
2693 <    test -n "$F90" && break
2693 >    test -n "$FC" && break
2694    done
2695   fi
2696 < if test -z "$F90"; then
2697 <  ac_ct_F90=$F90
2698 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2696 > if test -z "$FC"; then
2697 >  ac_ct_FC=$FC
2698 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2699   do
2700    # Extract the first word of "$ac_prog", so it can be a program name with args.
2701   set dummy $ac_prog; ac_word=$2
2702   echo "$as_me:$LINENO: checking for $ac_word" >&5
2703   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2704 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2704 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2705    echo $ECHO_N "(cached) $ECHO_C" >&6
2706   else
2707 <  if test -n "$ac_ct_F90"; then
2708 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2707 >  if test -n "$ac_ct_FC"; then
2708 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2709   else
2710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2711   for as_dir in $PATH
# Line 3169 | Line 2714 | do
2714    test -z "$as_dir" && as_dir=.
2715    for ac_exec_ext in '' $ac_executable_extensions; do
2716    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2717 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2717 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2718      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719      break 2
2720    fi
# Line 3178 | Line 2723 | ac_ct_F90=$ac_cv_prog_ac_ct_F90
2723  
2724   fi
2725   fi
2726 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2727 < if test -n "$ac_ct_F90"; then
2728 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2729 < echo "${ECHO_T}$ac_ct_F90" >&6
2726 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2727 > if test -n "$ac_ct_FC"; then
2728 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2729 > echo "${ECHO_T}$ac_ct_FC" >&6
2730   else
2731    echo "$as_me:$LINENO: result: no" >&5
2732   echo "${ECHO_T}no" >&6
2733   fi
2734  
2735 <  test -n "$ac_ct_F90" && break
2735 >  test -n "$ac_ct_FC" && break
2736   done
2737  
2738 <  F90=$ac_ct_F90
2738 >  FC=$ac_ct_FC
2739   fi
2740  
2741  
2742 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2743 < # input file.
2742 > # Provide some information about the compiler.
2743 > echo "$as_me:2743:" \
2744 >     "checking for Fortran compiler version" >&5
2745 > ac_compiler=`set X $ac_compile; echo $2`
2746 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2747 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2748 >  ac_status=$?
2749 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2750 >  (exit $ac_status); }
2751 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2752 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2753 >  ac_status=$?
2754 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755 >  (exit $ac_status); }
2756 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2757 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2758 >  ac_status=$?
2759 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2760 >  (exit $ac_status); }
2761 > rm -f a.out
2762 >
2763 > # If we don't use `.F' as extension, the preprocessor is not run on the
2764 > # input file.  (Note that this only needs to work for GNU compilers.)
2765   ac_save_ext=$ac_ext
2766 < ac_ext=F90
2767 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2768 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2769 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2766 > ac_ext=F
2767 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2768 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2769 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2770    echo $ECHO_N "(cached) $ECHO_C" >&6
2771   else
2772    cat >conftest.$ac_ext <<_ACEOF
2773 <
3208 < program main
3209 <
2773 >      program main
2774   #ifndef __GNUC__
2775         choke me
2776   #endif
2777  
2778 < end program main
3215 <
2778 >      end
2779   _ACEOF
2780   rm -f conftest.$ac_objext
2781   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3223 | Line 2786 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2786    cat conftest.err >&5
2787    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788    (exit $ac_status); } &&
2789 <         { ac_try='test -z "$ac_f90_werror_flag"
2789 >         { ac_try='test -z "$ac_fc_werror_flag"
2790                           || test ! -s conftest.err'
2791    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2792    (eval $ac_try) 2>&5
# Line 3244 | Line 2807 | ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2807   ac_compiler_gnu=no
2808   fi
2809   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2810 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811  
2812   fi
2813 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2814 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2813 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2814 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2815   ac_ext=$ac_save_ext
2816 < G95=`test $ac_compiler_gnu = yes && echo yes`
2817 < ac_ext=c
2818 < ac_cpp='$CPP $CPPFLAGS'
2819 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2820 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2821 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2816 > ac_test_FFLAGS=${FCFLAGS+set}
2817 > ac_save_FFLAGS=$FCFLAGS
2818 > FCFLAGS=
2819 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2820 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2821 > if test "${ac_cv_prog_fc_g+set}" = set; then
2822 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2823 > else
2824 >  FCFLAGS=-g
2825 > cat >conftest.$ac_ext <<_ACEOF
2826 >      program main
2827  
2828 <
3261 <
3262 <
3263 <
3264 < # Try to determine native compiler flags that allow us to use F90 suffix
3265 < # for preprocessed f90 source.
3266 <
3267 < if test "$ac_test_PREPFLAG" != "set"; then
3268 <  PREPFLAG=""
3269 <  case "${host_cpu}-${host_os}" in
3270 <
3271 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3272 <                    PREPFLAG="-fpp1 "
3273 <                fi;;
3274 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3275 <                    PREPFLAG="-qsuffix=cpp=F90 "
3276 <                fi;;
3277 <  *darwin*)
3278 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3279 <                PREPFLAG="-qsuffix=cpp=F90 "
3280 <        fi;;
3281 <  esac
3282 <
3283 <  if test -z "$PREPFLAG"; then
3284 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3285 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3286 <        PREPFLAG=""
3287 <  fi
3288 <
3289 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3290 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3291 <
3292 <
3293 <  ac_ext=f90
3294 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3295 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3296 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3297 <
3298 <  ac_save_ext=$ac_ext
3299 <  ac_ext=F90
3300 <  ac_save_F90FLAGS=$F90FLAGS
3301 <
3302 <  if test "$PREPFLAG"; then
3303 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3304 < fi
3305 <
3306 <    cat >conftest.$ac_ext <<_ACEOF
3307 <
3308 <
3309 < program main
3310 <
3311 <  integer :: i
3312 <  i = 1
3313 <
3314 <
3315 < end program main
3316 <
2828 >      end
2829   _ACEOF
2830   rm -f conftest.$ac_objext
2831   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3324 | Line 2836 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2836    cat conftest.err >&5
2837    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838    (exit $ac_status); } &&
2839 <         { ac_try='test -z "$ac_f90_werror_flag"
2839 >         { ac_try='test -z "$ac_fc_werror_flag"
2840                           || test ! -s conftest.err'
2841    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2842    (eval $ac_try) 2>&5
# Line 3337 | Line 2849 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2849    ac_status=$?
2850    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851    (exit $ac_status); }; }; then
2852 <  prepflagworks=1
2852 >  ac_cv_prog_fc_g=yes
2853   else
2854    echo "$as_me: failed program was:" >&5
2855   sed 's/^/| /' conftest.$ac_ext >&5
2856  
2857 < prepflagworks=0
2857 > ac_cv_prog_fc_g=no
2858   fi
2859   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860  
2861 <  F90FLAGS=$ac_save_F90FLAGS
2862 <  ac_ext=$ac_save_ext
2863 <  ac_ext=c
2861 > fi
2862 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2863 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2864 > if test "$ac_test_FFLAGS" = set; then
2865 >  FCFLAGS=$ac_save_FFLAGS
2866 > elif test $ac_cv_prog_fc_g = yes; then
2867 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2868 >    FCFLAGS="-g -O2"
2869 >  else
2870 >    FCFLAGS="-g"
2871 >  fi
2872 > else
2873 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2874 >    FCFLAGS="-O2"
2875 >  else
2876 >    FCFLAGS=
2877 >  fi
2878 > fi
2879 >
2880 > ac_ext=c
2881   ac_cpp='$CPP $CPPFLAGS'
2882   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2883   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2884   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2885  
2886 + ac_ext=c
2887 + ac_cpp='$CPP $CPPFLAGS'
2888 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2889 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2890 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2891 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2892 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2893 + # On Suns, sometimes $CPP names a directory.
2894 + if test -n "$CPP" && test -d "$CPP"; then
2895 +  CPP=
2896 + fi
2897 + if test -z "$CPP"; then
2898 +  if test "${ac_cv_prog_CPP+set}" = set; then
2899 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2900 + else
2901 +      # Double quotes because CPP needs to be expanded
2902 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2903 +    do
2904 +      ac_preproc_ok=false
2905 + for ac_c_preproc_warn_flag in '' yes
2906 + do
2907 +  # Use a header file that comes with gcc, so configuring glibc
2908 +  # with a fresh cross-compiler works.
2909 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2910 +  # <limits.h> exists even on freestanding compilers.
2911 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2912 +  # not just through cpp. "Syntax error" is here to catch this case.
2913 +  cat >conftest.$ac_ext <<_ACEOF
2914 + /* confdefs.h.  */
2915 + _ACEOF
2916 + cat confdefs.h >>conftest.$ac_ext
2917 + cat >>conftest.$ac_ext <<_ACEOF
2918 + /* end confdefs.h.  */
2919 + #ifdef __STDC__
2920 + # include <limits.h>
2921 + #else
2922 + # include <assert.h>
2923 + #endif
2924 +                     Syntax error
2925 + _ACEOF
2926 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2927 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2928 +  ac_status=$?
2929 +  grep -v '^ *+' conftest.er1 >conftest.err
2930 +  rm -f conftest.er1
2931 +  cat conftest.err >&5
2932 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2933 +  (exit $ac_status); } >/dev/null; then
2934 +  if test -s conftest.err; then
2935 +    ac_cpp_err=$ac_c_preproc_warn_flag
2936 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2937 +  else
2938 +    ac_cpp_err=
2939 +  fi
2940 + else
2941 +  ac_cpp_err=yes
2942 + fi
2943 + if test -z "$ac_cpp_err"; then
2944 +  :
2945 + else
2946 +  echo "$as_me: failed program was:" >&5
2947 + sed 's/^/| /' conftest.$ac_ext >&5
2948  
2949 <  if test "$prepflagworks" = 1; then
2950 <    echo "$as_me:$LINENO: result: yes" >&5
2951 < echo "${ECHO_T}yes" >&6
2949 >  # Broken: fails on valid input.
2950 > continue
2951 > fi
2952 > rm -f conftest.err conftest.$ac_ext
2953  
2954 +  # OK, works on sane cases.  Now check whether non-existent headers
2955 +  # can be detected and how.
2956 +  cat >conftest.$ac_ext <<_ACEOF
2957 + /* confdefs.h.  */
2958 + _ACEOF
2959 + cat confdefs.h >>conftest.$ac_ext
2960 + cat >>conftest.$ac_ext <<_ACEOF
2961 + /* end confdefs.h.  */
2962 + #include <ac_nonexistent.h>
2963 + _ACEOF
2964 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2965 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2966 +  ac_status=$?
2967 +  grep -v '^ *+' conftest.er1 >conftest.err
2968 +  rm -f conftest.er1
2969 +  cat conftest.err >&5
2970 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2971 +  (exit $ac_status); } >/dev/null; then
2972 +  if test -s conftest.err; then
2973 +    ac_cpp_err=$ac_c_preproc_warn_flag
2974 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2975    else
2976 <    echo "$as_me:$LINENO: result: no" >&5
3364 < echo "${ECHO_T}no" >&6
3365 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3366 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3367 <   { (exit 1); exit 1; }; }
2976 >    ac_cpp_err=
2977    fi
2978 + else
2979 +  ac_cpp_err=yes
2980   fi
2981 + if test -z "$ac_cpp_err"; then
2982 +  # Broken: success on invalid input.
2983 + continue
2984 + else
2985 +  echo "$as_me: failed program was:" >&5
2986 + sed 's/^/| /' conftest.$ac_ext >&5
2987  
2988 +  # Passes both tests.
2989 + ac_preproc_ok=:
2990 + break
2991 + fi
2992 + rm -f conftest.err conftest.$ac_ext
2993  
2994 <
2995 <
2996 <
2997 < # Try to determine native compiler flags that allow us to use F90 suffix
2998 < # for preprocessed f90 source with -D type defines
3377 <
3378 < if test "$ac_test_PREPDEFFLAG" != "set"; then
3379 <  PREPDEFFLAG=""
3380 <  case "${host_cpu}-${host_os}" in
3381 <
3382 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3383 <                    PREPDEFFLAG=" "
3384 <                fi;;
3385 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3386 <                    PREPDEFFLAG="-WF,"
3387 <                fi;;
3388 <  *darwin*)
3389 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3390 <                PREPDEFFLAG="-WF,"
3391 <        fi;;
3392 <  esac
3393 <
3394 <  if test -z "$PREPDEFFLAG"; then
3395 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3396 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3397 <        PREPDEFFLAG=" "
3398 <  fi
3399 <
3400 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3401 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3402 <
3403 <
3404 <  ac_ext=f90
3405 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3406 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3407 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3408 <
3409 <  ac_save_ext=$ac_ext
3410 <  ac_ext=F90
3411 <  ac_save_F90FLAGS=$F90FLAGS
3412 <
3413 <  if test "$PREPDEFFLAG"; then
3414 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
2994 > done
2995 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2996 > rm -f conftest.err conftest.$ac_ext
2997 > if $ac_preproc_ok; then
2998 >  break
2999   fi
3000  
3001 <    cat >conftest.$ac_ext <<_ACEOF
3001 >    done
3002 >    ac_cv_prog_CPP=$CPP
3003  
3004 <
3005 < program main
3006 <
3007 <  integer :: i
3008 < #ifdef TEST
3009 <  i = 1
3004 > fi
3005 >  CPP=$ac_cv_prog_CPP
3006 > else
3007 >  ac_cv_prog_CPP=$CPP
3008 > fi
3009 > echo "$as_me:$LINENO: result: $CPP" >&5
3010 > echo "${ECHO_T}$CPP" >&6
3011 > ac_preproc_ok=false
3012 > for ac_c_preproc_warn_flag in '' yes
3013 > do
3014 >  # Use a header file that comes with gcc, so configuring glibc
3015 >  # with a fresh cross-compiler works.
3016 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3017 >  # <limits.h> exists even on freestanding compilers.
3018 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3019 >  # not just through cpp. "Syntax error" is here to catch this case.
3020 >  cat >conftest.$ac_ext <<_ACEOF
3021 > /* confdefs.h.  */
3022 > _ACEOF
3023 > cat confdefs.h >>conftest.$ac_ext
3024 > cat >>conftest.$ac_ext <<_ACEOF
3025 > /* end confdefs.h.  */
3026 > #ifdef __STDC__
3027 > # include <limits.h>
3028   #else
3029 <  choke me
3029 > # include <assert.h>
3030   #endif
3031 +                     Syntax error
3032 + _ACEOF
3033 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3034 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3035 +  ac_status=$?
3036 +  grep -v '^ *+' conftest.er1 >conftest.err
3037 +  rm -f conftest.er1
3038 +  cat conftest.err >&5
3039 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3040 +  (exit $ac_status); } >/dev/null; then
3041 +  if test -s conftest.err; then
3042 +    ac_cpp_err=$ac_c_preproc_warn_flag
3043 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3044 +  else
3045 +    ac_cpp_err=
3046 +  fi
3047 + else
3048 +  ac_cpp_err=yes
3049 + fi
3050 + if test -z "$ac_cpp_err"; then
3051 +  :
3052 + else
3053 +  echo "$as_me: failed program was:" >&5
3054 + sed 's/^/| /' conftest.$ac_ext >&5
3055  
3056 +  # Broken: fails on valid input.
3057 + continue
3058 + fi
3059 + rm -f conftest.err conftest.$ac_ext
3060  
3061 < end program main
3062 <
3061 >  # OK, works on sane cases.  Now check whether non-existent headers
3062 >  # can be detected and how.
3063 >  cat >conftest.$ac_ext <<_ACEOF
3064 > /* confdefs.h.  */
3065   _ACEOF
3066 < rm -f conftest.$ac_objext
3067 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3068 <  (eval $ac_compile) 2>conftest.er1
3066 > cat confdefs.h >>conftest.$ac_ext
3067 > cat >>conftest.$ac_ext <<_ACEOF
3068 > /* end confdefs.h.  */
3069 > #include <ac_nonexistent.h>
3070 > _ACEOF
3071 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3072 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3073    ac_status=$?
3074    grep -v '^ *+' conftest.er1 >conftest.err
3075    rm -f conftest.er1
3076    cat conftest.err >&5
3077    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3078 <  (exit $ac_status); } &&
3079 <         { ac_try='test -z "$ac_f90_werror_flag"
3080 <                         || test ! -s conftest.err'
3081 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3082 <  (eval $ac_try) 2>&5
3083 <  ac_status=$?
3084 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3448 <  (exit $ac_status); }; } &&
3449 <         { ac_try='test -s conftest.$ac_objext'
3450 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3451 <  (eval $ac_try) 2>&5
3452 <  ac_status=$?
3453 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3454 <  (exit $ac_status); }; }; then
3455 <  prepdefflagworks=1
3078 >  (exit $ac_status); } >/dev/null; then
3079 >  if test -s conftest.err; then
3080 >    ac_cpp_err=$ac_c_preproc_warn_flag
3081 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3082 >  else
3083 >    ac_cpp_err=
3084 >  fi
3085   else
3086 +  ac_cpp_err=yes
3087 + fi
3088 + if test -z "$ac_cpp_err"; then
3089 +  # Broken: success on invalid input.
3090 + continue
3091 + else
3092    echo "$as_me: failed program was:" >&5
3093   sed 's/^/| /' conftest.$ac_ext >&5
3094  
3095 < prepdefflagworks=0
3095 >  # Passes both tests.
3096 > ac_preproc_ok=:
3097 > break
3098   fi
3099 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3099 > rm -f conftest.err conftest.$ac_ext
3100  
3101 <  F90FLAGS=$ac_save_F90FLAGS
3102 <  ac_ext=$ac_save_ext
3103 <  ac_ext=c
3101 > done
3102 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3103 > rm -f conftest.err conftest.$ac_ext
3104 > if $ac_preproc_ok; then
3105 >  :
3106 > else
3107 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3108 > See \`config.log' for more details." >&5
3109 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3110 > See \`config.log' for more details." >&2;}
3111 >   { (exit 1); exit 1; }; }
3112 > fi
3113 >
3114 > ac_ext=c
3115   ac_cpp='$CPP $CPPFLAGS'
3116   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3117   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3118   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3119  
3120 + echo "$as_me:$LINENO: checking for egrep" >&5
3121 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3122 + if test "${ac_cv_prog_egrep+set}" = set; then
3123 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3124 + else
3125 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3126 +    then ac_cv_prog_egrep='grep -E'
3127 +    else ac_cv_prog_egrep='egrep'
3128 +    fi
3129 + fi
3130 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3131 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132 + EGREP=$ac_cv_prog_egrep
3133  
3134  
3135 <  if test "$prepdefflagworks" = 1; then
3136 <    echo "$as_me:$LINENO: result: yes" >&5
3135 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3136 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3137 > LN_S=$as_ln_s
3138 > if test "$LN_S" = "ln -s"; then
3139 >  echo "$as_me:$LINENO: result: yes" >&5
3140   echo "${ECHO_T}yes" >&6
3141 + else
3142 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3143 + echo "${ECHO_T}no, using $LN_S" >&6
3144 + fi
3145  
3146 <  else
3147 <    echo "$as_me:$LINENO: result: no" >&5
3146 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3147 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3148 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3149 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3150 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3151 > else
3152 >  cat >conftest.make <<\_ACEOF
3153 > all:
3154 >        @echo 'ac_maketemp="$(MAKE)"'
3155 > _ACEOF
3156 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3157 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3158 > if test -n "$ac_maketemp"; then
3159 >  eval ac_cv_prog_make_${ac_make}_set=yes
3160 > else
3161 >  eval ac_cv_prog_make_${ac_make}_set=no
3162 > fi
3163 > rm -f conftest.make
3164 > fi
3165 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3166 >  echo "$as_me:$LINENO: result: yes" >&5
3167 > echo "${ECHO_T}yes" >&6
3168 >  SET_MAKE=
3169 > else
3170 >  echo "$as_me:$LINENO: result: no" >&5
3171   echo "${ECHO_T}no" >&6
3172 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3482 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3483 <   { (exit 1); exit 1; }; }
3484 <  fi
3172 >  SET_MAKE="MAKE=${MAKE-make}"
3173   fi
3174  
3175 < ac_ext=f90
3176 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3177 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3178 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3175 > if test -n "$ac_tool_prefix"; then
3176 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3177 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3178 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3179 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3181 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3182 > else
3183 >  if test -n "$RANLIB"; then
3184 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3185 > else
3186 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187 > for as_dir in $PATH
3188 > do
3189 >  IFS=$as_save_IFS
3190 >  test -z "$as_dir" && as_dir=.
3191 >  for ac_exec_ext in '' $ac_executable_extensions; do
3192 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3194 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195 >    break 2
3196 >  fi
3197 > done
3198 > done
3199  
3492 –
3493 –
3494 – ac_ext=f90
3495 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3496 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3497 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3498 – echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3499 – echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3500 – if test "${ac_cv_prog_f90_v+set}" = set; then
3501 –  echo $ECHO_N "(cached) $ECHO_C" >&6
3502 – else
3503 –
3504 – cat >conftest.$ac_ext <<_ACEOF
3505 –
3506 – program main
3507 –
3508 –
3509 – end program main
3510 –
3511 – _ACEOF
3512 – rm -f conftest.$ac_objext
3513 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3514 –  (eval $ac_compile) 2>conftest.er1
3515 –  ac_status=$?
3516 –  grep -v '^ *+' conftest.er1 >conftest.err
3517 –  rm -f conftest.er1
3518 –  cat conftest.err >&5
3519 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3520 –  (exit $ac_status); } &&
3521 –         { ac_try='test -z "$ac_f90_werror_flag"
3522 –                         || test ! -s conftest.err'
3523 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3524 –  (eval $ac_try) 2>&5
3525 –  ac_status=$?
3526 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527 –  (exit $ac_status); }; } &&
3528 –         { ac_try='test -s conftest.$ac_objext'
3529 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3530 –  (eval $ac_try) 2>&5
3531 –  ac_status=$?
3532 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3533 –  (exit $ac_status); }; }; then
3534 –  ac_cv_prog_f90_v=
3535 – # Try some options frequently used verbose output
3536 – for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3537 –  ac_ext=f90
3538 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3539 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3540 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3541 –
3542 – cat >conftest.$ac_ext <<_ACEOF
3543 –
3544 – program main
3545 –
3546 –
3547 – end program main
3548 –
3549 – _ACEOF
3550 –
3551 – # Compile and link our simple test program by passing a flag (argument
3552 – # 1 to this macro) to the Fortran 90 compiler in order to get
3553 – # "verbose" output that we can then parse for the Fortran 90 linker
3554 – # flags.
3555 – ac_save_F90FLAGS=$F90FLAGS
3556 – F90FLAGS="$F90FLAGS $ac_verb"
3557 –
3558 – (eval echo $as_me:3558: \"$ac_link\") >&5
3559 – ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3560 – echo "$ac_f90_v_output" >&5
3561 – F90FLAGS=$ac_save_F90FLAGS
3562 –
3563 – rm -f conftest.*
3564 – ac_ext=f90
3565 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3566 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3567 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3568 –
3569 – # If we are using xlf then replace all the commas with spaces.
3570 – if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3571 –  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3200   fi
3573 –
3574 – # If we are using Cray Fortran then delete quotes.
3575 – # Use "\"" instead of '"' for font-lock-mode.
3576 – # FIXME: a more general fix for quoted arguments with spaces?
3577 – if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3578 –  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3201   fi
3202 <  # look for -l* and *.a constructs in the output
3203 <  for ac_arg in $ac_f90_v_output; do
3204 <     case $ac_arg in
3205 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3584 <          ac_cv_prog_f90_v=$ac_verb
3585 <          break 2 ;;
3586 <     esac
3587 <  done
3588 < done
3589 < if test -z "$ac_cv_prog_f90_v"; then
3590 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3591 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3592 < fi
3202 > RANLIB=$ac_cv_prog_RANLIB
3203 > if test -n "$RANLIB"; then
3204 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3205 > echo "${ECHO_T}$RANLIB" >&6
3206   else
3207 <  echo "$as_me: failed program was:" >&5
3208 < sed 's/^/| /' conftest.$ac_ext >&5
3596 <
3597 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3598 < echo "$as_me: WARNING: compilation failed" >&2;}
3207 >  echo "$as_me:$LINENO: result: no" >&5
3208 > echo "${ECHO_T}no" >&6
3209   fi
3600 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3210  
3211   fi
3212 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3213 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3214 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3215 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3216 < if test "${ac_cv_flibs+set}" = set; then
3212 > if test -z "$ac_cv_prog_RANLIB"; then
3213 >  ac_ct_RANLIB=$RANLIB
3214 >  # Extract the first word of "ranlib", so it can be a program name with args.
3215 > set dummy ranlib; ac_word=$2
3216 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3217 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3218 > if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3219    echo $ECHO_N "(cached) $ECHO_C" >&6
3220   else
3221 <  if test "x$F90LIBS" != "x"; then
3222 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3221 >  if test -n "$ac_ct_RANLIB"; then
3222 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3223   else
3224 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225 + for as_dir in $PATH
3226 + do
3227 +  IFS=$as_save_IFS
3228 +  test -z "$as_dir" && as_dir=.
3229 +  for ac_exec_ext in '' $ac_executable_extensions; do
3230 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3232 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233 +    break 2
3234 +  fi
3235 + done
3236 + done
3237  
3238 < ac_ext=f90
3239 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3240 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3241 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3238 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3239 > fi
3240 > fi
3241 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3242 > if test -n "$ac_ct_RANLIB"; then
3243 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3244 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3245 > else
3246 >  echo "$as_me:$LINENO: result: no" >&5
3247 > echo "${ECHO_T}no" >&6
3248 > fi
3249  
3250 < cat >conftest.$ac_ext <<_ACEOF
3250 >  RANLIB=$ac_ct_RANLIB
3251 > else
3252 >  RANLIB="$ac_cv_prog_RANLIB"
3253 > fi
3254  
3621 – program main
3255  
3256 +   # Extract the first word of "perl", so it can be a program name with args.
3257 + set dummy perl; ac_word=$2
3258 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3259 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3260 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3261 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3262 + else
3263 +  case $PERLINTERP in
3264 +  [\\/]* | ?:[\\/]*)
3265 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3266 +  ;;
3267 +  *)
3268 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3269 + for as_dir in $PATH
3270 + do
3271 +  IFS=$as_save_IFS
3272 +  test -z "$as_dir" && as_dir=.
3273 +  for ac_exec_ext in '' $ac_executable_extensions; do
3274 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3275 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3276 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3277 +    break 2
3278 +  fi
3279 + done
3280 + done
3281  
3282 < end program main
3283 <
3284 < _ACEOF
3627 <
3628 < # Compile and link our simple test program by passing a flag (argument
3629 < # 1 to this macro) to the Fortran 90 compiler in order to get
3630 < # "verbose" output that we can then parse for the Fortran 90 linker
3631 < # flags.
3632 < ac_save_F90FLAGS=$F90FLAGS
3633 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3634 <
3635 < (eval echo $as_me:3635: \"$ac_link\") >&5
3636 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3637 < echo "$ac_f90_v_output" >&5
3638 < F90FLAGS=$ac_save_F90FLAGS
3639 <
3640 < rm -f conftest.*
3641 < ac_ext=f90
3642 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3643 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3644 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3645 <
3646 < # If we are using xlf then replace all the commas with spaces.
3647 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3648 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3282 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3283 >  ;;
3284 > esac
3285   fi
3286 + PERLINTERP=$ac_cv_path_PERLINTERP
3287  
3288 < # If we are using Cray Fortran then delete quotes.
3289 < # Use "\"" instead of '"' for font-lock-mode.
3290 < # FIXME: a more general fix for quoted arguments with spaces?
3291 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3292 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3288 > if test -n "$PERLINTERP"; then
3289 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3290 > echo "${ECHO_T}$PERLINTERP" >&6
3291 > else
3292 >  echo "$as_me:$LINENO: result: no" >&5
3293 > echo "${ECHO_T}no" >&6
3294   fi
3295  
3296 < ac_cv_f90libs=
3296 >   ac_cv_path_perlinterp="$PERLINTERP"
3297 >   _sHpB='#!'
3298  
3299 < # Save positional arguments (if any)
3299 >
3300 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3301 > if test "${with_perl_shebang+set}" = set; then
3302 >  withval="$with_perl_shebang"
3303 >  opt_perl_shebang="$withval"
3304 > else
3305 >                opt_perl_shebang="not_set"
3306 > fi;
3307 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3311 > else
3312 >   case "$opt_perl_shebang" in
3313 >                      not_set  ) ax_cv_opt_perl_shebang=''
3314 >                               ;;
3315 >                         *     )
3316 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317 >                    esac
3318 >
3319 > fi
3320 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3323 >     then
3324 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328 >
3329 > # Automatic detection of sharpbang formula starts here
3330 >     else
3331 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3332 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3337 > else
3338 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339 >        if test "x$_somian_kspb_perl" == x
3340 >          then _somian_ksbp_warn_empty='durnit'
3341 >          else
3342 >          case "A$_somian_kspb_perl" in
3343 >                 A#!*perl* )
3344 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345 >                        ;;
3346 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3347 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348 >          esac
3349 >        fi
3350 >
3351 > fi
3352 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354 > # The above prints Checking ... result message to user.
3355 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356 >
3357 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3358 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360 >    fi
3361 > # Inform user after printing result value
3362 >    if test A${_somian_ksbp_warn_defau+set} == Aset
3363 >      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364 > echo "$as_me: Maybe Not good -" >&6;}
3365 >           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366 > echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367 >      else { echo "$as_me:$LINENO: OK Good result - " >&5
3368 > echo "$as_me: OK Good result - " >&6;}
3369 >           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370 > echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371 >    fi
3372 >  fi
3373 >
3374 > # Find a good install program.  We prefer a C program (faster),
3375 > # so one script is as good as another.  But avoid the broken or
3376 > # incompatible versions:
3377 > # SysV /etc/install, /usr/sbin/install
3378 > # SunOS /usr/etc/install
3379 > # IRIX /sbin/install
3380 > # AIX /bin/install
3381 > # AmigaOS /C/install, which installs bootblocks on floppy discs
3382 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385 > # OS/2's system install, which has a completely different semantic
3386 > # ./install, which can be erroneously created by make from ./install.sh.
3387 > echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388 > echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389 > if test -z "$INSTALL"; then
3390 > if test "${ac_cv_path_install+set}" = set; then
3391 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3392 > else
3393 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394 > for as_dir in $PATH
3395 > do
3396 >  IFS=$as_save_IFS
3397 >  test -z "$as_dir" && as_dir=.
3398 >  # Account for people who put trailing slashes in PATH elements.
3399 > case $as_dir/ in
3400 >  ./ | .// | /cC/* | \
3401 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402 >  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403 >  /usr/ucb/* ) ;;
3404 >  *)
3405 >    # OSF1 and SCO ODT 3.0 have their own names for install.
3406 >    # Don't use installbsd from OSF since it installs stuff as root
3407 >    # by default.
3408 >    for ac_prog in ginstall scoinst install; do
3409 >      for ac_exec_ext in '' $ac_executable_extensions; do
3410 >        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411 >          if test $ac_prog = install &&
3412 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413 >            # AIX install.  It has an incompatible calling convention.
3414 >            :
3415 >          elif test $ac_prog = install &&
3416 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417 >            # program-specific install script used by HP pwplus--don't use.
3418 >            :
3419 >          else
3420 >            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421 >            break 3
3422 >          fi
3423 >        fi
3424 >      done
3425 >    done
3426 >    ;;
3427 > esac
3428 > done
3429 >
3430 >
3431 > fi
3432 >  if test "${ac_cv_path_install+set}" = set; then
3433 >    INSTALL=$ac_cv_path_install
3434 >  else
3435 >    # As a last resort, use the slow shell script.  We don't cache a
3436 >    # path for INSTALL within a source directory, because that will
3437 >    # break other packages using the cache if that directory is
3438 >    # removed, or if the path is relative.
3439 >    INSTALL=$ac_install_sh
3440 >  fi
3441 > fi
3442 > echo "$as_me:$LINENO: result: $INSTALL" >&5
3443 > echo "${ECHO_T}$INSTALL" >&6
3444 >
3445 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446 > # It thinks the first close brace ends the variable substitution.
3447 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448 >
3449 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450 >
3451 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452 >
3453 > case "x$INSTALL" in
3454 >   x/*) ;;
3455 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3456 > esac
3457 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3458 > # Extract the first word of "ar", so it can be a program name with args.
3459 > set dummy ar; ac_word=$2
3460 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3461 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3462 > if test "${ac_cv_prog_AR+set}" = set; then
3463 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3464 > else
3465 >  if test -n "$AR"; then
3466 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3467 > else
3468 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3469 > for as_dir in $PATH
3470 > do
3471 >  IFS=$as_save_IFS
3472 >  test -z "$as_dir" && as_dir=.
3473 >  for ac_exec_ext in '' $ac_executable_extensions; do
3474 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3475 >    ac_cv_prog_AR="ar"
3476 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3477 >    break 2
3478 >  fi
3479 > done
3480 > done
3481 >
3482 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3483 > fi
3484 > fi
3485 > AR=$ac_cv_prog_AR
3486 > if test -n "$AR"; then
3487 >  echo "$as_me:$LINENO: result: $AR" >&5
3488 > echo "${ECHO_T}$AR" >&6
3489 > else
3490 >  echo "$as_me:$LINENO: result: no" >&5
3491 > echo "${ECHO_T}no" >&6
3492 > fi
3493 >
3494 > if test "$AR" = "NONE"; then
3495 >  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3496 > echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3497 >   { (exit 1); exit 1; }; }
3498 >  cat >confcache <<\_ACEOF
3499 > # This file is a shell script that caches the results of configure
3500 > # tests run on this system so they can be shared between configure
3501 > # scripts and configure runs, see configure's option --config-cache.
3502 > # It is not useful on other systems.  If it contains results you don't
3503 > # want to keep, you may remove or edit it.
3504 > #
3505 > # config.status only pays attention to the cache file if you give it
3506 > # the --recheck option to rerun configure.
3507 > #
3508 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3509 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3510 > # following values.
3511 >
3512 > _ACEOF
3513 >
3514 > # The following way of writing the cache mishandles newlines in values,
3515 > # but we know of no workaround that is simple, portable, and efficient.
3516 > # So, don't put newlines in cache variables' values.
3517 > # Ultrix sh set writes to stderr and can't be redirected directly,
3518 > # and sets the high bit in the cache file unless we assign to the vars.
3519 > {
3520 >  (set) 2>&1 |
3521 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3522 >    *ac_space=\ *)
3523 >      # `set' does not quote correctly, so add quotes (double-quote
3524 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3525 >      sed -n \
3526 >        "s/'/'\\\\''/g;
3527 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3528 >      ;;
3529 >    *)
3530 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3531 >      sed -n \
3532 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3533 >      ;;
3534 >    esac;
3535 > } |
3536 >  sed '
3537 >     t clear
3538 >     : clear
3539 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3540 >     t end
3541 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3542 >     : end' >>confcache
3543 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3544 >  if test -w $cache_file; then
3545 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3546 >    cat confcache >$cache_file
3547 >  else
3548 >    echo "not updating unwritable cache $cache_file"
3549 >  fi
3550 > fi
3551 > rm -f confcache
3552 >  exit 1
3553 > fi
3554 > # Extract the first word of "ps", so it can be a program name with args.
3555 > set dummy ps; ac_word=$2
3556 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3557 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3558 > if test "${ac_cv_path_PS+set}" = set; then
3559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3560 > else
3561 >  case $PS in
3562 >  [\\/]* | ?:[\\/]*)
3563 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3564 >  ;;
3565 >  *)
3566 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3567 > for as_dir in $PATH
3568 > do
3569 >  IFS=$as_save_IFS
3570 >  test -z "$as_dir" && as_dir=.
3571 >  for ac_exec_ext in '' $ac_executable_extensions; do
3572 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3573 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3574 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3575 >    break 2
3576 >  fi
3577 > done
3578 > done
3579 >
3580 >  ;;
3581 > esac
3582 > fi
3583 > PS=$ac_cv_path_PS
3584 >
3585 > if test -n "$PS"; then
3586 >  echo "$as_me:$LINENO: result: $PS" >&5
3587 > echo "${ECHO_T}$PS" >&6
3588 > else
3589 >  echo "$as_me:$LINENO: result: no" >&5
3590 > echo "${ECHO_T}no" >&6
3591 > fi
3592 >
3593 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3594 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3595 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3596 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3597 > else
3598 >
3599 >        if $PS ax -o rss > /dev/null 2>&1; then
3600 >                ac_cv_prog_ps_ax=yes
3601 >        else
3602 >                ac_cv_prog_ps_ax=no
3603 >        fi
3604 >        if $PS -ef -o rss > /dev/null 2>&1; then
3605 >                ac_cv_prog_ps_ef=yes
3606 >        else
3607 >                ac_cv_prog_ps_ef=no
3608 >        fi
3609 >        if test "$ac_cv_prog_ps_ax" = yes; then
3610 >                ac_cv_prog_ps_syntax=BSD
3611 >        else
3612 >                if test "$ac_cv_prog_ps_ef" = yes; then
3613 >                        ac_cv_prog_ps_syntax=POSIX
3614 >                else
3615 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3616 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3617 >   { (exit 1); exit 1; }; }
3618 >                fi
3619 >        fi
3620 >
3621 > fi
3622 > echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3623 > echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3624 >
3625 > cat >>confdefs.h <<_ACEOF
3626 > #define PSCOMMAND $PS
3627 > _ACEOF
3628 >
3629 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3630 >
3631 > cat >>confdefs.h <<\_ACEOF
3632 > #define PSTYPE_IS_BSD 1
3633 > _ACEOF
3634 >
3635 > else
3636 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637 >
3638 > cat >>confdefs.h <<\_ACEOF
3639 > #define PSTYPE_IS_POSIX 1
3640 > _ACEOF
3641 >
3642 >   else
3643 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3644 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3645 >   { (exit 1); exit 1; }; }
3646 >   fi
3647 > fi
3648 >
3649 > ac_ext=${FC_SRCEXT-f}
3650 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3651 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3652 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3653 >
3654 >
3655 > echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3656 > echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3657 > if test "${ac_cv_fc_srcext_F90+set}" = set; then
3658 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3659 > else
3660 >  ac_ext=F90
3661 > ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3662 > FCFLAGS_SRCEXT=""
3663 > ac_cv_fc_srcext_F90=unknown
3664 > for ac_flag in none -qsuffix=f=F90 -Tf; do
3665 >  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3666 >  cat >conftest.$ac_ext <<_ACEOF
3667 >      program main
3668 >
3669 >      end
3670 > _ACEOF
3671 > rm -f conftest.$ac_objext
3672 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3673 >  (eval $ac_compile) 2>conftest.er1
3674 >  ac_status=$?
3675 >  grep -v '^ *+' conftest.er1 >conftest.err
3676 >  rm -f conftest.er1
3677 >  cat conftest.err >&5
3678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679 >  (exit $ac_status); } &&
3680 >         { ac_try='test -z "$ac_fc_werror_flag"
3681 >                         || test ! -s conftest.err'
3682 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3683 >  (eval $ac_try) 2>&5
3684 >  ac_status=$?
3685 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3686 >  (exit $ac_status); }; } &&
3687 >         { ac_try='test -s conftest.$ac_objext'
3688 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3689 >  (eval $ac_try) 2>&5
3690 >  ac_status=$?
3691 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692 >  (exit $ac_status); }; }; then
3693 >  ac_cv_fc_srcext_F90=$ac_flag; break
3694 > else
3695 >  echo "$as_me: failed program was:" >&5
3696 > sed 's/^/| /' conftest.$ac_ext >&5
3697 >
3698 > fi
3699 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700 > done
3701 > rm -f conftest.$ac_objext conftest.F90
3702 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3703 >
3704 > fi
3705 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3706 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3707 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3708 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3709 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3710 >   { (exit 1); exit 1; }; }
3711 > else
3712 >  FC_SRCEXT=F90
3713 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3714 >    FCFLAGS_SRCEXT=""
3715 >    FCFLAGS_F90=""
3716 >  else
3717 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3718 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3719 >  fi
3720 >
3721 >
3722 > fi
3723 >
3724 >
3725 >
3726 >
3727 >
3728 > # Try to determine native compiler flags that allow us to use F90 suffix
3729 > # for preprocessed f90 source.
3730 >
3731 > if test "$ac_test_PREPFLAG" != "set"; then
3732 >  PREPFLAG=""
3733 >  case "${host_cpu}-${host_os}" in
3734 >
3735 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736 >                    PREPFLAG="-fpp1 "
3737 >                fi;;
3738 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3739 >                    PREPFLAG="-qsuffix=cpp=F90 "
3740 >                fi;;
3741 >  *darwin*)
3742 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743 >                PREPFLAG="-qsuffix=cpp=F90 "
3744 >        fi;;
3745 >  esac
3746 >
3747 >  if test -z "$PREPFLAG"; then
3748 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3749 > echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3750 >        PREPFLAG=""
3751 >  fi
3752 >
3753 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3754 > echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755 >
3756 >
3757 >  ac_ext=${FC_SRCEXT-f}
3758 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3759 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3760 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3761 >
3762 >  ac_save_ext=$ac_ext
3763 >  ac_ext=F90
3764 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765 >
3766 >  if test "$PREPFLAG"; then
3767 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3768 > fi
3769 >
3770 >    cat >conftest.$ac_ext <<_ACEOF
3771 >
3772 >
3773 > program conftest
3774 >  integer :: i
3775 >  i = 1
3776 > end program conftest
3777 >
3778 > _ACEOF
3779 > rm -f conftest.$ac_objext
3780 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3781 >  (eval $ac_compile) 2>conftest.er1
3782 >  ac_status=$?
3783 >  grep -v '^ *+' conftest.er1 >conftest.err
3784 >  rm -f conftest.er1
3785 >  cat conftest.err >&5
3786 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787 >  (exit $ac_status); } &&
3788 >         { ac_try='test -z "$ac_fc_werror_flag"
3789 >                         || test ! -s conftest.err'
3790 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791 >  (eval $ac_try) 2>&5
3792 >  ac_status=$?
3793 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794 >  (exit $ac_status); }; } &&
3795 >         { ac_try='test -s conftest.$ac_objext'
3796 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3797 >  (eval $ac_try) 2>&5
3798 >  ac_status=$?
3799 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800 >  (exit $ac_status); }; }; then
3801 >  prepflagworks=1
3802 > else
3803 >  echo "$as_me: failed program was:" >&5
3804 > sed 's/^/| /' conftest.$ac_ext >&5
3805 >
3806 > prepflagworks=0
3807 > fi
3808 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809 >
3810 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811 >  ac_ext=$ac_save_ext
3812 >  ac_ext=${FC_SRCEXT-f}
3813 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3814 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3815 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3816 >
3817 >
3818 >  if test "$prepflagworks" = 1; then
3819 >    echo "$as_me:$LINENO: result: yes" >&5
3820 > echo "${ECHO_T}yes" >&6
3821 >    FCFLAGS_SRCEXT="${PREPFLAG}"
3822 >
3823 >  else
3824 >    echo "$as_me:$LINENO: result: no" >&5
3825 > echo "${ECHO_T}no" >&6
3826 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3827 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3828 >   { (exit 1); exit 1; }; }
3829 >  fi
3830 > fi
3831 >
3832 >
3833 >
3834 >
3835 >
3836 > # Try to determine native compiler flags that allow us to use F90 suffix
3837 > # for preprocessed f90 source with -D type defines
3838 >
3839 > if test "$ac_test_PREPDEFFLAG" != "set"; then
3840 >  PREPDEFFLAG=""
3841 >  case "${host_cpu}-${host_os}" in
3842 >
3843 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844 >                    PREPDEFFLAG=" "
3845 >                fi;;
3846 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847 >                    PREPDEFFLAG="-WF,"
3848 >                fi;;
3849 >  *darwin*)
3850 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851 >                PREPDEFFLAG="-WF,"
3852 >        fi;;
3853 >  esac
3854 >
3855 >  if test -z "$PREPDEFFLAG"; then
3856 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3857 > echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3858 >        PREPDEFFLAG=" "
3859 >  fi
3860 >
3861 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3862 > echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863 >
3864 >
3865 >  ac_ext=${FC_SRCEXT-f}
3866 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3867 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3868 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3869 >
3870 >  ac_save_ext=$ac_ext
3871 >  ac_ext=F90
3872 >  ac_save_FCFLAGS=$FCFLAGS
3873 >
3874 >  if test "$PREPDEFFLAG"; then
3875 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876 > fi
3877 >
3878 >    cat >conftest.$ac_ext <<_ACEOF
3879 >
3880 >
3881 > program conftest
3882 >  integer :: i
3883 > #ifdef TEST
3884 >  i = 1
3885 > #else
3886 >  choke me
3887 > #endif
3888 > end program conftest
3889 >
3890 > _ACEOF
3891 > rm -f conftest.$ac_objext
3892 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3893 >  (eval $ac_compile) 2>conftest.er1
3894 >  ac_status=$?
3895 >  grep -v '^ *+' conftest.er1 >conftest.err
3896 >  rm -f conftest.er1
3897 >  cat conftest.err >&5
3898 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899 >  (exit $ac_status); } &&
3900 >         { ac_try='test -z "$ac_fc_werror_flag"
3901 >                         || test ! -s conftest.err'
3902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903 >  (eval $ac_try) 2>&5
3904 >  ac_status=$?
3905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3906 >  (exit $ac_status); }; } &&
3907 >         { ac_try='test -s conftest.$ac_objext'
3908 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3909 >  (eval $ac_try) 2>&5
3910 >  ac_status=$?
3911 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912 >  (exit $ac_status); }; }; then
3913 >  prepdefflagworks=1
3914 > else
3915 >  echo "$as_me: failed program was:" >&5
3916 > sed 's/^/| /' conftest.$ac_ext >&5
3917 >
3918 > prepdefflagworks=0
3919 > fi
3920 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921 >
3922 >  FCFLAGS=$ac_save_FCFLAGS
3923 >  ac_ext=$ac_save_ext
3924 >  ac_ext=${FC_SRCEXT-f}
3925 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3926 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3927 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3928 >
3929 >
3930 >  if test "$prepdefflagworks" = 1; then
3931 >    echo "$as_me:$LINENO: result: yes" >&5
3932 > echo "${ECHO_T}yes" >&6
3933 >
3934 >  else
3935 >    echo "$as_me:$LINENO: result: no" >&5
3936 > echo "${ECHO_T}no" >&6
3937 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3938 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3939 >   { (exit 1); exit 1; }; }
3940 >  fi
3941 > fi
3942 >
3943 > ac_ext=${FC_SRCEXT-f}
3944 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3945 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3946 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3947 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3948 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3949 > if test "${ac_cv_prog_fc_v+set}" = set; then
3950 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3951 > else
3952 >  cat >conftest.$ac_ext <<_ACEOF
3953 >      program main
3954 >
3955 >      end
3956 > _ACEOF
3957 > rm -f conftest.$ac_objext
3958 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959 >  (eval $ac_compile) 2>conftest.er1
3960 >  ac_status=$?
3961 >  grep -v '^ *+' conftest.er1 >conftest.err
3962 >  rm -f conftest.er1
3963 >  cat conftest.err >&5
3964 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965 >  (exit $ac_status); } &&
3966 >         { ac_try='test -z "$ac_fc_werror_flag"
3967 >                         || test ! -s conftest.err'
3968 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969 >  (eval $ac_try) 2>&5
3970 >  ac_status=$?
3971 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972 >  (exit $ac_status); }; } &&
3973 >         { ac_try='test -s conftest.$ac_objext'
3974 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975 >  (eval $ac_try) 2>&5
3976 >  ac_status=$?
3977 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978 >  (exit $ac_status); }; }; then
3979 >  ac_cv_prog_fc_v=
3980 > # Try some options frequently used verbose output
3981 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3982 >  cat >conftest.$ac_ext <<_ACEOF
3983 >      program main
3984 >
3985 >      end
3986 > _ACEOF
3987 >
3988 > # Compile and link our simple test program by passing a flag (argument
3989 > # 1 to this macro) to the Fortran compiler in order to get
3990 > # "verbose" output that we can then parse for the Fortran linker
3991 > # flags.
3992 > ac_save_FFLAGS=$FCFLAGS
3993 > FCFLAGS="$FCFLAGS $ac_verb"
3994 > (eval echo $as_me:3994: \"$ac_link\") >&5
3995 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3996 > echo "$ac_fc_v_output" >&5
3997 > FCFLAGS=$ac_save_FFLAGS
3998 >
3999 > rm -f conftest*
4000 >
4001 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4002 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4003 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4004 > ac_fc_v_output="`echo $ac_fc_v_output |
4005 >        grep 'LPATH is:' |
4006 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4007 >
4008 > case $ac_fc_v_output in
4009 >  # If we are using xlf then replace all the commas with spaces.
4010 >  *xlfentry*)
4011 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4012 >
4013 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4014 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4015 >  *mGLOB_options_string*)
4016 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4017 >
4018 >  # If we are using Cray Fortran then delete quotes.
4019 >  # Use "\"" instead of '"' for font-lock-mode.
4020 >  # FIXME: a more general fix for quoted arguments with spaces?
4021 >  *cft90*)
4022 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4023 > esac
4024 >
4025 >
4026 >  # look for -l* and *.a constructs in the output
4027 >  for ac_arg in $ac_fc_v_output; do
4028 >     case $ac_arg in
4029 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030 >          ac_cv_prog_fc_v=$ac_verb
4031 >          break 2 ;;
4032 >     esac
4033 >  done
4034 > done
4035 > if test -z "$ac_cv_prog_fc_v"; then
4036 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4037 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4038 > fi
4039 > else
4040 >  echo "$as_me: failed program was:" >&5
4041 > sed 's/^/| /' conftest.$ac_ext >&5
4042 >
4043 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4044 > echo "$as_me: WARNING: compilation failed" >&2;}
4045 > fi
4046 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047 >
4048 > fi
4049 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4050 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4051 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4052 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4053 > if test "${ac_cv_fc_libs+set}" = set; then
4054 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4055 > else
4056 >  if test "x$FCLIBS" != "x"; then
4057 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058 > else
4059 >
4060 > cat >conftest.$ac_ext <<_ACEOF
4061 >      program main
4062 >
4063 >      end
4064 > _ACEOF
4065 >
4066 > # Compile and link our simple test program by passing a flag (argument
4067 > # 1 to this macro) to the Fortran compiler in order to get
4068 > # "verbose" output that we can then parse for the Fortran linker
4069 > # flags.
4070 > ac_save_FFLAGS=$FCFLAGS
4071 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4072 > (eval echo $as_me:4072: \"$ac_link\") >&5
4073 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4074 > echo "$ac_fc_v_output" >&5
4075 > FCFLAGS=$ac_save_FFLAGS
4076 >
4077 > rm -f conftest*
4078 >
4079 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4080 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4081 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4082 > ac_fc_v_output="`echo $ac_fc_v_output |
4083 >        grep 'LPATH is:' |
4084 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4085 >
4086 > case $ac_fc_v_output in
4087 >  # If we are using xlf then replace all the commas with spaces.
4088 >  *xlfentry*)
4089 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4090 >
4091 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4092 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4093 >  *mGLOB_options_string*)
4094 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4095 >
4096 >  # If we are using Cray Fortran then delete quotes.
4097 >  # Use "\"" instead of '"' for font-lock-mode.
4098 >  # FIXME: a more general fix for quoted arguments with spaces?
4099 >  *cft90*)
4100 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101 > esac
4102 >
4103 >
4104 >
4105 > ac_cv_fc_libs=
4106 >
4107 > # Save positional arguments (if any)
4108   ac_save_positional="$@"
4109  
4110 < set X $ac_f90_v_output
4110 > set X $ac_fc_v_output
4111   while test $# != 1; do
4112    shift
4113    ac_arg=$1
4114    case $ac_arg in
4115          [\\/]*.a | ?:[\\/]*.a)
4116              ac_exists=false
4117 <  for ac_i in $ac_cv_f90libs; do
4117 >  for ac_i in $ac_cv_fc_libs; do
4118      if test x"$ac_arg" = x"$ac_i"; then
4119        ac_exists=true
4120        break
# Line 3677 | Line 4124 | else
4124    if test x"$ac_exists" = xtrue; then
4125    :
4126   else
4127 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4127 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4128   fi
4129  
4130            ;;
4131          -bI:*)
4132              ac_exists=false
4133 <  for ac_i in $ac_cv_f90libs; do
4133 >  for ac_i in $ac_cv_fc_libs; do
4134      if test x"$ac_arg" = x"$ac_i"; then
4135        ac_exists=true
4136        break
# Line 3695 | Line 4142 | else
4142   else
4143    if test "$ac_compiler_gnu" = yes; then
4144    for ac_link_opt in $ac_arg; do
4145 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4145 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146    done
4147   else
4148 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4148 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149   fi
4150   fi
4151  
4152            ;;
4153            # Ignore these flags.
4154 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4154 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155            ;;
4156          -lkernel32)
4157 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4157 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4158            ;;
4159          -[LRuY])
4160            # These flags, when seen by themselves, take an argument.
4161            # We remove the space between option and argument and re-iterate
4162            # unless we find an empty arg or a new option (starting with -)
4163            case $2 in
4164 <             "" | -*);;
4165 <             *)
4164 >             "" | -*);;
4165 >             *)
4166                  ac_arg="$ac_arg$2"
3720 –
4167                  shift; shift
4168                  set X $ac_arg "$@"
4169                  ;;
# Line 3726 | Line 4172 | fi
4172          -YP,*)
4173            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4174                ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_j" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 3737 | Line 4183 | else
4183    :
4184   else
4185    ac_arg="$ac_arg $ac_j"
4186 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4186 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4187   fi
4188  
4189            done
4190            ;;
4191          -[lLR]*)
4192              ac_exists=false
4193 <  for ac_i in $ac_cv_f90libs; do
4193 >  for ac_i in $ac_cv_fc_libs; do
4194      if test x"$ac_arg" = x"$ac_i"; then
4195        ac_exists=true
4196        break
# Line 3754 | Line 4200 | else
4200    if test x"$ac_exists" = xtrue; then
4201    :
4202   else
4203 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4203 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204   fi
4205  
4206            ;;
# Line 3769 | Line 4215 | case `(uname -sr) 2>/dev/null` in
4215   # must begin with a "/").
4216   case `(uname -sr) 2>/dev/null` in
4217     "SunOS 5"*)
4218 <      ac_ld_run_path=`echo $ac_f90_v_output |
4218 >      ac_ld_run_path=`echo $ac_fc_v_output |
4219                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4220        test "x$ac_ld_run_path" != x &&
3775 –
4221          if test "$ac_compiler_gnu" = yes; then
4222    for ac_link_opt in $ac_ld_run_path; do
4223 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4223 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224    done
4225   else
4226 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4226 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227   fi
4228        ;;
4229   esac
4230 < fi # test "x$F90LIBS" = "x"
4230 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231  
4232   fi
4233 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4234 < echo "${ECHO_T}$ac_cv_flibs" >&6
4235 < F90LIBS="$ac_cv_f90libs"
4233 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4234 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4235 > FCLIBS="$ac_cv_fc_libs"
4236  
3792 – ac_ext=f90
3793 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3794 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3795 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4237  
4238 + ac_ext=${FC_SRCEXT-f}
4239 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4240 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4241 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4242  
4243 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4244 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4245 < if test "${ac_cv_f90_mangling+set}" = set; then
4243 >
4244 > ac_ext=${FC_SRCEXT-f}
4245 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4246 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4247 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4248 >
4249 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4250 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4251 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4252    echo $ECHO_N "(cached) $ECHO_C" >&6
4253   else
4254 <  ac_ext=f90
4255 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4256 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4257 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3807 < cat >conftest.$ac_ext <<_ACEOF
3808 < subroutine foobar()
3809 < return
3810 < end
3811 < subroutine foo_bar()
3812 < return
3813 < end
3814 < _ACEOF
3815 < rm -f conftest.$ac_objext
3816 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3817 <  (eval $ac_compile) 2>conftest.er1
3818 <  ac_status=$?
3819 <  grep -v '^ *+' conftest.er1 >conftest.err
3820 <  rm -f conftest.er1
3821 <  cat conftest.err >&5
3822 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3823 <  (exit $ac_status); } &&
3824 <         { ac_try='test -z "$ac_f90_werror_flag"
3825 <                         || test ! -s conftest.err'
3826 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3827 <  (eval $ac_try) 2>&5
3828 <  ac_status=$?
3829 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3830 <  (exit $ac_status); }; } &&
3831 <         { ac_try='test -s conftest.$ac_objext'
3832 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3833 <  (eval $ac_try) 2>&5
3834 <  ac_status=$?
3835 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3836 <  (exit $ac_status); }; }; then
3837 <  mv conftest.$ac_objext cf90_test.$ac_objext
3838 <
3839 <  ac_ext=c
4254 >  ac_fc_dm_save_LIBS=$LIBS
4255 > LIBS="$LIBS $FCLIBS"
4256 > ac_fortran_dm_var=FC_DUMMY_MAIN
4257 > ac_ext=c
4258   ac_cpp='$CPP $CPPFLAGS'
4259   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4260   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4261   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4262  
4263 <  ac_save_LIBS=$LIBS
4264 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3847 <
3848 <  ac_success=no
3849 <  for ac_foobar in foobar FOOBAR; do
3850 <    for ac_underscore in "" "_"; do
3851 <      ac_func="$ac_foobar$ac_underscore"
3852 <      cat >conftest.$ac_ext <<_ACEOF
4263 > # First, try linking without a dummy main:
4264 > cat >conftest.$ac_ext <<_ACEOF
4265   /* confdefs.h.  */
4266   _ACEOF
4267   cat confdefs.h >>conftest.$ac_ext
4268   cat >>conftest.$ac_ext <<_ACEOF
4269   /* end confdefs.h.  */
4270  
4271 < /* Override any gcc2 internal prototype to avoid an error.  */
4272 < #ifdef __cplusplus
4273 < extern "C"
4271 > #ifdef FC_DUMMY_MAIN
4272 > #ifndef FC_DUMMY_MAIN_EQ_F77
4273 > #  ifdef __cplusplus
4274 >     extern "C"
4275 > #  endif
4276 >   int FC_DUMMY_MAIN() { return 1; }
4277   #endif
4278 < /* We use char because int might match the return type of a gcc2
3864 <   builtin and then its argument prototype would still apply.  */
3865 < char $ac_func ();
4278 > #endif
4279   int
4280   main ()
4281   {
4282 < $ac_func ();
4282 >
4283    ;
4284    return 0;
4285   }
# Line 3893 | Line 4306 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4306    ac_status=$?
4307    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308    (exit $ac_status); }; }; then
4309 <  ac_success=yes; break 2
4309 >  ac_cv_fortran_dummy_main=none
4310   else
4311    echo "$as_me: failed program was:" >&5
4312   sed 's/^/| /' conftest.$ac_ext >&5
4313  
4314 + ac_cv_fortran_dummy_main=unknown
4315   fi
4316   rm -f conftest.err conftest.$ac_objext \
4317        conftest$ac_exeext conftest.$ac_ext
3904 –    done
3905 –  done
4318  
4319 <  if test "$ac_success" = "yes"; then
4320 <     case $ac_foobar in
4321 <        foobar)
3910 <           ac_case=lower
3911 <           ac_foo_bar=foo_bar
3912 <           ;;
3913 <        FOOBAR)
3914 <           ac_case=upper
3915 <           ac_foo_bar=FOO_BAR
3916 <           ;;
3917 <     esac
3918 <
3919 <     ac_success_extra=no
3920 <     for ac_extra in "" "_"; do
3921 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3922 <
3923 <        cat >conftest.$ac_ext <<_ACEOF
4319 > if test $ac_cv_fortran_dummy_main = unknown; then
4320 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4321 >     cat >conftest.$ac_ext <<_ACEOF
4322   /* confdefs.h.  */
4323   _ACEOF
4324   cat confdefs.h >>conftest.$ac_ext
4325   cat >>conftest.$ac_ext <<_ACEOF
4326   /* end confdefs.h.  */
4327 <
4328 < /* Override any gcc2 internal prototype to avoid an error.  */
4329 < #ifdef __cplusplus
4330 < extern "C"
4327 > #define $ac_fortran_dm_var $ac_func
4328 > #ifdef FC_DUMMY_MAIN
4329 > #ifndef FC_DUMMY_MAIN_EQ_F77
4330 > #  ifdef __cplusplus
4331 >     extern "C"
4332 > #  endif
4333 >   int FC_DUMMY_MAIN() { return 1; }
4334   #endif
4335 < /* We use char because int might match the return type of a gcc2
3935 <   builtin and then its argument prototype would still apply.  */
3936 < char $ac_func ();
4335 > #endif
4336   int
4337   main ()
4338   {
4339 < $ac_func ();
4339 >
4340    ;
4341    return 0;
4342   }
# Line 3964 | Line 4363 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4363    ac_status=$?
4364    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4365    (exit $ac_status); }; }; then
4366 <  ac_success_extra=yes; break
4366 >  ac_cv_fortran_dummy_main=$ac_func; break
4367   else
4368    echo "$as_me: failed program was:" >&5
4369   sed 's/^/| /' conftest.$ac_ext >&5
# Line 3972 | Line 4371 | rm -f conftest.err conftest.$ac_objext \
4371   fi
4372   rm -f conftest.err conftest.$ac_objext \
4373        conftest$ac_exeext conftest.$ac_ext
4374 <     done
4374 >   done
4375 > fi
4376 > ac_ext=${FC_SRCEXT-f}
4377 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4378 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4379 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4380 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4381 > rm -f conftest*
4382 > LIBS=$ac_fc_dm_save_LIBS
4383  
4384 <     if test "$ac_success_extra" = "yes"; then
4385 <        ac_cv_f90_mangling="$ac_case case"
4386 <        if test -z "$ac_underscore"; then
4387 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4388 <        else
4389 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4384 > fi
4385 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4386 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4387 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4388 > if test "$FC_DUMMY_MAIN" != unknown; then
4389 >  if test $FC_DUMMY_MAIN != none; then
4390  
4391 <        fi
4392 <        if test -z "$ac_extra"; then
4393 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3987 <        else
3988 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3989 <        fi
3990 <      else
3991 <        ac_cv_f90_mangling="unknown"
3992 <      fi
3993 <  else
3994 <     ac_cv_f90_mangling="unknown"
4391 > cat >>confdefs.h <<_ACEOF
4392 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4393 > _ACEOF
4394  
4395 <  fi
4395 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4396  
4397 <  LIBS=$ac_save_LIBS
4398 <  ac_ext=f90
4399 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4400 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4401 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4402 <  rm -f cf90_test* conftest*
4403 < else
4404 <  echo "$as_me: failed program was:" >&5
4405 < sed 's/^/| /' conftest.$ac_ext >&5
4406 <
4407 < fi
4408 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4409 < ac_ext=f90
4410 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4411 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4412 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4413 <
4414 < fi
4415 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4416 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4417 <
4418 <
4419 <
4420 < case $ac_cv_f90_mangling in
4421 <  "lower case, no underscore, no extra underscore")
4422 <          cat >>confdefs.h <<\_ACEOF
4423 < #define F90_FUNC(name,NAME) name
4424 < _ACEOF
4425 <
4426 <          cat >>confdefs.h <<\_ACEOF
4427 < #define F90_FUNC_(name,NAME) name
4428 < _ACEOF
4429 < ;;
4430 <  "lower case, no underscore, extra underscore")
4431 <          cat >>confdefs.h <<\_ACEOF
4432 < #define F90_FUNC(name,NAME) name
4433 < _ACEOF
4434 <
4435 <          cat >>confdefs.h <<\_ACEOF
4436 < #define F90_FUNC_(name,NAME) name ## _
4437 < _ACEOF
4438 < ;;
4439 <  "lower case, underscore, no extra underscore")
4440 <          cat >>confdefs.h <<\_ACEOF
4441 < #define F90_FUNC(name,NAME) name ## _
4442 < _ACEOF
4443 <
4444 <          cat >>confdefs.h <<\_ACEOF
4445 < #define F90_FUNC_(name,NAME) name ## _
4446 < _ACEOF
4447 < ;;
4448 <  "lower case, underscore, extra underscore")
4449 <          cat >>confdefs.h <<\_ACEOF
4450 < #define F90_FUNC(name,NAME) name ## _
4451 < _ACEOF
4452 <
4453 <          cat >>confdefs.h <<\_ACEOF
4454 < #define F90_FUNC_(name,NAME) name ## __
4455 < _ACEOF
4456 < ;;
4457 <  "upper case, no underscore, no extra underscore")
4458 <          cat >>confdefs.h <<\_ACEOF
4459 < #define F90_FUNC(name,NAME) NAME
4460 < _ACEOF
4461 <
4462 <          cat >>confdefs.h <<\_ACEOF
4463 < #define F90_FUNC_(name,NAME) NAME
4464 < _ACEOF
4465 < ;;
4466 <  "upper case, no underscore, extra underscore")
4467 <          cat >>confdefs.h <<\_ACEOF
4468 < #define F90_FUNC(name,NAME) NAME
4469 < _ACEOF
4470 <
4471 <          cat >>confdefs.h <<\_ACEOF
4472 < #define F90_FUNC_(name,NAME) NAME ## _
4473 < _ACEOF
4474 < ;;
4475 <  "upper case, underscore, no extra underscore")
4476 <          cat >>confdefs.h <<\_ACEOF
4477 < #define F90_FUNC(name,NAME) NAME ## _
4478 < _ACEOF
4479 <
4480 <          cat >>confdefs.h <<\_ACEOF
4481 < #define F90_FUNC_(name,NAME) NAME ## _
4482 < _ACEOF
4483 < ;;
4484 <  "upper case, underscore, extra underscore")
4485 <          cat >>confdefs.h <<\_ACEOF
4486 < #define F90_FUNC(name,NAME) NAME ## _
4487 < _ACEOF
4488 <
4489 <          cat >>confdefs.h <<\_ACEOF
4490 < #define F90_FUNC_(name,NAME) NAME ## __
4491 < _ACEOF
4492 < ;;
4493 <  *)
4494 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4495 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4496 <          ;;
4497 < esac
4498 <
4499 <
4500 <
4501 <
4502 <
4503 < echo "$as_me:$LINENO: checking for module suffix" >&5
4504 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4505 < rm -f conftest*
4506 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4507 < rm -f work*
4508 < cat >conftest.f90 <<EOF
4509 <        module conftest
4510 <        integer n
4511 <        parameter (n=1)
4512 <        end module conftest
4513 < EOF
4514 < # SGI and absoft compilers generates module name in upper case!
4515 < testname="conftest"
4516 < modcase="lower"
4517 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4518 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4519 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4520 <    if test -z "$MOD" ; then
4521 <        MOD=`ls CONFTEST* 2>/dev/null \
4522 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4523 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4524 <        if test -n "$MOD" ; then
4525 <            testname="CONFTEST"
4526 <            modcase="upper"
4527 <        fi
4528 <    fi
4529 <    if test -z "$MOD" ; then
4530 <        echo "$as_me:$LINENO: result: unknown" >&5
4531 < echo "${ECHO_T}unknown" >&6
4532 <        # Use mod if we can't figure it out
4533 <        MOD="mod"
4534 <    else
4535 <        echo "$as_me:$LINENO: result: $MOD" >&5
4536 < echo "${ECHO_T}$MOD" >&6
4537 <    fi
4538 <    if test -s work.pcl ; then
4539 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4540 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4541 <    fi
4542 < else
4543 <    echo "$as_me:$LINENO: result: unknown" >&5
4544 < echo "${ECHO_T}unknown" >&6
4545 < fi
4546 <
4547 <
4548 <
4549 <
4550 <
4551 < # Check for module include path (some use -I, some (Solaris) use -M, some
4552 < # (absoft) use -p).
4553 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4554 < # specified, work.pcl and work.pc are created.  However, if you specify
4555 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4556 < # Use the module made above
4557 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4558 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4559 < rm -f conftest*
4560 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4561 < rm -f work*
4562 < cat >conftest.f90 <<EOF
4563 <        module conftest
4564 <        integer n
4565 <        parameter (n=1)
4566 <        end module conftest
4567 < EOF
4568 < # SGI and absoft compilers generates module name in upper case!
4569 < testname="conftest"
4570 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4571 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4572 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4573 <   if test -n "$mod" ; then
4574 <      testname="CONFTEST"
4575 <   fi
4576 <   madedir=0
4577 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4578 <   cp $testname.$MOD conf
4579 <   rm -f conftest* CONFTEST*
4580 <   cat >conftest1.f90 <<EOF
4581 <        program main
4582 <        use conftest
4583 <        print *, n
4584 <        end
4585 < EOF
4586 <   F90_WORK_FILES_ARG=""
4587 <   F90MODINCSPEC=""
4588 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4589 <       MODDIRFLAG="-I"
4590 <       F90MODINCSPEC="-I<dir>"
4591 <       echo "$as_me:$LINENO: result: -I" >&5
4592 < echo "${ECHO_T}-I" >&6
4593 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4594 <       MODDIRFLAG="-M"
4595 <       F90MODINCSPEC="-M<dir>"
4596 <       echo "$as_me:$LINENO: result: -M" >&5
4597 < echo "${ECHO_T}-M" >&6
4598 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4599 <       MODDIRFLAG="-p"
4600 <       F90MODINCSPEC="-p<dir>"
4601 <       echo "$as_me:$LINENO: result: -p" >&5
4602 < echo "${ECHO_T}-p" >&6
4603 <   elif test -s work.pc ; then
4604 <        cp work.pc conf/mpimod.pc
4605 <        echo "mpimod.pc" > conf/mpimod.pcl
4606 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4607 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4608 <            MODDIRFLAG='-cl,mpimod.pcl'
4609 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4610 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4611 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4612 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4613 <
4614 <        else
4615 <            # The version of the Intel compiler that I have refuses to let
4616 <            # you put the "work catalog" list anywhere but the current
4617 <            # directory. For example, you cannot in
4618 <         :
4619 <        fi
4620 <   fi
4621 <   if test -z "MODDIRFLAG" ; then
4622 <       echo "$as_me:$LINENO: result: unknown" >&5
4623 < echo "${ECHO_T}unknown" >&6
4624 <   fi
4625 <
4626 <
4627 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4628 <   if test $madedir = 1 ; then rmdir conf ; fi
4629 < fi
4630 <
4631 <
4632 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4633 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4634 < if test "${ac_cv_f90_module_names+set}" = set; then
4635 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4636 < else
4637 <  ac_ext=f90
4638 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4639 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4640 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4641 <
4642 < # carry out the test in a new directory, so that we don't miss anything
4643 < mkdir conftest
4644 < cd conftest
4645 < cat >conftest.$ac_ext <<_ACEOF
4646 < MODULE Bar
4647 < END MODULE Bar
4648 < _ACEOF
4649 < rm -f conftest.$ac_objext
4650 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4651 <  (eval $ac_compile) 2>conftest.er1
4652 <  ac_status=$?
4653 <  grep -v '^ *+' conftest.er1 >conftest.err
4654 <  rm -f conftest.er1
4655 <  cat conftest.err >&5
4656 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4657 <  (exit $ac_status); } &&
4658 <         { ac_try='test -z "$ac_f90_werror_flag"
4659 <                         || test ! -s conftest.err'
4660 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4661 <  (eval $ac_try) 2>&5
4662 <  ac_status=$?
4663 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4664 <  (exit $ac_status); }; } &&
4665 <         { ac_try='test -s conftest.$ac_objext'
4666 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4667 <  (eval $ac_try) 2>&5
4668 <  ac_status=$?
4669 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4670 <  (exit $ac_status); }; }; then
4671 <  ac_cv_f90_module_names=
4672 < ac_file_list=*
4673 < for ac_file in $ac_file_list; do
4674 <   case $ac_file in
4675 <      # don't care for original source and object files
4676 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4677 <          :
4678 <          ;;
4679 <      # look for new files derived from the file name
4680 <      *conftest*)
4681 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4682 <            ac_exists=false
4683 <  for ac_i in $ac_cv_f90_module_names; do
4684 <    if test x"$ac_pat" = x"$ac_i"; then
4685 <      ac_exists=true
4686 <      break
4687 <    fi
4688 <  done
4689 <
4690 <  if test x"$ac_exists" = xtrue; then
4691 <  :
4692 < else
4693 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4694 < fi
4695 <
4696 <          ;;
4697 <      # look for new files derived from the module name,
4698 <      # with different case translation schemes
4699 <      *Bar*)
4700 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4701 <            ac_exists=false
4702 <  for ac_i in $ac_cv_f90_module_names; do
4703 <    if test x"$ac_pat" = x"$ac_i"; then
4704 <      ac_exists=true
4705 <      break
4706 <    fi
4707 <  done
4708 <
4709 <  if test x"$ac_exists" = xtrue; then
4710 <  :
4711 < else
4712 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4713 < fi
4714 <
4715 <          ;;
4716 <      *bar*)
4717 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4718 <            ac_exists=false
4719 <  for ac_i in $ac_cv_f90_module_names; do
4720 <    if test x"$ac_pat" = x"$ac_i"; then
4721 <      ac_exists=true
4722 <      break
4723 <    fi
4724 <  done
4725 <
4726 <  if test x"$ac_exists" = xtrue; then
4727 <  :
4728 < else
4729 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4730 < fi
4731 <
4732 <          ;;
4733 <      *BAR*)
4734 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4735 <            ac_exists=false
4736 <  for ac_i in $ac_cv_f90_module_names; do
4737 <    if test x"$ac_pat" = x"$ac_i"; then
4738 <      ac_exists=true
4739 <      break
4740 <    fi
4741 <  done
4742 <
4743 <  if test x"$ac_exists" = xtrue; then
4744 <  :
4745 < else
4746 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4747 < fi
4748 <
4749 <          ;;
4750 <       # Other files - we have no idea how they are generated
4751 <       *)
4752 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4753 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4754 <          ;;
4755 <   esac
4756 < done
4757 < if test "x$ac_cv_f90_module_names" = "x"; then
4758 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4759 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4760 < fi
4761 <
4762 < else
4763 <  echo "$as_me: failed program was:" >&5
4764 < sed 's/^/| /' conftest.$ac_ext >&5
4765 <
4766 < ac_cv_f90_module_names=
4767 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4768 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4769 < fi
4770 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4771 < cd ..
4772 < # cleanup
4773 < rm -rf conftest
4774 < ac_ext=f90
4775 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4776 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4777 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4778 <
4779 < fi
4780 < echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4781 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
4782 <
4783 < # We now generate a shell script that will help us to figure out the correct
4784 < # module file names, using the value of ac_cv_f90_module_names
4785 <
4786 < echo "Generating shell script modnam"
4787 <
4788 < cat > scripts/modnam << EOF
4789 < #! /bin/sh
4790 < # This script is auto-generated by configure
4791 < #
4792 < usage="\\
4793 < Usage: \$0 [FILES]
4794 <
4795 < [FILES] are Fortran 90 source files.
4796 < The output is a list of module file names that the Fortran 90 compiler
4797 < generates when compiling [FILES]."
4798 <
4799 < list=
4800 < empty=
4801 <
4802 < if test \$# -eq 0; then
4803 <   echo "\$usage"; exit 0
4804 < fi
4805 <
4806 < while test \$# != 0; do
4807 <
4808 <  file=\$1
4809 <  shift
4810 <
4811 < # strip suffix
4812 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4813 <
4814 <  test ! -f \$file && continue
4815 <
4816 < # Look for module definitions and transform them to upper / lower case
4817 <  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/'\`
4818 <  upper=\`echo \$mods | tr a-z A-Z\`
4819 <  lower=\`echo \$mods | tr A-Z a-z\`
4820 <
4821 < # Here, the patterns for generating module file names were inserted by configure
4822 <  for trans in $ac_cv_f90_module_names; do
4823 <
4824 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4825 <    var=empty
4826 <    case \$pat in
4827 <       %MODULE%)
4828 <          var=upper ;;
4829 <       %Module%)
4830 <          var=mods ;;
4831 <       %module%)
4832 <          var=lower ;;
4833 <       %FILE%)
4834 <          test -n "\$mods" && var=base ;;
4835 <    esac
4836 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4837 <    list="\$list \$new"
4838 <  done
4839 < done
4840 <
4841 < echo \$list
4842 < # end of configure-generated script
4843 < EOF
4844 < chmod 755 scripts/modnam
4845 <
4846 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4847 < F90_MODULE_NAMES=empty
4848 < case $pat in
4849 <       %MODULE%)
4850 <          F90_MODULE_NAMES=UPPER ;;
4851 <       %Module%)
4852 <          F90_MODULE_NAMES=Mixed ;;
4853 <       %module%)
4854 <          F90_MODULE_NAMES=lower ;;
4855 <       *)
4856 <          F90_MODULE_NAMES=unknown ;;
4397 > cat >>confdefs.h <<\_ACEOF
4398 > #define FC_DUMMY_MAIN_EQ_F77 1
4399 > _ACEOF
4400 >
4401 >  fi
4402 > fi
4403 > else
4404 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4405 > See \`config.log' for more details." >&5
4406 > echo "$as_me: error: linking to Fortran libraries from C fails
4407 > See \`config.log' for more details." >&2;}
4408 >   { (exit 1); exit 1; }; }
4409 > fi
4410 >
4411 >
4412 > ac_ext=${FC_SRCEXT-f}
4413 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4414 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4415 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4416 >
4417 > ac_ext=${FC_SRCEXT-f}
4418 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4419 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4420 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4421 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4422 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4423 > if test "${ac_cv_fc_mangling+set}" = set; then
4424 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4425 > else
4426 >  cat >conftest.$ac_ext <<_ACEOF
4427 >      subroutine foobar()
4428 >      return
4429 >      end
4430 >      subroutine foo_bar()
4431 >      return
4432 >      end
4433 > _ACEOF
4434 > rm -f conftest.$ac_objext
4435 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4436 >  (eval $ac_compile) 2>conftest.er1
4437 >  ac_status=$?
4438 >  grep -v '^ *+' conftest.er1 >conftest.err
4439 >  rm -f conftest.er1
4440 >  cat conftest.err >&5
4441 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442 >  (exit $ac_status); } &&
4443 >         { ac_try='test -z "$ac_fc_werror_flag"
4444 >                         || test ! -s conftest.err'
4445 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4446 >  (eval $ac_try) 2>&5
4447 >  ac_status=$?
4448 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4449 >  (exit $ac_status); }; } &&
4450 >         { ac_try='test -s conftest.$ac_objext'
4451 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4452 >  (eval $ac_try) 2>&5
4453 >  ac_status=$?
4454 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455 >  (exit $ac_status); }; }; then
4456 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4457 >
4458 >  ac_save_LIBS=$LIBS
4459 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4460 >
4461 >  ac_ext=c
4462 > ac_cpp='$CPP $CPPFLAGS'
4463 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4464 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4465 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4466 >  ac_success=no
4467 >  for ac_foobar in foobar FOOBAR; do
4468 >    for ac_underscore in "" "_"; do
4469 >      ac_func="$ac_foobar$ac_underscore"
4470 >      cat >conftest.$ac_ext <<_ACEOF
4471 > /* confdefs.h.  */
4472 > _ACEOF
4473 > cat confdefs.h >>conftest.$ac_ext
4474 > cat >>conftest.$ac_ext <<_ACEOF
4475 > /* end confdefs.h.  */
4476 >
4477 > /* Override any gcc2 internal prototype to avoid an error.  */
4478 > #ifdef __cplusplus
4479 > extern "C"
4480 > #endif
4481 > /* We use char because int might match the return type of a gcc2
4482 >   builtin and then its argument prototype would still apply.  */
4483 > char $ac_func ();
4484 > #ifdef FC_DUMMY_MAIN
4485 > #ifndef FC_DUMMY_MAIN_EQ_F77
4486 > #  ifdef __cplusplus
4487 >     extern "C"
4488 > #  endif
4489 >   int FC_DUMMY_MAIN() { return 1; }
4490 > #endif
4491 > #endif
4492 > int
4493 > main ()
4494 > {
4495 > $ac_func ();
4496 >  ;
4497 >  return 0;
4498 > }
4499 > _ACEOF
4500 > rm -f conftest.$ac_objext conftest$ac_exeext
4501 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4502 >  (eval $ac_link) 2>conftest.er1
4503 >  ac_status=$?
4504 >  grep -v '^ *+' conftest.er1 >conftest.err
4505 >  rm -f conftest.er1
4506 >  cat conftest.err >&5
4507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508 >  (exit $ac_status); } &&
4509 >         { ac_try='test -z "$ac_c_werror_flag"
4510 >                         || test ! -s conftest.err'
4511 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512 >  (eval $ac_try) 2>&5
4513 >  ac_status=$?
4514 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515 >  (exit $ac_status); }; } &&
4516 >         { ac_try='test -s conftest$ac_exeext'
4517 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518 >  (eval $ac_try) 2>&5
4519 >  ac_status=$?
4520 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521 >  (exit $ac_status); }; }; then
4522 >  ac_success=yes; break 2
4523 > else
4524 >  echo "$as_me: failed program was:" >&5
4525 > sed 's/^/| /' conftest.$ac_ext >&5
4526 >
4527 > fi
4528 > rm -f conftest.err conftest.$ac_objext \
4529 >      conftest$ac_exeext conftest.$ac_ext
4530 >    done
4531 >  done
4532 >  ac_ext=${FC_SRCEXT-f}
4533 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4534 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4535 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4536 >
4537 >  if test "$ac_success" = "yes"; then
4538 >     case $ac_foobar in
4539 >        foobar)
4540 >           ac_case=lower
4541 >           ac_foo_bar=foo_bar
4542 >           ;;
4543 >        FOOBAR)
4544 >           ac_case=upper
4545 >           ac_foo_bar=FOO_BAR
4546 >           ;;
4547 >     esac
4548 >
4549 >     ac_ext=c
4550 > ac_cpp='$CPP $CPPFLAGS'
4551 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4552 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4553 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4554 >     ac_success_extra=no
4555 >     for ac_extra in "" "_"; do
4556 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557 >        cat >conftest.$ac_ext <<_ACEOF
4558 > /* confdefs.h.  */
4559 > _ACEOF
4560 > cat confdefs.h >>conftest.$ac_ext
4561 > cat >>conftest.$ac_ext <<_ACEOF
4562 > /* end confdefs.h.  */
4563 >
4564 > /* Override any gcc2 internal prototype to avoid an error.  */
4565 > #ifdef __cplusplus
4566 > extern "C"
4567 > #endif
4568 > /* We use char because int might match the return type of a gcc2
4569 >   builtin and then its argument prototype would still apply.  */
4570 > char $ac_func ();
4571 > #ifdef FC_DUMMY_MAIN
4572 > #ifndef FC_DUMMY_MAIN_EQ_F77
4573 > #  ifdef __cplusplus
4574 >     extern "C"
4575 > #  endif
4576 >   int FC_DUMMY_MAIN() { return 1; }
4577 > #endif
4578 > #endif
4579 > int
4580 > main ()
4581 > {
4582 > $ac_func ();
4583 >  ;
4584 >  return 0;
4585 > }
4586 > _ACEOF
4587 > rm -f conftest.$ac_objext conftest$ac_exeext
4588 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4589 >  (eval $ac_link) 2>conftest.er1
4590 >  ac_status=$?
4591 >  grep -v '^ *+' conftest.er1 >conftest.err
4592 >  rm -f conftest.er1
4593 >  cat conftest.err >&5
4594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4595 >  (exit $ac_status); } &&
4596 >         { ac_try='test -z "$ac_c_werror_flag"
4597 >                         || test ! -s conftest.err'
4598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4599 >  (eval $ac_try) 2>&5
4600 >  ac_status=$?
4601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4602 >  (exit $ac_status); }; } &&
4603 >         { ac_try='test -s conftest$ac_exeext'
4604 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4605 >  (eval $ac_try) 2>&5
4606 >  ac_status=$?
4607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4608 >  (exit $ac_status); }; }; then
4609 >  ac_success_extra=yes; break
4610 > else
4611 >  echo "$as_me: failed program was:" >&5
4612 > sed 's/^/| /' conftest.$ac_ext >&5
4613 >
4614 > fi
4615 > rm -f conftest.err conftest.$ac_objext \
4616 >      conftest$ac_exeext conftest.$ac_ext
4617 >     done
4618 >     ac_ext=${FC_SRCEXT-f}
4619 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4620 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4621 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4622 >
4623 >     if test "$ac_success_extra" = "yes"; then
4624 >        ac_cv_fc_mangling="$ac_case case"
4625 >        if test -z "$ac_underscore"; then
4626 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627 >        else
4628 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629 >        fi
4630 >        if test -z "$ac_extra"; then
4631 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632 >        else
4633 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634 >        fi
4635 >      else
4636 >        ac_cv_fc_mangling="unknown"
4637 >      fi
4638 >  else
4639 >     ac_cv_fc_mangling="unknown"
4640 >  fi
4641 >
4642 >  LIBS=$ac_save_LIBS
4643 >  rm -f cfortran_test* conftest*
4644 > else
4645 >  echo "$as_me: failed program was:" >&5
4646 > sed 's/^/| /' conftest.$ac_ext >&5
4647 >
4648 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4649 > See \`config.log' for more details." >&5
4650 > echo "$as_me: error: cannot compile a simple Fortran program
4651 > See \`config.log' for more details." >&2;}
4652 >   { (exit 1); exit 1; }; }
4653 > fi
4654 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4655 >
4656 > fi
4657 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4658 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4659 >
4660 > ac_ext=${FC_SRCEXT-f}
4661 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664 >
4665 > ac_ext=${FC_SRCEXT-f}
4666 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4667 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4668 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4669 >
4670 >
4671 > case $ac_cv_fc_mangling in
4672 >  "lower case, no underscore, no extra underscore")
4673 >          cat >>confdefs.h <<\_ACEOF
4674 > #define FC_FUNC(name,NAME) name
4675 > _ACEOF
4676 >
4677 >          cat >>confdefs.h <<\_ACEOF
4678 > #define FC_FUNC_(name,NAME) name
4679 > _ACEOF
4680 > ;;
4681 >  "lower case, no underscore, extra underscore")
4682 >          cat >>confdefs.h <<\_ACEOF
4683 > #define FC_FUNC(name,NAME) name
4684 > _ACEOF
4685 >
4686 >          cat >>confdefs.h <<\_ACEOF
4687 > #define FC_FUNC_(name,NAME) name ## _
4688 > _ACEOF
4689 > ;;
4690 >  "lower case, underscore, no extra underscore")
4691 >          cat >>confdefs.h <<\_ACEOF
4692 > #define FC_FUNC(name,NAME) name ## _
4693 > _ACEOF
4694 >
4695 >          cat >>confdefs.h <<\_ACEOF
4696 > #define FC_FUNC_(name,NAME) name ## _
4697 > _ACEOF
4698 > ;;
4699 >  "lower case, underscore, extra underscore")
4700 >          cat >>confdefs.h <<\_ACEOF
4701 > #define FC_FUNC(name,NAME) name ## _
4702 > _ACEOF
4703 >
4704 >          cat >>confdefs.h <<\_ACEOF
4705 > #define FC_FUNC_(name,NAME) name ## __
4706 > _ACEOF
4707 > ;;
4708 >  "upper case, no underscore, no extra underscore")
4709 >          cat >>confdefs.h <<\_ACEOF
4710 > #define FC_FUNC(name,NAME) NAME
4711 > _ACEOF
4712 >
4713 >          cat >>confdefs.h <<\_ACEOF
4714 > #define FC_FUNC_(name,NAME) NAME
4715 > _ACEOF
4716 > ;;
4717 >  "upper case, no underscore, extra underscore")
4718 >          cat >>confdefs.h <<\_ACEOF
4719 > #define FC_FUNC(name,NAME) NAME
4720 > _ACEOF
4721 >
4722 >          cat >>confdefs.h <<\_ACEOF
4723 > #define FC_FUNC_(name,NAME) NAME ## _
4724 > _ACEOF
4725 > ;;
4726 >  "upper case, underscore, no extra underscore")
4727 >          cat >>confdefs.h <<\_ACEOF
4728 > #define FC_FUNC(name,NAME) NAME ## _
4729 > _ACEOF
4730 >
4731 >          cat >>confdefs.h <<\_ACEOF
4732 > #define FC_FUNC_(name,NAME) NAME ## _
4733 > _ACEOF
4734 > ;;
4735 >  "upper case, underscore, extra underscore")
4736 >          cat >>confdefs.h <<\_ACEOF
4737 > #define FC_FUNC(name,NAME) NAME ## _
4738 > _ACEOF
4739 >
4740 >          cat >>confdefs.h <<\_ACEOF
4741 > #define FC_FUNC_(name,NAME) NAME ## __
4742 > _ACEOF
4743 > ;;
4744 >  *)
4745 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4746 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4747 >          ;;
4748 > esac
4749 >
4750 > ac_ext=${FC_SRCEXT-f}
4751 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4752 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4753 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4754 >
4755 >
4756 >
4757 > ac_ext=${FC_SRCEXT-f}
4758 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4759 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4760 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4762 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4763 > if test "${ac_cv_prog_fc_v+set}" = set; then
4764 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4765 > else
4766 >  cat >conftest.$ac_ext <<_ACEOF
4767 >      program main
4768 >
4769 >      end
4770 > _ACEOF
4771 > rm -f conftest.$ac_objext
4772 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4773 >  (eval $ac_compile) 2>conftest.er1
4774 >  ac_status=$?
4775 >  grep -v '^ *+' conftest.er1 >conftest.err
4776 >  rm -f conftest.er1
4777 >  cat conftest.err >&5
4778 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4779 >  (exit $ac_status); } &&
4780 >         { ac_try='test -z "$ac_fc_werror_flag"
4781 >                         || test ! -s conftest.err'
4782 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4783 >  (eval $ac_try) 2>&5
4784 >  ac_status=$?
4785 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4786 >  (exit $ac_status); }; } &&
4787 >         { ac_try='test -s conftest.$ac_objext'
4788 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4789 >  (eval $ac_try) 2>&5
4790 >  ac_status=$?
4791 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4792 >  (exit $ac_status); }; }; then
4793 >  ac_cv_prog_fc_v=
4794 > # Try some options frequently used verbose output
4795 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4796 >  cat >conftest.$ac_ext <<_ACEOF
4797 >      program main
4798 >
4799 >      end
4800 > _ACEOF
4801 >
4802 > # Compile and link our simple test program by passing a flag (argument
4803 > # 1 to this macro) to the Fortran compiler in order to get
4804 > # "verbose" output that we can then parse for the Fortran linker
4805 > # flags.
4806 > ac_save_FFLAGS=$FCFLAGS
4807 > FCFLAGS="$FCFLAGS $ac_verb"
4808 > (eval echo $as_me:4808: \"$ac_link\") >&5
4809 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4810 > echo "$ac_fc_v_output" >&5
4811 > FCFLAGS=$ac_save_FFLAGS
4812 >
4813 > rm -f conftest*
4814 >
4815 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4816 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4817 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4818 > ac_fc_v_output="`echo $ac_fc_v_output |
4819 >        grep 'LPATH is:' |
4820 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4821 >
4822 > case $ac_fc_v_output in
4823 >  # If we are using xlf then replace all the commas with spaces.
4824 >  *xlfentry*)
4825 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4826 >
4827 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4828 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4829 >  *mGLOB_options_string*)
4830 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4831 >
4832 >  # If we are using Cray Fortran then delete quotes.
4833 >  # Use "\"" instead of '"' for font-lock-mode.
4834 >  # FIXME: a more general fix for quoted arguments with spaces?
4835 >  *cft90*)
4836 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4837 > esac
4838 >
4839 >
4840 >  # look for -l* and *.a constructs in the output
4841 >  for ac_arg in $ac_fc_v_output; do
4842 >     case $ac_arg in
4843 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4844 >          ac_cv_prog_fc_v=$ac_verb
4845 >          break 2 ;;
4846 >     esac
4847 >  done
4848 > done
4849 > if test -z "$ac_cv_prog_fc_v"; then
4850 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4851 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4852 > fi
4853 > else
4854 >  echo "$as_me: failed program was:" >&5
4855 > sed 's/^/| /' conftest.$ac_ext >&5
4856 >
4857 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4858 > echo "$as_me: WARNING: compilation failed" >&2;}
4859 > fi
4860 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4861 >
4862 > fi
4863 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4864 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4865 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4866 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4867 > if test "${ac_cv_fc_libs+set}" = set; then
4868 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4869 > else
4870 >  if test "x$FCLIBS" != "x"; then
4871 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4872 > else
4873 >
4874 > cat >conftest.$ac_ext <<_ACEOF
4875 >      program main
4876 >
4877 >      end
4878 > _ACEOF
4879 >
4880 > # Compile and link our simple test program by passing a flag (argument
4881 > # 1 to this macro) to the Fortran compiler in order to get
4882 > # "verbose" output that we can then parse for the Fortran linker
4883 > # flags.
4884 > ac_save_FFLAGS=$FCFLAGS
4885 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4886 > (eval echo $as_me:4886: \"$ac_link\") >&5
4887 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4888 > echo "$ac_fc_v_output" >&5
4889 > FCFLAGS=$ac_save_FFLAGS
4890 >
4891 > rm -f conftest*
4892 >
4893 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4894 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4895 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4896 > ac_fc_v_output="`echo $ac_fc_v_output |
4897 >        grep 'LPATH is:' |
4898 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4899 >
4900 > case $ac_fc_v_output in
4901 >  # If we are using xlf then replace all the commas with spaces.
4902 >  *xlfentry*)
4903 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4904 >
4905 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4906 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4907 >  *mGLOB_options_string*)
4908 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4909 >
4910 >  # If we are using Cray Fortran then delete quotes.
4911 >  # Use "\"" instead of '"' for font-lock-mode.
4912 >  # FIXME: a more general fix for quoted arguments with spaces?
4913 >  *cft90*)
4914 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4915 > esac
4916 >
4917 >
4918 >
4919 > ac_cv_fc_libs=
4920 >
4921 > # Save positional arguments (if any)
4922 > ac_save_positional="$@"
4923 >
4924 > set X $ac_fc_v_output
4925 > while test $# != 1; do
4926 >  shift
4927 >  ac_arg=$1
4928 >  case $ac_arg in
4929 >        [\\/]*.a | ?:[\\/]*.a)
4930 >            ac_exists=false
4931 >  for ac_i in $ac_cv_fc_libs; do
4932 >    if test x"$ac_arg" = x"$ac_i"; then
4933 >      ac_exists=true
4934 >      break
4935 >    fi
4936 >  done
4937 >
4938 >  if test x"$ac_exists" = xtrue; then
4939 >  :
4940 > else
4941 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4942 > fi
4943 >
4944 >          ;;
4945 >        -bI:*)
4946 >            ac_exists=false
4947 >  for ac_i in $ac_cv_fc_libs; do
4948 >    if test x"$ac_arg" = x"$ac_i"; then
4949 >      ac_exists=true
4950 >      break
4951 >    fi
4952 >  done
4953 >
4954 >  if test x"$ac_exists" = xtrue; then
4955 >  :
4956 > else
4957 >  if test "$ac_compiler_gnu" = yes; then
4958 >  for ac_link_opt in $ac_arg; do
4959 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4960 >  done
4961 > else
4962 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4963 > fi
4964 > fi
4965 >
4966 >          ;;
4967 >          # Ignore these flags.
4968 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4969 >          ;;
4970 >        -lkernel32)
4971 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4972 >          ;;
4973 >        -[LRuY])
4974 >          # These flags, when seen by themselves, take an argument.
4975 >          # We remove the space between option and argument and re-iterate
4976 >          # unless we find an empty arg or a new option (starting with -)
4977 >          case $2 in
4978 >             "" | -*);;
4979 >             *)
4980 >                ac_arg="$ac_arg$2"
4981 >                shift; shift
4982 >                set X $ac_arg "$@"
4983 >                ;;
4984 >          esac
4985 >          ;;
4986 >        -YP,*)
4987 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4988 >              ac_exists=false
4989 >  for ac_i in $ac_cv_fc_libs; do
4990 >    if test x"$ac_j" = x"$ac_i"; then
4991 >      ac_exists=true
4992 >      break
4993 >    fi
4994 >  done
4995 >
4996 >  if test x"$ac_exists" = xtrue; then
4997 >  :
4998 > else
4999 >  ac_arg="$ac_arg $ac_j"
5000 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5001 > fi
5002 >
5003 >          done
5004 >          ;;
5005 >        -[lLR]*)
5006 >            ac_exists=false
5007 >  for ac_i in $ac_cv_fc_libs; do
5008 >    if test x"$ac_arg" = x"$ac_i"; then
5009 >      ac_exists=true
5010 >      break
5011 >    fi
5012 >  done
5013 >
5014 >  if test x"$ac_exists" = xtrue; then
5015 >  :
5016 > else
5017 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5018 > fi
5019 >
5020 >          ;;
5021 >          # Ignore everything else.
5022 >  esac
5023 > done
5024 > # restore positional arguments
5025 > set X $ac_save_positional; shift
5026 >
5027 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5028 > # then we insist that the "run path" must be an absolute path (i.e. it
5029 > # must begin with a "/").
5030 > case `(uname -sr) 2>/dev/null` in
5031 >   "SunOS 5"*)
5032 >      ac_ld_run_path=`echo $ac_fc_v_output |
5033 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5034 >      test "x$ac_ld_run_path" != x &&
5035 >        if test "$ac_compiler_gnu" = yes; then
5036 >  for ac_link_opt in $ac_ld_run_path; do
5037 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5038 >  done
5039 > else
5040 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5041 > fi
5042 >      ;;
5043 > esac
5044 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5045 >
5046 > fi
5047 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5048 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5049 > FCLIBS="$ac_cv_fc_libs"
5050 >
5051 >
5052 > ac_ext=${FC_SRCEXT-f}
5053 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5054 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5055 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5056 >
5057 >
5058 >
5059 > echo "$as_me:$LINENO: checking for module suffix" >&5
5060 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5061 > rm -f conftest*
5062 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5063 > rm -f work*
5064 > cat >conftest.$ac_ext <<EOF
5065 >        module conftest
5066 >        integer n
5067 >        parameter (n=1)
5068 >        end module conftest
5069 > EOF
5070 > # SGI and absoft compilers generates module name in upper case!
5071 > testname="conftest"
5072 > modcase="lower"
5073 > if (eval $ac_compile) 2>/dev/null ; then
5074 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5075 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5076 >    if test -z "$MOD" ; then
5077 >        MOD=`ls CONFTEST* 2>/dev/null \
5078 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5079 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5080 >        if test -n "$MOD" ; then
5081 >            testname="CONFTEST"
5082 >            modcase="upper"
5083 >        fi
5084 >    fi
5085 >    if test -z "$MOD" ; then
5086 >        echo "$as_me:$LINENO: result: unknown" >&5
5087 > echo "${ECHO_T}unknown" >&6
5088 >        # Use mod if we can't figure it out
5089 >        MOD="mod"
5090 >    else
5091 >        echo "$as_me:$LINENO: result: $MOD" >&5
5092 > echo "${ECHO_T}$MOD" >&6
5093 >    fi
5094 >    if test -s work.pcl ; then
5095 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5096 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5097 >    fi
5098 > else
5099 >    echo "$as_me:$LINENO: result: unknown" >&5
5100 > echo "${ECHO_T}unknown" >&6
5101 > fi
5102 >
5103 >
5104 >
5105 >
5106 >
5107 > # Check for module include path (some use -I, some (Solaris) use -M, some
5108 > # (absoft) use -p).
5109 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5110 > # specified, work.pcl and work.pc are created.  However, if you specify
5111 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5112 > # Use the module made above
5113 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5114 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5115 > rm -f conftest*
5116 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5117 > rm -f work*
5118 > cat >conftest.$ac_ext <<EOF
5119 >        module conftest
5120 >        integer n
5121 >        parameter (n=1)
5122 >        end module conftest
5123 > EOF
5124 > # SGI and absoft compilers generates module name in upper case!
5125 > testname="conftest"
5126 > if (eval $ac_compile) 2>/dev/null ; then
5127 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5128 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5129 >   if test -n "$mod" ; then
5130 >      testname="CONFTEST"
5131 >   fi
5132 >   madedir=0
5133 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134 >   cp $testname.$MOD conf
5135 >   rm -f conftest* CONFTEST*
5136 >   cat >conftest1.$ac_ext <<EOF
5137 >        program main
5138 >        use conftest
5139 >        print *, n
5140 >        end
5141 > EOF
5142 >   F90_WORK_FILES_ARG=""
5143 >   F90MODINCSPEC=""
5144 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5145 >       MODDIRFLAG="-I"
5146 >       F90MODINCSPEC="-I<dir>"
5147 >       echo "$as_me:$LINENO: result: -I" >&5
5148 > echo "${ECHO_T}-I" >&6
5149 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5150 >       MODDIRFLAG="-M"
5151 >       F90MODINCSPEC="-M<dir>"
5152 >       echo "$as_me:$LINENO: result: -M" >&5
5153 > echo "${ECHO_T}-M" >&6
5154 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5155 >       MODDIRFLAG="-p"
5156 >       F90MODINCSPEC="-p<dir>"
5157 >       echo "$as_me:$LINENO: result: -p" >&5
5158 > echo "${ECHO_T}-p" >&6
5159 >   elif test -s work.pc ; then
5160 >        cp work.pc conf/mpimod.pc
5161 >        echo "mpimod.pc" > conf/mpimod.pcl
5162 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5163 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5164 >            MODDIRFLAG='-cl,mpimod.pcl'
5165 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5166 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5167 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5168 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5169 >
5170 >        else
5171 >            # The version of the Intel compiler that I have refuses to let
5172 >            # you put the "work catalog" list anywhere but the current
5173 >            # directory. For example, you cannot in
5174 >         :
5175 >        fi
5176 >   fi
5177 >   if test -z "MODDIRFLAG" ; then
5178 >       echo "$as_me:$LINENO: result: unknown" >&5
5179 > echo "${ECHO_T}unknown" >&6
5180 >   fi
5181 >
5182 >
5183 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5184 >   if test $madedir = 1 ; then rmdir conf ; fi
5185 > fi
5186 >
5187 >
5188 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5189 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5190 > if test "${ac_cv_f90_module_names+set}" = set; then
5191 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5192 > else
5193 >  ac_ext=${FC_SRCEXT-f}
5194 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5195 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5196 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5197 >
5198 > # carry out the test in a new directory, so that we don't miss anything
5199 > mkdir conftest
5200 > cd conftest
5201 > cat >conftest.$ac_ext <<_ACEOF
5202 > MODULE Bar
5203 > END MODULE Bar
5204 > _ACEOF
5205 > rm -f conftest.$ac_objext
5206 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5207 >  (eval $ac_compile) 2>conftest.er1
5208 >  ac_status=$?
5209 >  grep -v '^ *+' conftest.er1 >conftest.err
5210 >  rm -f conftest.er1
5211 >  cat conftest.err >&5
5212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213 >  (exit $ac_status); } &&
5214 >         { ac_try='test -z "$ac_fc_werror_flag"
5215 >                         || test ! -s conftest.err'
5216 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5217 >  (eval $ac_try) 2>&5
5218 >  ac_status=$?
5219 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5220 >  (exit $ac_status); }; } &&
5221 >         { ac_try='test -s conftest.$ac_objext'
5222 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5223 >  (eval $ac_try) 2>&5
5224 >  ac_status=$?
5225 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5226 >  (exit $ac_status); }; }; then
5227 >  ac_cv_f90_module_names=
5228 > ac_file_list=*
5229 > for ac_file in $ac_file_list; do
5230 >   case $ac_file in
5231 >      # don't care for original source and object files
5232 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5233 >          :
5234 >          ;;
5235 >      # look for new files derived from the file name
5236 >      *conftest*)
5237 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5238 >            ac_exists=false
5239 >  for ac_i in $ac_cv_f90_module_names; do
5240 >    if test x"$ac_pat" = x"$ac_i"; then
5241 >      ac_exists=true
5242 >      break
5243 >    fi
5244 >  done
5245 >
5246 >  if test x"$ac_exists" = xtrue; then
5247 >  :
5248 > else
5249 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5250 > fi
5251 >
5252 >          ;;
5253 >      # look for new files derived from the module name,
5254 >      # with different case translation schemes
5255 >      *Bar*)
5256 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5257 >            ac_exists=false
5258 >  for ac_i in $ac_cv_f90_module_names; do
5259 >    if test x"$ac_pat" = x"$ac_i"; then
5260 >      ac_exists=true
5261 >      break
5262 >    fi
5263 >  done
5264 >
5265 >  if test x"$ac_exists" = xtrue; then
5266 >  :
5267 > else
5268 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5269 > fi
5270 >
5271 >          ;;
5272 >      *bar*)
5273 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5274 >            ac_exists=false
5275 >  for ac_i in $ac_cv_f90_module_names; do
5276 >    if test x"$ac_pat" = x"$ac_i"; then
5277 >      ac_exists=true
5278 >      break
5279 >    fi
5280 >  done
5281 >
5282 >  if test x"$ac_exists" = xtrue; then
5283 >  :
5284 > else
5285 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5286 > fi
5287 >
5288 >          ;;
5289 >      *BAR*)
5290 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5291 >            ac_exists=false
5292 >  for ac_i in $ac_cv_f90_module_names; do
5293 >    if test x"$ac_pat" = x"$ac_i"; then
5294 >      ac_exists=true
5295 >      break
5296 >    fi
5297 >  done
5298 >
5299 >  if test x"$ac_exists" = xtrue; then
5300 >  :
5301 > else
5302 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5303 > fi
5304 >
5305 >          ;;
5306 >       # Other files - we have no idea how they are generated
5307 >       *)
5308 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5309 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5310 >          ;;
5311 >   esac
5312 > done
5313 > if test "x$ac_cv_f90_module_names" = "x"; then
5314 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5315 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5316 > fi
5317 >
5318 > else
5319 >  echo "$as_me: failed program was:" >&5
5320 > sed 's/^/| /' conftest.$ac_ext >&5
5321 >
5322 > ac_cv_f90_module_names=
5323 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5324 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5325 > fi
5326 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5327 > cd ..
5328 > # cleanup
5329 > rm -rf conftest
5330 > ac_ext=${FC_SRCEXT-f}
5331 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5332 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5333 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5334 >
5335 > fi
5336 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5337 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5338 >
5339 > # We now generate a shell script that will help us to figure out the correct
5340 > # module file names, using the value of ac_cv_f90_module_names
5341 >
5342 > echo "Generating shell script modnam"
5343 >
5344 > cat > scripts/modnam << EOF
5345 > #! /bin/sh
5346 > # This script is auto-generated by configure
5347 > #
5348 > usage="\\
5349 > Usage: \$0 [FILES]
5350 >
5351 > [FILES] are Fortran 90 source files.
5352 > The output is a list of module file names that the Fortran 90 compiler
5353 > generates when compiling [FILES]."
5354 >
5355 > list=
5356 > empty=
5357 >
5358 > if test \$# -eq 0; then
5359 >   echo "\$usage"; exit 0
5360 > fi
5361 >
5362 > while test \$# != 0; do
5363 >
5364 >  file=\$1
5365 >  shift
5366 >
5367 > # strip suffix
5368 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5369 >
5370 >  test ! -f \$file && continue
5371 >
5372 > # Look for module definitions and transform them to upper / lower case
5373 >  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/'\`
5374 >  upper=\`echo \$mods | tr a-z A-Z\`
5375 >  lower=\`echo \$mods | tr A-Z a-z\`
5376 >
5377 > # Here, the patterns for generating module file names were inserted by configure
5378 >  for trans in $ac_cv_f90_module_names; do
5379 >
5380 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5381 >    var=empty
5382 >    case \$pat in
5383 >       %MODULE%)
5384 >          var=upper ;;
5385 >       %Module%)
5386 >          var=mods ;;
5387 >       %module%)
5388 >          var=lower ;;
5389 >       %FILE%)
5390 >          test -n "\$mods" && var=base ;;
5391 >    esac
5392 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5393 >    list="\$list \$new"
5394 >  done
5395 > done
5396 >
5397 > echo \$list
5398 > # end of configure-generated script
5399 > EOF
5400 > chmod 755 scripts/modnam
5401 >
5402 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5403 > F90_MODULE_NAMES=empty
5404 > case $pat in
5405 >       %MODULE%)
5406 >          F90_MODULE_NAMES=UPPER ;;
5407 >       %Module%)
5408 >          F90_MODULE_NAMES=Mixed ;;
5409 >       %module%)
5410 >          F90_MODULE_NAMES=lower ;;
5411 >       *)
5412 >          F90_MODULE_NAMES=unknown ;;
5413 > esac
5414 >
5415 > ac_ext=c
5416 > ac_cpp='$CPP $CPPFLAGS'
5417 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5418 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5419 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420 >
5421 >
5422 > ac_ext=c
5423 > ac_cpp='$CPP $CPPFLAGS'
5424 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5427 >
5428 >
5429 >
5430 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5431 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5432 > if test "${ac_cv_lib_m_asin+set}" = set; then
5433 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5434 > else
5435 >  ac_check_lib_save_LIBS=$LIBS
5436 > LIBS="-lm  $LIBS"
5437 > cat >conftest.$ac_ext <<_ACEOF
5438 > /* confdefs.h.  */
5439 > _ACEOF
5440 > cat confdefs.h >>conftest.$ac_ext
5441 > cat >>conftest.$ac_ext <<_ACEOF
5442 > /* end confdefs.h.  */
5443 >
5444 > /* Override any gcc2 internal prototype to avoid an error.  */
5445 > #ifdef __cplusplus
5446 > extern "C"
5447 > #endif
5448 > /* We use char because int might match the return type of a gcc2
5449 >   builtin and then its argument prototype would still apply.  */
5450 > char asin ();
5451 > #ifdef FC_DUMMY_MAIN
5452 > #ifndef FC_DUMMY_MAIN_EQ_F77
5453 > #  ifdef __cplusplus
5454 >     extern "C"
5455 > #  endif
5456 >   int FC_DUMMY_MAIN() { return 1; }
5457 > #endif
5458 > #endif
5459 > int
5460 > main ()
5461 > {
5462 > asin ();
5463 >  ;
5464 >  return 0;
5465 > }
5466 > _ACEOF
5467 > rm -f conftest.$ac_objext conftest$ac_exeext
5468 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5469 >  (eval $ac_link) 2>conftest.er1
5470 >  ac_status=$?
5471 >  grep -v '^ *+' conftest.er1 >conftest.err
5472 >  rm -f conftest.er1
5473 >  cat conftest.err >&5
5474 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475 >  (exit $ac_status); } &&
5476 >         { ac_try='test -z "$ac_c_werror_flag"
5477 >                         || test ! -s conftest.err'
5478 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5479 >  (eval $ac_try) 2>&5
5480 >  ac_status=$?
5481 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5482 >  (exit $ac_status); }; } &&
5483 >         { ac_try='test -s conftest$ac_exeext'
5484 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5485 >  (eval $ac_try) 2>&5
5486 >  ac_status=$?
5487 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5488 >  (exit $ac_status); }; }; then
5489 >  ac_cv_lib_m_asin=yes
5490 > else
5491 >  echo "$as_me: failed program was:" >&5
5492 > sed 's/^/| /' conftest.$ac_ext >&5
5493 >
5494 > ac_cv_lib_m_asin=no
5495 > fi
5496 > rm -f conftest.err conftest.$ac_objext \
5497 >      conftest$ac_exeext conftest.$ac_ext
5498 > LIBS=$ac_check_lib_save_LIBS
5499 > fi
5500 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5501 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5502 > if test $ac_cv_lib_m_asin = yes; then
5503 >  cat >>confdefs.h <<_ACEOF
5504 > #define HAVE_LIBM 1
5505 > _ACEOF
5506 >
5507 >  LIBS="-lm $LIBS"
5508 >
5509 > else
5510 >  exit
5511 > fi
5512 >
5513 >
5514 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5515 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5516 > if test "${ac_cv_header_stdc+set}" = set; then
5517 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5518 > else
5519 >  cat >conftest.$ac_ext <<_ACEOF
5520 > /* confdefs.h.  */
5521 > _ACEOF
5522 > cat confdefs.h >>conftest.$ac_ext
5523 > cat >>conftest.$ac_ext <<_ACEOF
5524 > /* end confdefs.h.  */
5525 > #include <stdlib.h>
5526 > #include <stdarg.h>
5527 > #include <string.h>
5528 > #include <float.h>
5529 >
5530 > #ifdef FC_DUMMY_MAIN
5531 > #ifndef FC_DUMMY_MAIN_EQ_F77
5532 > #  ifdef __cplusplus
5533 >     extern "C"
5534 > #  endif
5535 >   int FC_DUMMY_MAIN() { return 1; }
5536 > #endif
5537 > #endif
5538 > int
5539 > main ()
5540 > {
5541 >
5542 >  ;
5543 >  return 0;
5544 > }
5545 > _ACEOF
5546 > rm -f conftest.$ac_objext
5547 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5548 >  (eval $ac_compile) 2>conftest.er1
5549 >  ac_status=$?
5550 >  grep -v '^ *+' conftest.er1 >conftest.err
5551 >  rm -f conftest.er1
5552 >  cat conftest.err >&5
5553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554 >  (exit $ac_status); } &&
5555 >         { ac_try='test -z "$ac_c_werror_flag"
5556 >                         || test ! -s conftest.err'
5557 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5558 >  (eval $ac_try) 2>&5
5559 >  ac_status=$?
5560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5561 >  (exit $ac_status); }; } &&
5562 >         { ac_try='test -s conftest.$ac_objext'
5563 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5564 >  (eval $ac_try) 2>&5
5565 >  ac_status=$?
5566 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5567 >  (exit $ac_status); }; }; then
5568 >  ac_cv_header_stdc=yes
5569 > else
5570 >  echo "$as_me: failed program was:" >&5
5571 > sed 's/^/| /' conftest.$ac_ext >&5
5572 >
5573 > ac_cv_header_stdc=no
5574 > fi
5575 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5576 >
5577 > if test $ac_cv_header_stdc = yes; then
5578 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5579 >  cat >conftest.$ac_ext <<_ACEOF
5580 > /* confdefs.h.  */
5581 > _ACEOF
5582 > cat confdefs.h >>conftest.$ac_ext
5583 > cat >>conftest.$ac_ext <<_ACEOF
5584 > /* end confdefs.h.  */
5585 > #include <string.h>
5586 >
5587 > _ACEOF
5588 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5589 >  $EGREP "memchr" >/dev/null 2>&1; then
5590 >  :
5591 > else
5592 >  ac_cv_header_stdc=no
5593 > fi
5594 > rm -f conftest*
5595 >
5596 > fi
5597 >
5598 > if test $ac_cv_header_stdc = yes; then
5599 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5600 >  cat >conftest.$ac_ext <<_ACEOF
5601 > /* confdefs.h.  */
5602 > _ACEOF
5603 > cat confdefs.h >>conftest.$ac_ext
5604 > cat >>conftest.$ac_ext <<_ACEOF
5605 > /* end confdefs.h.  */
5606 > #include <stdlib.h>
5607 >
5608 > _ACEOF
5609 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5610 >  $EGREP "free" >/dev/null 2>&1; then
5611 >  :
5612 > else
5613 >  ac_cv_header_stdc=no
5614 > fi
5615 > rm -f conftest*
5616 >
5617 > fi
5618 >
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5621 >  if test "$cross_compiling" = yes; then
5622 >  :
5623 > else
5624 >  cat >conftest.$ac_ext <<_ACEOF
5625 > /* confdefs.h.  */
5626 > _ACEOF
5627 > cat confdefs.h >>conftest.$ac_ext
5628 > cat >>conftest.$ac_ext <<_ACEOF
5629 > /* end confdefs.h.  */
5630 > #include <ctype.h>
5631 > #if ((' ' & 0x0FF) == 0x020)
5632 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5633 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5634 > #else
5635 > # define ISLOWER(c) \
5636 >                   (('a' <= (c) && (c) <= 'i') \
5637 >                     || ('j' <= (c) && (c) <= 'r') \
5638 >                     || ('s' <= (c) && (c) <= 'z'))
5639 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5640 > #endif
5641 >
5642 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5643 > int
5644 > main ()
5645 > {
5646 >  int i;
5647 >  for (i = 0; i < 256; i++)
5648 >    if (XOR (islower (i), ISLOWER (i))
5649 >        || toupper (i) != TOUPPER (i))
5650 >      exit(2);
5651 >  exit (0);
5652 > }
5653 > _ACEOF
5654 > rm -f conftest$ac_exeext
5655 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5656 >  (eval $ac_link) 2>&5
5657 >  ac_status=$?
5658 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5659 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5660 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5661 >  (eval $ac_try) 2>&5
5662 >  ac_status=$?
5663 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5664 >  (exit $ac_status); }; }; then
5665 >  :
5666 > else
5667 >  echo "$as_me: program exited with status $ac_status" >&5
5668 > echo "$as_me: failed program was:" >&5
5669 > sed 's/^/| /' conftest.$ac_ext >&5
5670 >
5671 > ( exit $ac_status )
5672 > ac_cv_header_stdc=no
5673 > fi
5674 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5675 > fi
5676 > fi
5677 > fi
5678 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5679 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5680 > if test $ac_cv_header_stdc = yes; then
5681 >
5682 > cat >>confdefs.h <<\_ACEOF
5683 > #define STDC_HEADERS 1
5684 > _ACEOF
5685 >
5686 > fi
5687 >
5688 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5689 >
5690 >
5691 >
5692 >
5693 >
5694 >
5695 >
5696 >
5697 >
5698 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5699 >                  inttypes.h stdint.h unistd.h
5700 > do
5701 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5702 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5703 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5704 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5705 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5706 > else
5707 >  cat >conftest.$ac_ext <<_ACEOF
5708 > /* confdefs.h.  */
5709 > _ACEOF
5710 > cat confdefs.h >>conftest.$ac_ext
5711 > cat >>conftest.$ac_ext <<_ACEOF
5712 > /* end confdefs.h.  */
5713 > $ac_includes_default
5714 >
5715 > #include <$ac_header>
5716 > _ACEOF
5717 > rm -f conftest.$ac_objext
5718 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5719 >  (eval $ac_compile) 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); } &&
5726 >         { ac_try='test -z "$ac_c_werror_flag"
5727 >                         || test ! -s conftest.err'
5728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5729 >  (eval $ac_try) 2>&5
5730 >  ac_status=$?
5731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732 >  (exit $ac_status); }; } &&
5733 >         { ac_try='test -s conftest.$ac_objext'
5734 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5735 >  (eval $ac_try) 2>&5
5736 >  ac_status=$?
5737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5738 >  (exit $ac_status); }; }; then
5739 >  eval "$as_ac_Header=yes"
5740 > else
5741 >  echo "$as_me: failed program was:" >&5
5742 > sed 's/^/| /' conftest.$ac_ext >&5
5743 >
5744 > eval "$as_ac_Header=no"
5745 > fi
5746 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5747 > fi
5748 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5749 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5750 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5751 >  cat >>confdefs.h <<_ACEOF
5752 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5753 > _ACEOF
5754 >
5755 > fi
5756 >
5757 > done
5758 >
5759 >
5760 > #
5761 > # Handle user hints
5762 > #
5763 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5764 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5765 >
5766 > # Check whether --with-zlib or --without-zlib was given.
5767 > if test "${with_zlib+set}" = set; then
5768 >  withval="$with_zlib"
5769 >  if test "$withval" != no ; then
5770 >  echo "$as_me:$LINENO: result: yes" >&5
5771 > echo "${ECHO_T}yes" >&6
5772 >  if test -d "$withval"
5773 >  then
5774 >    ZLIB_HOME="$withval"
5775 >  else
5776 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5777 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5778 >  fi
5779 > else
5780 >  echo "$as_me:$LINENO: result: no" >&5
5781 > echo "${ECHO_T}no" >&6
5782 > fi
5783 > fi;
5784 >
5785 > ZLIB_HOME=/usr/local
5786 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5787 > then
5788 >        ZLIB_HOME=/usr
5789 > fi
5790 >
5791 > #
5792 > # Locate zlib, if wanted
5793 > #
5794 > if test -n "${ZLIB_HOME}"
5795 > then
5796 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5797 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5798 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5799 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5800 >
5801 >
5802 >        ac_ext=c
5803 > ac_cpp='$CPP $CPPFLAGS'
5804 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5805 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5806 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5807 >
5808 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5809 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5810 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5811 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5812 > else
5813 >  ac_check_lib_save_LIBS=$LIBS
5814 > LIBS="-lz  $LIBS"
5815 > cat >conftest.$ac_ext <<_ACEOF
5816 > /* confdefs.h.  */
5817 > _ACEOF
5818 > cat confdefs.h >>conftest.$ac_ext
5819 > cat >>conftest.$ac_ext <<_ACEOF
5820 > /* end confdefs.h.  */
5821 >
5822 > /* Override any gcc2 internal prototype to avoid an error.  */
5823 > #ifdef __cplusplus
5824 > extern "C"
5825 > #endif
5826 > /* We use char because int might match the return type of a gcc2
5827 >   builtin and then its argument prototype would still apply.  */
5828 > char inflateEnd ();
5829 > #ifdef FC_DUMMY_MAIN
5830 > #ifndef FC_DUMMY_MAIN_EQ_F77
5831 > #  ifdef __cplusplus
5832 >     extern "C"
5833 > #  endif
5834 >   int FC_DUMMY_MAIN() { return 1; }
5835 > #endif
5836 > #endif
5837 > int
5838 > main ()
5839 > {
5840 > inflateEnd ();
5841 >  ;
5842 >  return 0;
5843 > }
5844 > _ACEOF
5845 > rm -f conftest.$ac_objext conftest$ac_exeext
5846 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5847 >  (eval $ac_link) 2>conftest.er1
5848 >  ac_status=$?
5849 >  grep -v '^ *+' conftest.er1 >conftest.err
5850 >  rm -f conftest.er1
5851 >  cat conftest.err >&5
5852 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5853 >  (exit $ac_status); } &&
5854 >         { ac_try='test -z "$ac_c_werror_flag"
5855 >                         || test ! -s conftest.err'
5856 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5857 >  (eval $ac_try) 2>&5
5858 >  ac_status=$?
5859 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5860 >  (exit $ac_status); }; } &&
5861 >         { ac_try='test -s conftest$ac_exeext'
5862 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5863 >  (eval $ac_try) 2>&5
5864 >  ac_status=$?
5865 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5866 >  (exit $ac_status); }; }; then
5867 >  ac_cv_lib_z_inflateEnd=yes
5868 > else
5869 >  echo "$as_me: failed program was:" >&5
5870 > sed 's/^/| /' conftest.$ac_ext >&5
5871 >
5872 > ac_cv_lib_z_inflateEnd=no
5873 > fi
5874 > rm -f conftest.err conftest.$ac_objext \
5875 >      conftest$ac_exeext conftest.$ac_ext
5876 > LIBS=$ac_check_lib_save_LIBS
5877 > fi
5878 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5879 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5880 > if test $ac_cv_lib_z_inflateEnd = yes; then
5881 >  zlib_cv_libz=yes
5882 > else
5883 >  zlib_cv_libz=no
5884 > fi
5885 >
5886 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5887 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5888 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5889 > if test "${ac_cv_header_zlib_h+set}" = set; then
5890 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5891 > fi
5892 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5893 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5894 > else
5895 >  # Is the header compilable?
5896 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5897 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5898 > cat >conftest.$ac_ext <<_ACEOF
5899 > /* confdefs.h.  */
5900 > _ACEOF
5901 > cat confdefs.h >>conftest.$ac_ext
5902 > cat >>conftest.$ac_ext <<_ACEOF
5903 > /* end confdefs.h.  */
5904 > $ac_includes_default
5905 > #include <zlib.h>
5906 > _ACEOF
5907 > rm -f conftest.$ac_objext
5908 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5909 >  (eval $ac_compile) 2>conftest.er1
5910 >  ac_status=$?
5911 >  grep -v '^ *+' conftest.er1 >conftest.err
5912 >  rm -f conftest.er1
5913 >  cat conftest.err >&5
5914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915 >  (exit $ac_status); } &&
5916 >         { ac_try='test -z "$ac_c_werror_flag"
5917 >                         || test ! -s conftest.err'
5918 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5919 >  (eval $ac_try) 2>&5
5920 >  ac_status=$?
5921 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5922 >  (exit $ac_status); }; } &&
5923 >         { ac_try='test -s conftest.$ac_objext'
5924 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5925 >  (eval $ac_try) 2>&5
5926 >  ac_status=$?
5927 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5928 >  (exit $ac_status); }; }; then
5929 >  ac_header_compiler=yes
5930 > else
5931 >  echo "$as_me: failed program was:" >&5
5932 > sed 's/^/| /' conftest.$ac_ext >&5
5933 >
5934 > ac_header_compiler=no
5935 > fi
5936 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5937 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5938 > echo "${ECHO_T}$ac_header_compiler" >&6
5939 >
5940 > # Is the header present?
5941 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5942 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5943 > cat >conftest.$ac_ext <<_ACEOF
5944 > /* confdefs.h.  */
5945 > _ACEOF
5946 > cat confdefs.h >>conftest.$ac_ext
5947 > cat >>conftest.$ac_ext <<_ACEOF
5948 > /* end confdefs.h.  */
5949 > #include <zlib.h>
5950 > _ACEOF
5951 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5952 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5953 >  ac_status=$?
5954 >  grep -v '^ *+' conftest.er1 >conftest.err
5955 >  rm -f conftest.er1
5956 >  cat conftest.err >&5
5957 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5958 >  (exit $ac_status); } >/dev/null; then
5959 >  if test -s conftest.err; then
5960 >    ac_cpp_err=$ac_c_preproc_warn_flag
5961 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5962 >  else
5963 >    ac_cpp_err=
5964 >  fi
5965 > else
5966 >  ac_cpp_err=yes
5967 > fi
5968 > if test -z "$ac_cpp_err"; then
5969 >  ac_header_preproc=yes
5970 > else
5971 >  echo "$as_me: failed program was:" >&5
5972 > sed 's/^/| /' conftest.$ac_ext >&5
5973 >
5974 >  ac_header_preproc=no
5975 > fi
5976 > rm -f conftest.err conftest.$ac_ext
5977 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5978 > echo "${ECHO_T}$ac_header_preproc" >&6
5979 >
5980 > # So?  What about this header?
5981 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982 >  yes:no: )
5983 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5984 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5986 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5987 >    ac_header_preproc=yes
5988 >    ;;
5989 >  no:yes:* )
5990 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5991 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5992 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5993 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5994 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5995 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5996 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5997 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5998 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5999 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6000 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6001 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6002 >    (
6003 >      cat <<\_ASBOX
6004 > ## ------------------------------ ##
6005 > ## Report this to gezelter@nd.edu ##
6006 > ## ------------------------------ ##
6007 > _ASBOX
6008 >    ) |
6009 >      sed "s/^/$as_me: WARNING:     /" >&2
6010 >    ;;
6011 > esac
6012 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6013 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014 > if test "${ac_cv_header_zlib_h+set}" = set; then
6015 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6016 > else
6017 >  ac_cv_header_zlib_h=$ac_header_preproc
6018 > fi
6019 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6020 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6021 >
6022 > fi
6023 > if test $ac_cv_header_zlib_h = yes; then
6024 >  zlib_cv_zlib_h=yes
6025 > else
6026 >  zlib_cv_zlib_h=no
6027 > fi
6028 >
6029 >
6030 >        ac_ext=c
6031 > ac_cpp='$CPP $CPPFLAGS'
6032 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6033 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6035 >
6036 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6037 >        then
6038 >                #
6039 >                # If both library and header were found, use them
6040 >                #
6041 >
6042 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6043 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6044 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6045 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6046 > else
6047 >  ac_check_lib_save_LIBS=$LIBS
6048 > LIBS="-lz  $LIBS"
6049 > cat >conftest.$ac_ext <<_ACEOF
6050 > /* confdefs.h.  */
6051 > _ACEOF
6052 > cat confdefs.h >>conftest.$ac_ext
6053 > cat >>conftest.$ac_ext <<_ACEOF
6054 > /* end confdefs.h.  */
6055 >
6056 > /* Override any gcc2 internal prototype to avoid an error.  */
6057 > #ifdef __cplusplus
6058 > extern "C"
6059 > #endif
6060 > /* We use char because int might match the return type of a gcc2
6061 >   builtin and then its argument prototype would still apply.  */
6062 > char inflateEnd ();
6063 > #ifdef FC_DUMMY_MAIN
6064 > #ifndef FC_DUMMY_MAIN_EQ_F77
6065 > #  ifdef __cplusplus
6066 >     extern "C"
6067 > #  endif
6068 >   int FC_DUMMY_MAIN() { return 1; }
6069 > #endif
6070 > #endif
6071 > int
6072 > main ()
6073 > {
6074 > inflateEnd ();
6075 >  ;
6076 >  return 0;
6077 > }
6078 > _ACEOF
6079 > rm -f conftest.$ac_objext conftest$ac_exeext
6080 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6081 >  (eval $ac_link) 2>conftest.er1
6082 >  ac_status=$?
6083 >  grep -v '^ *+' conftest.er1 >conftest.err
6084 >  rm -f conftest.er1
6085 >  cat conftest.err >&5
6086 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6087 >  (exit $ac_status); } &&
6088 >         { ac_try='test -z "$ac_c_werror_flag"
6089 >                         || test ! -s conftest.err'
6090 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6091 >  (eval $ac_try) 2>&5
6092 >  ac_status=$?
6093 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6094 >  (exit $ac_status); }; } &&
6095 >         { ac_try='test -s conftest$ac_exeext'
6096 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6097 >  (eval $ac_try) 2>&5
6098 >  ac_status=$?
6099 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6100 >  (exit $ac_status); }; }; then
6101 >  ac_cv_lib_z_inflateEnd=yes
6102 > else
6103 >  echo "$as_me: failed program was:" >&5
6104 > sed 's/^/| /' conftest.$ac_ext >&5
6105 >
6106 > ac_cv_lib_z_inflateEnd=no
6107 > fi
6108 > rm -f conftest.err conftest.$ac_objext \
6109 >      conftest$ac_exeext conftest.$ac_ext
6110 > LIBS=$ac_check_lib_save_LIBS
6111 > fi
6112 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6113 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6114 > if test $ac_cv_lib_z_inflateEnd = yes; then
6115 >  cat >>confdefs.h <<_ACEOF
6116 > #define HAVE_LIBZ 1
6117 > _ACEOF
6118 >
6119 >  LIBS="-lz $LIBS"
6120 >
6121 > fi
6122 >
6123 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6124 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6125 >                echo "$as_me:$LINENO: result: ok" >&5
6126 > echo "${ECHO_T}ok" >&6
6127 >        else
6128 >                #
6129 >                # If either header or library was not found, revert and bomb
6130 >                #
6131 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6132 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6133 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6134 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6135 >                echo "$as_me:$LINENO: result: failed" >&5
6136 > echo "${ECHO_T}failed" >&6
6137 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6138 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6139 >   { (exit 1); exit 1; }; }
6140 >        fi
6141 > fi
6142 >
6143 >
6144 >
6145 > # Check whether --with-fftw or --without-fftw was given.
6146 > if test "${with_fftw+set}" = set; then
6147 >  withval="$with_fftw"
6148 >
6149 > else
6150 >  with_fftw=yes
6151 > fi;
6152 > if test "$with_fftw" = "no"; then
6153 >
6154 > cat >>confdefs.h <<\_ACEOF
6155 > #define WITHOUT_FFTW
6156 > _ACEOF
6157 >
6158 > fi
6159 > if test "$with_fftw" = "yes"; then
6160 >  sizeof_real=8
6161 >
6162 >
6163 > if test -z "$ac_fftw_firstname"; then
6164 >
6165 > sizeof_real=$sizeof_real
6166 > if test $sizeof_real = 8; then
6167 >  prec="double"
6168 >  fftwcheckprefix=d
6169 > else
6170 >  prec="single"
6171 >  fftwcheckprefix=s
6172 > fi
6173 >
6174 > xfftwname=${fftwcheckprefix}fftw3
6175 >
6176 > ok="no"
6177 > # check header doesn't work, since we must use mpicc to get includes,
6178 > # we cant trust cpp.
6179 > echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6180 > echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6181 > cat >conftest.$ac_ext <<_ACEOF
6182 > /* confdefs.h.  */
6183 > _ACEOF
6184 > cat confdefs.h >>conftest.$ac_ext
6185 > cat >>conftest.$ac_ext <<_ACEOF
6186 > /* end confdefs.h.  */
6187 > #include <$xfftwname.h>
6188 > #ifdef FC_DUMMY_MAIN
6189 > #ifndef FC_DUMMY_MAIN_EQ_F77
6190 > #  ifdef __cplusplus
6191 >     extern "C"
6192 > #  endif
6193 >   int FC_DUMMY_MAIN() { return 1; }
6194 > #endif
6195 > #endif
6196 > int
6197 > main ()
6198 > {
6199 >
6200 >  ;
6201 >  return 0;
6202 > }
6203 > _ACEOF
6204 > rm -f conftest.$ac_objext
6205 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6206 >  (eval $ac_compile) 2>conftest.er1
6207 >  ac_status=$?
6208 >  grep -v '^ *+' conftest.er1 >conftest.err
6209 >  rm -f conftest.er1
6210 >  cat conftest.err >&5
6211 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212 >  (exit $ac_status); } &&
6213 >         { ac_try='test -z "$ac_c_werror_flag"
6214 >                         || test ! -s conftest.err'
6215 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6216 >  (eval $ac_try) 2>&5
6217 >  ac_status=$?
6218 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6219 >  (exit $ac_status); }; } &&
6220 >         { ac_try='test -s conftest.$ac_objext'
6221 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6222 >  (eval $ac_try) 2>&5
6223 >  ac_status=$?
6224 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225 >  (exit $ac_status); }; }; then
6226 >
6227 > fftwname=$xfftwname
6228 > echo "$as_me:$LINENO: result: yes" >&5
6229 > echo "${ECHO_T}yes" >&6
6230 >
6231 > else
6232 >  echo "$as_me: failed program was:" >&5
6233 > sed 's/^/| /' conftest.$ac_ext >&5
6234 >
6235 > echo "$as_me:$LINENO: result: no" >&5
6236 > echo "${ECHO_T}no" >&6
6237 > fi
6238 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6239 >
6240 > # fftwname was set if we found a header
6241 >
6242 > if test -n "$fftwname"; then
6243 > # we cannot run the code since an MPI program might not be allowed
6244 > # on a login node of a supercomputer
6245 > cat >conftest.$ac_ext <<_ACEOF
6246 > /* confdefs.h.  */
6247 > _ACEOF
6248 > cat confdefs.h >>conftest.$ac_ext
6249 > cat >>conftest.$ac_ext <<_ACEOF
6250 > /* end confdefs.h.  */
6251 > #include <$fftwname.h>
6252 > #ifdef FC_DUMMY_MAIN
6253 > #ifndef FC_DUMMY_MAIN_EQ_F77
6254 > #  ifdef __cplusplus
6255 >     extern "C"
6256 > #  endif
6257 >   int FC_DUMMY_MAIN() { return 1; }
6258 > #endif
6259 > #endif
6260 > int
6261 > main ()
6262 > {
6263 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6264 >  ;
6265 >  return 0;
6266 > }
6267 > _ACEOF
6268 > rm -f conftest.$ac_objext
6269 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6270 >  (eval $ac_compile) 2>conftest.er1
6271 >  ac_status=$?
6272 >  grep -v '^ *+' conftest.er1 >conftest.err
6273 >  rm -f conftest.er1
6274 >  cat conftest.err >&5
6275 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276 >  (exit $ac_status); } &&
6277 >         { ac_try='test -z "$ac_c_werror_flag"
6278 >                         || test ! -s conftest.err'
6279 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6280 >  (eval $ac_try) 2>&5
6281 >  ac_status=$?
6282 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6283 >  (exit $ac_status); }; } &&
6284 >         { ac_try='test -s conftest.$ac_objext'
6285 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6286 >  (eval $ac_try) 2>&5
6287 >  ac_status=$?
6288 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6289 >  (exit $ac_status); }; }; then
6290 >
6291 > ok=yes
6292 > usedprefix=$fftwcheckprefix
6293 >
6294 > else
6295 >  echo "$as_me: failed program was:" >&5
6296 > sed 's/^/| /' conftest.$ac_ext >&5
6297 >
6298 > ok=no
6299 > fi
6300 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301 > fi
6302 >
6303 > if test "$ok" != "yes"; then
6304 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6305 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6306 >  cat >conftest.$ac_ext <<_ACEOF
6307 > /* confdefs.h.  */
6308 > _ACEOF
6309 > cat confdefs.h >>conftest.$ac_ext
6310 > cat >>conftest.$ac_ext <<_ACEOF
6311 > /* end confdefs.h.  */
6312 > #include <fftw3.h>
6313 > #ifdef FC_DUMMY_MAIN
6314 > #ifndef FC_DUMMY_MAIN_EQ_F77
6315 > #  ifdef __cplusplus
6316 >     extern "C"
6317 > #  endif
6318 >   int FC_DUMMY_MAIN() { return 1; }
6319 > #endif
6320 > #endif
6321 > int
6322 > main ()
6323 > {
6324 >
6325 >  ;
6326 >  return 0;
6327 > }
6328 > _ACEOF
6329 > rm -f conftest.$ac_objext
6330 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6331 >  (eval $ac_compile) 2>conftest.er1
6332 >  ac_status=$?
6333 >  grep -v '^ *+' conftest.er1 >conftest.err
6334 >  rm -f conftest.er1
6335 >  cat conftest.err >&5
6336 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337 >  (exit $ac_status); } &&
6338 >         { ac_try='test -z "$ac_c_werror_flag"
6339 >                         || test ! -s conftest.err'
6340 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6341 >  (eval $ac_try) 2>&5
6342 >  ac_status=$?
6343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6344 >  (exit $ac_status); }; } &&
6345 >         { ac_try='test -s conftest.$ac_objext'
6346 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6347 >  (eval $ac_try) 2>&5
6348 >  ac_status=$?
6349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350 >  (exit $ac_status); }; }; then
6351 >  echo "$as_me:$LINENO: result: yes" >&5
6352 > echo "${ECHO_T}yes" >&6
6353 > else
6354 >  echo "$as_me: failed program was:" >&5
6355 > sed 's/^/| /' conftest.$ac_ext >&5
6356 >
6357 >
6358 > echo "$as_me:$LINENO: result: no" >&5
6359 > echo "${ECHO_T}no" >&6
6360 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6361 > Do you have $prec precision FFTW installed? If you are using packages,
6362 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6363 > software at www.fftw.org.
6364 > If you compiled FFTW yourself:
6365 > Note that the default FFTW setup is double precision.  If you want MPI support,
6366 > use --with-mpi. It is a good idea to install both single & double.
6367 > If you have installed FFTW in a non-standard location, you should
6368 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6369 > variables before running configure.
6370 > That is also necessary to do if your compiler doesn't search
6371 > /usr/local/include and /usr/local/lib by default." >&5
6372 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6373 > Do you have $prec precision FFTW installed? If you are using packages,
6374 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6375 > software at www.fftw.org.
6376 > If you compiled FFTW yourself:
6377 > Note that the default FFTW setup is double precision.  If you want MPI support,
6378 > use --with-mpi. It is a good idea to install both single & double.
6379 > If you have installed FFTW in a non-standard location, you should
6380 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6381 > variables before running configure.
6382 > That is also necessary to do if your compiler doesn't search
6383 > /usr/local/include and /usr/local/lib by default." >&2;}
6384 >   { (exit 1); exit 1; }; }
6385 >
6386 > fi
6387 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6388 > cat >conftest.$ac_ext <<_ACEOF
6389 > /* confdefs.h.  */
6390 > _ACEOF
6391 > cat confdefs.h >>conftest.$ac_ext
6392 > cat >>conftest.$ac_ext <<_ACEOF
6393 > /* end confdefs.h.  */
6394 > #include <fftw3.h>
6395 > #ifdef FC_DUMMY_MAIN
6396 > #ifndef FC_DUMMY_MAIN_EQ_F77
6397 > #  ifdef __cplusplus
6398 >     extern "C"
6399 > #  endif
6400 >   int FC_DUMMY_MAIN() { return 1; }
6401 > #endif
6402 > #endif
6403 > int
6404 > main ()
6405 > {
6406 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6407 >  ;
6408 >  return 0;
6409 > }
6410 > _ACEOF
6411 > rm -f conftest.$ac_objext
6412 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6413 >  (eval $ac_compile) 2>conftest.er1
6414 >  ac_status=$?
6415 >  grep -v '^ *+' conftest.er1 >conftest.err
6416 >  rm -f conftest.er1
6417 >  cat conftest.err >&5
6418 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6419 >  (exit $ac_status); } &&
6420 >         { ac_try='test -z "$ac_c_werror_flag"
6421 >                         || test ! -s conftest.err'
6422 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6423 >  (eval $ac_try) 2>&5
6424 >  ac_status=$?
6425 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426 >  (exit $ac_status); }; } &&
6427 >         { ac_try='test -s conftest.$ac_objext'
6428 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6429 >  (eval $ac_try) 2>&5
6430 >  ac_status=$?
6431 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432 >  (exit $ac_status); }; }; then
6433 >
6434 > usedprefix=""
6435 > fftwname=fftw3
6436 >
6437 > else
6438 >  echo "$as_me: failed program was:" >&5
6439 > sed 's/^/| /' conftest.$ac_ext >&5
6440 >
6441 >
6442 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6443 > Do you have $prec precision FFTW installed? If you are using packages,
6444 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6445 > software at www.fftw.org.
6446 > If you compiled FFTW yourself:
6447 > Note that the default FFTW setup is double precision.  If you want MPI support,
6448 > use --with-mpi. It is a good idea to install both single & double.
6449 > If you have installed FFTW in a non-standard location, you should
6450 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6451 > variables before running configure.
6452 > That is also necessary to do if your compiler doesn't search
6453 > /usr/local/include and /usr/local/lib by default." >&5
6454 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6455 > Do you have $prec precision FFTW installed? If you are using packages,
6456 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6457 > software at www.fftw.org.
6458 > If you compiled FFTW yourself:
6459 > Note that the default FFTW setup is double precision.  If you want MPI support,
6460 > use --with-mpi. It is a good idea to install both single & double.
6461 > If you have installed FFTW in a non-standard location, you should
6462 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6463 > variables before running configure.
6464 > That is also necessary to do if your compiler doesn't search
6465 > /usr/local/include and /usr/local/lib by default." >&2;}
6466 >   { (exit 1); exit 1; }; }
6467 > fi
6468 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6469 > fi
6470 >
6471 >
6472 > as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6473 > echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6474 > echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6475 > if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6476 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6477 > else
6478 >  ac_check_lib_save_LIBS=$LIBS
6479 > LIBS="-l$fftwname  $LIBS"
6480 > cat >conftest.$ac_ext <<_ACEOF
6481 > /* confdefs.h.  */
6482 > _ACEOF
6483 > cat confdefs.h >>conftest.$ac_ext
6484 > cat >>conftest.$ac_ext <<_ACEOF
6485 > /* end confdefs.h.  */
6486 >
6487 >
6488 > #ifdef FC_DUMMY_MAIN
6489 > #ifndef FC_DUMMY_MAIN_EQ_F77
6490 > #  ifdef __cplusplus
6491 >     extern "C"
6492 > #  endif
6493 >   int FC_DUMMY_MAIN() { return 1; }
6494 > #endif
6495 > #endif
6496 > int
6497 > main ()
6498 > {
6499 > main ();
6500 >  ;
6501 >  return 0;
6502 > }
6503 > _ACEOF
6504 > rm -f conftest.$ac_objext conftest$ac_exeext
6505 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6506 >  (eval $ac_link) 2>conftest.er1
6507 >  ac_status=$?
6508 >  grep -v '^ *+' conftest.er1 >conftest.err
6509 >  rm -f conftest.er1
6510 >  cat conftest.err >&5
6511 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6512 >  (exit $ac_status); } &&
6513 >         { ac_try='test -z "$ac_c_werror_flag"
6514 >                         || test ! -s conftest.err'
6515 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6516 >  (eval $ac_try) 2>&5
6517 >  ac_status=$?
6518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519 >  (exit $ac_status); }; } &&
6520 >         { ac_try='test -s conftest$ac_exeext'
6521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6522 >  (eval $ac_try) 2>&5
6523 >  ac_status=$?
6524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6525 >  (exit $ac_status); }; }; then
6526 >  eval "$as_ac_Lib=yes"
6527 > else
6528 >  echo "$as_me: failed program was:" >&5
6529 > sed 's/^/| /' conftest.$ac_ext >&5
6530 >
6531 > eval "$as_ac_Lib=no"
6532 > fi
6533 > rm -f conftest.err conftest.$ac_objext \
6534 >      conftest$ac_exeext conftest.$ac_ext
6535 > LIBS=$ac_check_lib_save_LIBS
6536 > fi
6537 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
6538 > echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
6539 > if test `eval echo '${'$as_ac_Lib'}'` = yes; then
6540 >  cat >>confdefs.h <<_ACEOF
6541 > #define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
6542 > _ACEOF
6543 >
6544 >  LIBS="-l$fftwname $LIBS"
6545 >
6546 > else
6547 >  { { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
6548 > echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
6549 >   { (exit 1); exit 1; }; }
6550 > fi
6551 >
6552 > ac_fftw_savedprefix=$usedprefix
6553 > ac_fftw_firstname=$fftwname
6554 >
6555 > else
6556 >
6557 > fftwname=${ac_fftw_savedprefix}fftw3
6558 > echo "$as_me:$LINENO: checking for $fftwname.h" >&5
6559 > echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
6560 > cat >conftest.$ac_ext <<_ACEOF
6561 > /* confdefs.h.  */
6562 > _ACEOF
6563 > cat confdefs.h >>conftest.$ac_ext
6564 > cat >>conftest.$ac_ext <<_ACEOF
6565 > /* end confdefs.h.  */
6566 > #include <$fftwname.h>
6567 > #ifdef FC_DUMMY_MAIN
6568 > #ifndef FC_DUMMY_MAIN_EQ_F77
6569 > #  ifdef __cplusplus
6570 >     extern "C"
6571 > #  endif
6572 >   int FC_DUMMY_MAIN() { return 1; }
6573 > #endif
6574 > #endif
6575 > int
6576 > main ()
6577 > {
6578 >
6579 >  ;
6580 >  return 0;
6581 > }
6582 > _ACEOF
6583 > rm -f conftest.$ac_objext
6584 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6585 >  (eval $ac_compile) 2>conftest.er1
6586 >  ac_status=$?
6587 >  grep -v '^ *+' conftest.er1 >conftest.err
6588 >  rm -f conftest.er1
6589 >  cat conftest.err >&5
6590 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6591 >  (exit $ac_status); } &&
6592 >         { ac_try='test -z "$ac_c_werror_flag"
6593 >                         || test ! -s conftest.err'
6594 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6595 >  (eval $ac_try) 2>&5
6596 >  ac_status=$?
6597 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6598 >  (exit $ac_status); }; } &&
6599 >         { ac_try='test -s conftest.$ac_objext'
6600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6601 >  (eval $ac_try) 2>&5
6602 >  ac_status=$?
6603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6604 >  (exit $ac_status); }; }; then
6605 >  echo "$as_me:$LINENO: result: yes" >&5
6606 > echo "${ECHO_T}yes" >&6
6607 > LIBS="-l$fftwname $LIBS"
6608 > cat >conftest.$ac_ext <<_ACEOF
6609 > /* confdefs.h.  */
6610 > _ACEOF
6611 > cat confdefs.h >>conftest.$ac_ext
6612 > cat >>conftest.$ac_ext <<_ACEOF
6613 > /* end confdefs.h.  */
6614 >
6615 >
6616 > #ifdef FC_DUMMY_MAIN
6617 > #ifndef FC_DUMMY_MAIN_EQ_F77
6618 > #  ifdef __cplusplus
6619 >     extern "C"
6620 > #  endif
6621 >   int FC_DUMMY_MAIN() { return 1; }
6622 > #endif
6623 > #endif
6624 > int
6625 > main ()
6626 > {
6627 > main ();
6628 >  ;
6629 >  return 0;
6630 > }
6631 > _ACEOF
6632 > rm -f conftest.$ac_objext conftest$ac_exeext
6633 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6634 >  (eval $ac_link) 2>conftest.er1
6635 >  ac_status=$?
6636 >  grep -v '^ *+' conftest.er1 >conftest.err
6637 >  rm -f conftest.er1
6638 >  cat conftest.err >&5
6639 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6640 >  (exit $ac_status); } &&
6641 >         { ac_try='test -z "$ac_c_werror_flag"
6642 >                         || test ! -s conftest.err'
6643 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6644 >  (eval $ac_try) 2>&5
6645 >  ac_status=$?
6646 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647 >  (exit $ac_status); }; } &&
6648 >         { ac_try='test -s conftest$ac_exeext'
6649 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650 >  (eval $ac_try) 2>&5
6651 >  ac_status=$?
6652 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653 >  (exit $ac_status); }; }; then
6654 >  :
6655 > else
6656 >  echo "$as_me: failed program was:" >&5
6657 > sed 's/^/| /' conftest.$ac_ext >&5
6658 >
6659 > fi
6660 > rm -f conftest.err conftest.$ac_objext \
6661 >      conftest$ac_exeext conftest.$ac_ext
6662 > else
6663 >  echo "$as_me: failed program was:" >&5
6664 > sed 's/^/| /' conftest.$ac_ext >&5
6665 >
6666 >
6667 > echo "$as_me:$LINENO: result: no" >&5
6668 > echo "${ECHO_T}no" >&6
6669 > { { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
6670 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
6671 > echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
6672 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
6673 >   { (exit 1); exit 1; }; }
6674 >
6675 > fi
6676 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6677 >
6678 > fi
6679 >
6680 >
6681 >
6682 >  if test "$with_mpi" = "yes"; then
6683 >
6684 > if test -z "$ac_fftw_firstname"; then
6685 >
6686 > sizeof_real=$sizeof_real
6687 > if test $sizeof_real = 8; then
6688 >  prec="double"
6689 >  fftwcheckprefix=d
6690 > else
6691 >  prec="single"
6692 >  fftwcheckprefix=s
6693 > fi
6694 >
6695 > xfftwname=${fftwcheckprefix}fftw3_mpi
6696 >
6697 > ok="no"
6698 > # check header doesn't work, since we must use mpicc to get includes,
6699 > # we cant trust cpp.
6700 > echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6701 > echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6702 > cat >conftest.$ac_ext <<_ACEOF
6703 > /* confdefs.h.  */
6704 > _ACEOF
6705 > cat confdefs.h >>conftest.$ac_ext
6706 > cat >>conftest.$ac_ext <<_ACEOF
6707 > /* end confdefs.h.  */
6708 > #include <$xfftwname.h>
6709 > #ifdef FC_DUMMY_MAIN
6710 > #ifndef FC_DUMMY_MAIN_EQ_F77
6711 > #  ifdef __cplusplus
6712 >     extern "C"
6713 > #  endif
6714 >   int FC_DUMMY_MAIN() { return 1; }
6715 > #endif
6716 > #endif
6717 > int
6718 > main ()
6719 > {
6720 >
6721 >  ;
6722 >  return 0;
6723 > }
6724 > _ACEOF
6725 > rm -f conftest.$ac_objext
6726 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727 >  (eval $ac_compile) 2>conftest.er1
6728 >  ac_status=$?
6729 >  grep -v '^ *+' conftest.er1 >conftest.err
6730 >  rm -f conftest.er1
6731 >  cat conftest.err >&5
6732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733 >  (exit $ac_status); } &&
6734 >         { ac_try='test -z "$ac_c_werror_flag"
6735 >                         || test ! -s conftest.err'
6736 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737 >  (eval $ac_try) 2>&5
6738 >  ac_status=$?
6739 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740 >  (exit $ac_status); }; } &&
6741 >         { ac_try='test -s conftest.$ac_objext'
6742 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743 >  (eval $ac_try) 2>&5
6744 >  ac_status=$?
6745 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746 >  (exit $ac_status); }; }; then
6747 >
6748 > fftwname=$xfftwname
6749 > echo "$as_me:$LINENO: result: yes" >&5
6750 > echo "${ECHO_T}yes" >&6
6751 >
6752 > else
6753 >  echo "$as_me: failed program was:" >&5
6754 > sed 's/^/| /' conftest.$ac_ext >&5
6755 >
6756 > echo "$as_me:$LINENO: result: no" >&5
6757 > echo "${ECHO_T}no" >&6
6758 > fi
6759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760 >
6761 > # fftwname was set if we found a header
6762 >
6763 > if test -n "$fftwname"; then
6764 > # we cannot run the code since an MPI program might not be allowed
6765 > # on a login node of a supercomputer
6766 > cat >conftest.$ac_ext <<_ACEOF
6767 > /* confdefs.h.  */
6768 > _ACEOF
6769 > cat confdefs.h >>conftest.$ac_ext
6770 > cat >>conftest.$ac_ext <<_ACEOF
6771 > /* end confdefs.h.  */
6772 > #include <$fftwname.h>
6773 > #ifdef FC_DUMMY_MAIN
6774 > #ifndef FC_DUMMY_MAIN_EQ_F77
6775 > #  ifdef __cplusplus
6776 >     extern "C"
6777 > #  endif
6778 >   int FC_DUMMY_MAIN() { return 1; }
6779 > #endif
6780 > #endif
6781 > int
6782 > main ()
6783 > {
6784 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6785 >  ;
6786 >  return 0;
6787 > }
6788 > _ACEOF
6789 > rm -f conftest.$ac_objext
6790 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791 >  (eval $ac_compile) 2>conftest.er1
6792 >  ac_status=$?
6793 >  grep -v '^ *+' conftest.er1 >conftest.err
6794 >  rm -f conftest.er1
6795 >  cat conftest.err >&5
6796 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6797 >  (exit $ac_status); } &&
6798 >         { ac_try='test -z "$ac_c_werror_flag"
6799 >                         || test ! -s conftest.err'
6800 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6801 >  (eval $ac_try) 2>&5
6802 >  ac_status=$?
6803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6804 >  (exit $ac_status); }; } &&
6805 >         { ac_try='test -s conftest.$ac_objext'
6806 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6807 >  (eval $ac_try) 2>&5
6808 >  ac_status=$?
6809 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6810 >  (exit $ac_status); }; }; then
6811 >
6812 > ok=yes
6813 > usedprefix=$fftwcheckprefix
6814 >
6815 > else
6816 >  echo "$as_me: failed program was:" >&5
6817 > sed 's/^/| /' conftest.$ac_ext >&5
6818 >
6819 > ok=no
6820 > fi
6821 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6822 > fi
6823 >
6824 > if test "$ok" != "yes"; then
6825 >  echo "$as_me:$LINENO: checking for fftw3_mpi.h" >&5
6826 > echo $ECHO_N "checking for fftw3_mpi.h... $ECHO_C" >&6
6827 >  cat >conftest.$ac_ext <<_ACEOF
6828 > /* confdefs.h.  */
6829 > _ACEOF
6830 > cat confdefs.h >>conftest.$ac_ext
6831 > cat >>conftest.$ac_ext <<_ACEOF
6832 > /* end confdefs.h.  */
6833 > #include <fftw3_mpi.h>
6834 > #ifdef FC_DUMMY_MAIN
6835 > #ifndef FC_DUMMY_MAIN_EQ_F77
6836 > #  ifdef __cplusplus
6837 >     extern "C"
6838 > #  endif
6839 >   int FC_DUMMY_MAIN() { return 1; }
6840 > #endif
6841 > #endif
6842 > int
6843 > main ()
6844 > {
6845 >
6846 >  ;
6847 >  return 0;
6848 > }
6849 > _ACEOF
6850 > rm -f conftest.$ac_objext
6851 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6852 >  (eval $ac_compile) 2>conftest.er1
6853 >  ac_status=$?
6854 >  grep -v '^ *+' conftest.er1 >conftest.err
6855 >  rm -f conftest.er1
6856 >  cat conftest.err >&5
6857 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6858 >  (exit $ac_status); } &&
6859 >         { ac_try='test -z "$ac_c_werror_flag"
6860 >                         || test ! -s conftest.err'
6861 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6862 >  (eval $ac_try) 2>&5
6863 >  ac_status=$?
6864 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6865 >  (exit $ac_status); }; } &&
6866 >         { ac_try='test -s conftest.$ac_objext'
6867 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6868 >  (eval $ac_try) 2>&5
6869 >  ac_status=$?
6870 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871 >  (exit $ac_status); }; }; then
6872 >  echo "$as_me:$LINENO: result: yes" >&5
6873 > echo "${ECHO_T}yes" >&6
6874 > else
6875 >  echo "$as_me: failed program was:" >&5
6876 > sed 's/^/| /' conftest.$ac_ext >&5
6877 >
6878 >
6879 > echo "$as_me:$LINENO: result: no" >&5
6880 > echo "${ECHO_T}no" >&6
6881 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6882 > Do you have $prec precision FFTW installed? If you are using packages,
6883 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6884 > software at www.fftw.org.
6885 > If you compiled FFTW yourself:
6886 > Note that the default FFTW setup is double precision.  If you want MPI support,
6887 > use --with-mpi. It is a good idea to install both single & double.
6888 > If you have installed FFTW in a non-standard location, you should
6889 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6890 > variables before running configure.
6891 > That is also necessary to do if your compiler doesn't search
6892 > /usr/local/include and /usr/local/lib by default." >&5
6893 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6894 > Do you have $prec precision FFTW installed? If you are using packages,
6895 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6896 > software at www.fftw.org.
6897 > If you compiled FFTW yourself:
6898 > Note that the default FFTW setup is double precision.  If you want MPI support,
6899 > use --with-mpi. It is a good idea to install both single & double.
6900 > If you have installed FFTW in a non-standard location, you should
6901 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6902 > variables before running configure.
6903 > That is also necessary to do if your compiler doesn't search
6904 > /usr/local/include and /usr/local/lib by default." >&2;}
6905 >   { (exit 1); exit 1; }; }
6906 >
6907 > fi
6908 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6909 > cat >conftest.$ac_ext <<_ACEOF
6910 > /* confdefs.h.  */
6911 > _ACEOF
6912 > cat confdefs.h >>conftest.$ac_ext
6913 > cat >>conftest.$ac_ext <<_ACEOF
6914 > /* end confdefs.h.  */
6915 > #include <fftw3_mpi.h>
6916 > #ifdef FC_DUMMY_MAIN
6917 > #ifndef FC_DUMMY_MAIN_EQ_F77
6918 > #  ifdef __cplusplus
6919 >     extern "C"
6920 > #  endif
6921 >   int FC_DUMMY_MAIN() { return 1; }
6922 > #endif
6923 > #endif
6924 > int
6925 > main ()
6926 > {
6927 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6928 >  ;
6929 >  return 0;
6930 > }
6931 > _ACEOF
6932 > rm -f conftest.$ac_objext
6933 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6934 >  (eval $ac_compile) 2>conftest.er1
6935 >  ac_status=$?
6936 >  grep -v '^ *+' conftest.er1 >conftest.err
6937 >  rm -f conftest.er1
6938 >  cat conftest.err >&5
6939 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6940 >  (exit $ac_status); } &&
6941 >         { ac_try='test -z "$ac_c_werror_flag"
6942 >                         || test ! -s conftest.err'
6943 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6944 >  (eval $ac_try) 2>&5
6945 >  ac_status=$?
6946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947 >  (exit $ac_status); }; } &&
6948 >         { ac_try='test -s conftest.$ac_objext'
6949 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950 >  (eval $ac_try) 2>&5
6951 >  ac_status=$?
6952 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953 >  (exit $ac_status); }; }; then
6954 >
6955 > usedprefix=""
6956 > fftwname=fftw3_mpi
6957 >
6958 > else
6959 >  echo "$as_me: failed program was:" >&5
6960 > sed 's/^/| /' conftest.$ac_ext >&5
6961 >
6962 >
6963 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6964 > Do you have $prec precision FFTW installed? If you are using packages,
6965 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6966 > software at www.fftw.org.
6967 > If you compiled FFTW yourself:
6968 > Note that the default FFTW setup is double precision.  If you want MPI support,
6969 > use --with-mpi. It is a good idea to install both single & double.
6970 > If you have installed FFTW in a non-standard location, you should
6971 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6972 > variables before running configure.
6973 > That is also necessary to do if your compiler doesn't search
6974 > /usr/local/include and /usr/local/lib by default." >&5
6975 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6976 > Do you have $prec precision FFTW installed? If you are using packages,
6977 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6978 > software at www.fftw.org.
6979 > If you compiled FFTW yourself:
6980 > Note that the default FFTW setup is double precision.  If you want MPI support,
6981 > use --with-mpi. It is a good idea to install both single & double.
6982 > If you have installed FFTW in a non-standard location, you should
6983 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6984 > variables before running configure.
6985 > That is also necessary to do if your compiler doesn't search
6986 > /usr/local/include and /usr/local/lib by default." >&2;}
6987 >   { (exit 1); exit 1; }; }
6988 > fi
6989 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6990 > fi
6991 >
6992 >
6993 > as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6994 > echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6995 > echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6996 > if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6997 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6998 > else
6999 >  ac_check_lib_save_LIBS=$LIBS
7000 > LIBS="-l$fftwname  $LIBS"
7001 > cat >conftest.$ac_ext <<_ACEOF
7002 > /* confdefs.h.  */
7003 > _ACEOF
7004 > cat confdefs.h >>conftest.$ac_ext
7005 > cat >>conftest.$ac_ext <<_ACEOF
7006 > /* end confdefs.h.  */
7007 >
7008 >
7009 > #ifdef FC_DUMMY_MAIN
7010 > #ifndef FC_DUMMY_MAIN_EQ_F77
7011 > #  ifdef __cplusplus
7012 >     extern "C"
7013 > #  endif
7014 >   int FC_DUMMY_MAIN() { return 1; }
7015 > #endif
7016 > #endif
7017 > int
7018 > main ()
7019 > {
7020 > main ();
7021 >  ;
7022 >  return 0;
7023 > }
7024 > _ACEOF
7025 > rm -f conftest.$ac_objext conftest$ac_exeext
7026 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7027 >  (eval $ac_link) 2>conftest.er1
7028 >  ac_status=$?
7029 >  grep -v '^ *+' conftest.er1 >conftest.err
7030 >  rm -f conftest.er1
7031 >  cat conftest.err >&5
7032 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033 >  (exit $ac_status); } &&
7034 >         { ac_try='test -z "$ac_c_werror_flag"
7035 >                         || test ! -s conftest.err'
7036 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7037 >  (eval $ac_try) 2>&5
7038 >  ac_status=$?
7039 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040 >  (exit $ac_status); }; } &&
7041 >         { ac_try='test -s conftest$ac_exeext'
7042 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7043 >  (eval $ac_try) 2>&5
7044 >  ac_status=$?
7045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7046 >  (exit $ac_status); }; }; then
7047 >  eval "$as_ac_Lib=yes"
7048 > else
7049 >  echo "$as_me: failed program was:" >&5
7050 > sed 's/^/| /' conftest.$ac_ext >&5
7051 >
7052 > eval "$as_ac_Lib=no"
7053 > fi
7054 > rm -f conftest.err conftest.$ac_objext \
7055 >      conftest$ac_exeext conftest.$ac_ext
7056 > LIBS=$ac_check_lib_save_LIBS
7057 > fi
7058 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
7059 > echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
7060 > if test `eval echo '${'$as_ac_Lib'}'` = yes; then
7061 >  cat >>confdefs.h <<_ACEOF
7062 > #define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
7063 > _ACEOF
7064 >
7065 >  LIBS="-l$fftwname $LIBS"
7066 >
7067 > else
7068 >  { { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
7069 > echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
7070 >   { (exit 1); exit 1; }; }
7071 > fi
7072 >
7073 > ac_fftw_savedprefix=$usedprefix
7074 > ac_fftw_firstname=$fftwname
7075 >
7076 > else
7077 >
7078 > fftwname=${ac_fftw_savedprefix}fftw3_mpi
7079 > echo "$as_me:$LINENO: checking for $fftwname.h" >&5
7080 > echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
7081 > cat >conftest.$ac_ext <<_ACEOF
7082 > /* confdefs.h.  */
7083 > _ACEOF
7084 > cat confdefs.h >>conftest.$ac_ext
7085 > cat >>conftest.$ac_ext <<_ACEOF
7086 > /* end confdefs.h.  */
7087 > #include <$fftwname.h>
7088 > #ifdef FC_DUMMY_MAIN
7089 > #ifndef FC_DUMMY_MAIN_EQ_F77
7090 > #  ifdef __cplusplus
7091 >     extern "C"
7092 > #  endif
7093 >   int FC_DUMMY_MAIN() { return 1; }
7094 > #endif
7095 > #endif
7096 > int
7097 > main ()
7098 > {
7099 >
7100 >  ;
7101 >  return 0;
7102 > }
7103 > _ACEOF
7104 > rm -f conftest.$ac_objext
7105 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106 >  (eval $ac_compile) 2>conftest.er1
7107 >  ac_status=$?
7108 >  grep -v '^ *+' conftest.er1 >conftest.err
7109 >  rm -f conftest.er1
7110 >  cat conftest.err >&5
7111 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112 >  (exit $ac_status); } &&
7113 >         { ac_try='test -z "$ac_c_werror_flag"
7114 >                         || test ! -s conftest.err'
7115 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116 >  (eval $ac_try) 2>&5
7117 >  ac_status=$?
7118 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119 >  (exit $ac_status); }; } &&
7120 >         { ac_try='test -s conftest.$ac_objext'
7121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122 >  (eval $ac_try) 2>&5
7123 >  ac_status=$?
7124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125 >  (exit $ac_status); }; }; then
7126 >  echo "$as_me:$LINENO: result: yes" >&5
7127 > echo "${ECHO_T}yes" >&6
7128 > LIBS="-l$fftwname $LIBS"
7129 > cat >conftest.$ac_ext <<_ACEOF
7130 > /* confdefs.h.  */
7131 > _ACEOF
7132 > cat confdefs.h >>conftest.$ac_ext
7133 > cat >>conftest.$ac_ext <<_ACEOF
7134 > /* end confdefs.h.  */
7135 >
7136 >
7137 > #ifdef FC_DUMMY_MAIN
7138 > #ifndef FC_DUMMY_MAIN_EQ_F77
7139 > #  ifdef __cplusplus
7140 >     extern "C"
7141 > #  endif
7142 >   int FC_DUMMY_MAIN() { return 1; }
7143 > #endif
7144 > #endif
7145 > int
7146 > main ()
7147 > {
7148 > main ();
7149 >  ;
7150 >  return 0;
7151 > }
7152 > _ACEOF
7153 > rm -f conftest.$ac_objext conftest$ac_exeext
7154 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7155 >  (eval $ac_link) 2>conftest.er1
7156 >  ac_status=$?
7157 >  grep -v '^ *+' conftest.er1 >conftest.err
7158 >  rm -f conftest.er1
7159 >  cat conftest.err >&5
7160 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7161 >  (exit $ac_status); } &&
7162 >         { ac_try='test -z "$ac_c_werror_flag"
7163 >                         || test ! -s conftest.err'
7164 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7165 >  (eval $ac_try) 2>&5
7166 >  ac_status=$?
7167 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168 >  (exit $ac_status); }; } &&
7169 >         { ac_try='test -s conftest$ac_exeext'
7170 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171 >  (eval $ac_try) 2>&5
7172 >  ac_status=$?
7173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174 >  (exit $ac_status); }; }; then
7175 >  :
7176 > else
7177 >  echo "$as_me: failed program was:" >&5
7178 > sed 's/^/| /' conftest.$ac_ext >&5
7179 >
7180 > fi
7181 > rm -f conftest.err conftest.$ac_objext \
7182 >      conftest$ac_exeext conftest.$ac_ext
7183 > else
7184 >  echo "$as_me: failed program was:" >&5
7185 > sed 's/^/| /' conftest.$ac_ext >&5
7186 >
7187 >
7188 > echo "$as_me:$LINENO: result: no" >&5
7189 > echo "${ECHO_T}no" >&6
7190 > { { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
7191 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
7192 > echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
7193 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
7194 >   { (exit 1); exit 1; }; }
7195 >
7196 > fi
7197 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198 >
7199 > fi
7200 >
7201 >
7202 >  fi
7203 >
7204 >  case ${ac_fftw_savedprefix} in
7205 >   d)
7206 > cat >>confdefs.h <<\_ACEOF
7207 > #define FFTW_NAME_DFFTW
7208 > _ACEOF
7209 > ;;
7210 >   *)
7211 > cat >>confdefs.h <<\_ACEOF
7212 > #define FFTW_NAME_FFTW
7213 > _ACEOF
7214 > ;;
7215 >  esac
7216 > else
7217 >  echo "*******************************************************************"
7218 >  echo "* FFTW libraries and include files are required for computing     *"
7219 >  echo "* undulation spectra with the staticProps program.  If you don't  *"
7220 >  echo "* fftw turned on, OOPSE will still work, but you won't be able to *"
7221 >  echo "* analyze your trajectories for this property.                    *"
7222 >  echo "*******************************************************************"
7223 > fi # end of fftw check
7224 >
7225 > # Checks for header files.
7226 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7227 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7228 > if test "${ac_cv_header_stdc+set}" = set; then
7229 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7230 > else
7231 >  cat >conftest.$ac_ext <<_ACEOF
7232 > /* confdefs.h.  */
7233 > _ACEOF
7234 > cat confdefs.h >>conftest.$ac_ext
7235 > cat >>conftest.$ac_ext <<_ACEOF
7236 > /* end confdefs.h.  */
7237 > #include <stdlib.h>
7238 > #include <stdarg.h>
7239 > #include <string.h>
7240 > #include <float.h>
7241 >
7242 > #ifdef FC_DUMMY_MAIN
7243 > #ifndef FC_DUMMY_MAIN_EQ_F77
7244 > #  ifdef __cplusplus
7245 >     extern "C"
7246 > #  endif
7247 >   int FC_DUMMY_MAIN() { return 1; }
7248 > #endif
7249 > #endif
7250 > int
7251 > main ()
7252 > {
7253 >
7254 >  ;
7255 >  return 0;
7256 > }
7257 > _ACEOF
7258 > rm -f conftest.$ac_objext
7259 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7260 >  (eval $ac_compile) 2>conftest.er1
7261 >  ac_status=$?
7262 >  grep -v '^ *+' conftest.er1 >conftest.err
7263 >  rm -f conftest.er1
7264 >  cat conftest.err >&5
7265 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7266 >  (exit $ac_status); } &&
7267 >         { ac_try='test -z "$ac_c_werror_flag"
7268 >                         || test ! -s conftest.err'
7269 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7270 >  (eval $ac_try) 2>&5
7271 >  ac_status=$?
7272 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7273 >  (exit $ac_status); }; } &&
7274 >         { ac_try='test -s conftest.$ac_objext'
7275 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7276 >  (eval $ac_try) 2>&5
7277 >  ac_status=$?
7278 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7279 >  (exit $ac_status); }; }; then
7280 >  ac_cv_header_stdc=yes
7281 > else
7282 >  echo "$as_me: failed program was:" >&5
7283 > sed 's/^/| /' conftest.$ac_ext >&5
7284 >
7285 > ac_cv_header_stdc=no
7286 > fi
7287 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7288 >
7289 > if test $ac_cv_header_stdc = yes; then
7290 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7291 >  cat >conftest.$ac_ext <<_ACEOF
7292 > /* confdefs.h.  */
7293 > _ACEOF
7294 > cat confdefs.h >>conftest.$ac_ext
7295 > cat >>conftest.$ac_ext <<_ACEOF
7296 > /* end confdefs.h.  */
7297 > #include <string.h>
7298 >
7299 > _ACEOF
7300 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7301 >  $EGREP "memchr" >/dev/null 2>&1; then
7302 >  :
7303 > else
7304 >  ac_cv_header_stdc=no
7305 > fi
7306 > rm -f conftest*
7307 >
7308 > fi
7309 >
7310 > if test $ac_cv_header_stdc = yes; then
7311 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7312 >  cat >conftest.$ac_ext <<_ACEOF
7313 > /* confdefs.h.  */
7314 > _ACEOF
7315 > cat confdefs.h >>conftest.$ac_ext
7316 > cat >>conftest.$ac_ext <<_ACEOF
7317 > /* end confdefs.h.  */
7318 > #include <stdlib.h>
7319 >
7320 > _ACEOF
7321 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7322 >  $EGREP "free" >/dev/null 2>&1; then
7323 >  :
7324 > else
7325 >  ac_cv_header_stdc=no
7326 > fi
7327 > rm -f conftest*
7328 >
7329 > fi
7330 >
7331 > if test $ac_cv_header_stdc = yes; then
7332 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7333 >  if test "$cross_compiling" = yes; then
7334 >  :
7335 > else
7336 >  cat >conftest.$ac_ext <<_ACEOF
7337 > /* confdefs.h.  */
7338 > _ACEOF
7339 > cat confdefs.h >>conftest.$ac_ext
7340 > cat >>conftest.$ac_ext <<_ACEOF
7341 > /* end confdefs.h.  */
7342 > #include <ctype.h>
7343 > #if ((' ' & 0x0FF) == 0x020)
7344 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7345 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7346 > #else
7347 > # define ISLOWER(c) \
7348 >                   (('a' <= (c) && (c) <= 'i') \
7349 >                     || ('j' <= (c) && (c) <= 'r') \
7350 >                     || ('s' <= (c) && (c) <= 'z'))
7351 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7352 > #endif
7353 >
7354 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7355 > int
7356 > main ()
7357 > {
7358 >  int i;
7359 >  for (i = 0; i < 256; i++)
7360 >    if (XOR (islower (i), ISLOWER (i))
7361 >        || toupper (i) != TOUPPER (i))
7362 >      exit(2);
7363 >  exit (0);
7364 > }
7365 > _ACEOF
7366 > rm -f conftest$ac_exeext
7367 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7368 >  (eval $ac_link) 2>&5
7369 >  ac_status=$?
7370 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7372 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373 >  (eval $ac_try) 2>&5
7374 >  ac_status=$?
7375 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376 >  (exit $ac_status); }; }; then
7377 >  :
7378 > else
7379 >  echo "$as_me: program exited with status $ac_status" >&5
7380 > echo "$as_me: failed program was:" >&5
7381 > sed 's/^/| /' conftest.$ac_ext >&5
7382 >
7383 > ( exit $ac_status )
7384 > ac_cv_header_stdc=no
7385 > fi
7386 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7387 > fi
7388 > fi
7389 > fi
7390 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7391 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7392 > if test $ac_cv_header_stdc = yes; then
7393 >
7394 > cat >>confdefs.h <<\_ACEOF
7395 > #define STDC_HEADERS 1
7396 > _ACEOF
7397 >
7398 > fi
7399 >
7400 >
7401 >
7402 >
7403 >
7404 >
7405 >
7406 >
7407 >
7408 >
7409 >
7410 >
7411 >
7412 >
7413 >
7414 >
7415 >
7416 >
7417 >
7418 >
7419 >
7420 >
7421 >
7422 >
7423 >
7424 >
7425 > for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7426 > do
7427 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7428 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7429 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7430 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7431 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7432 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7433 > fi
7434 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7435 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7436 > else
7437 >  # Is the header compilable?
7438 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7439 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7440 > cat >conftest.$ac_ext <<_ACEOF
7441 > /* confdefs.h.  */
7442 > _ACEOF
7443 > cat confdefs.h >>conftest.$ac_ext
7444 > cat >>conftest.$ac_ext <<_ACEOF
7445 > /* end confdefs.h.  */
7446 > $ac_includes_default
7447 > #include <$ac_header>
7448 > _ACEOF
7449 > rm -f conftest.$ac_objext
7450 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451 >  (eval $ac_compile) 2>conftest.er1
7452 >  ac_status=$?
7453 >  grep -v '^ *+' conftest.er1 >conftest.err
7454 >  rm -f conftest.er1
7455 >  cat conftest.err >&5
7456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457 >  (exit $ac_status); } &&
7458 >         { ac_try='test -z "$ac_c_werror_flag"
7459 >                         || test ! -s conftest.err'
7460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461 >  (eval $ac_try) 2>&5
7462 >  ac_status=$?
7463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464 >  (exit $ac_status); }; } &&
7465 >         { ac_try='test -s conftest.$ac_objext'
7466 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467 >  (eval $ac_try) 2>&5
7468 >  ac_status=$?
7469 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470 >  (exit $ac_status); }; }; then
7471 >  ac_header_compiler=yes
7472 > else
7473 >  echo "$as_me: failed program was:" >&5
7474 > sed 's/^/| /' conftest.$ac_ext >&5
7475 >
7476 > ac_header_compiler=no
7477 > fi
7478 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7480 > echo "${ECHO_T}$ac_header_compiler" >&6
7481 >
7482 > # Is the header present?
7483 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7484 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7485 > cat >conftest.$ac_ext <<_ACEOF
7486 > /* confdefs.h.  */
7487 > _ACEOF
7488 > cat confdefs.h >>conftest.$ac_ext
7489 > cat >>conftest.$ac_ext <<_ACEOF
7490 > /* end confdefs.h.  */
7491 > #include <$ac_header>
7492 > _ACEOF
7493 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7494 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7495 >  ac_status=$?
7496 >  grep -v '^ *+' conftest.er1 >conftest.err
7497 >  rm -f conftest.er1
7498 >  cat conftest.err >&5
7499 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500 >  (exit $ac_status); } >/dev/null; then
7501 >  if test -s conftest.err; then
7502 >    ac_cpp_err=$ac_c_preproc_warn_flag
7503 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7504 >  else
7505 >    ac_cpp_err=
7506 >  fi
7507 > else
7508 >  ac_cpp_err=yes
7509 > fi
7510 > if test -z "$ac_cpp_err"; then
7511 >  ac_header_preproc=yes
7512 > else
7513 >  echo "$as_me: failed program was:" >&5
7514 > sed 's/^/| /' conftest.$ac_ext >&5
7515 >
7516 >  ac_header_preproc=no
7517 > fi
7518 > rm -f conftest.err conftest.$ac_ext
7519 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7520 > echo "${ECHO_T}$ac_header_preproc" >&6
7521 >
7522 > # So?  What about this header?
7523 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7524 >  yes:no: )
7525 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7526 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7527 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7528 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7529 >    ac_header_preproc=yes
7530 >    ;;
7531 >  no:yes:* )
7532 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7533 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7534 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7535 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7536 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7537 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7538 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7539 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7540 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7541 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7542 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7543 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7544 >    (
7545 >      cat <<\_ASBOX
7546 > ## ------------------------------ ##
7547 > ## Report this to gezelter@nd.edu ##
7548 > ## ------------------------------ ##
7549 > _ASBOX
7550 >    ) |
7551 >      sed "s/^/$as_me: WARNING:     /" >&2
7552 >    ;;
7553 > esac
7554 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7555 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7556 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7557 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7558 > else
7559 >  eval "$as_ac_Header=\$ac_header_preproc"
7560 > fi
7561 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7562 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7563 >
7564 > fi
7565 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7566 >  cat >>confdefs.h <<_ACEOF
7567 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7568 > _ACEOF
7569 >
7570 > fi
7571 >
7572 > done
7573 >
7574 >
7575 > # Checks for typedefs, structures, and compiler characteristics.
7576 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7577 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7578 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7579 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7580 > else
7581 >  cat >conftest.$ac_ext <<_ACEOF
7582 > /* confdefs.h.  */
7583 > _ACEOF
7584 > cat confdefs.h >>conftest.$ac_ext
7585 > cat >>conftest.$ac_ext <<_ACEOF
7586 > /* end confdefs.h.  */
7587 >
7588 > #include <stdbool.h>
7589 > #ifndef bool
7590 > # error bool is not defined
7591 > #endif
7592 > #ifndef false
7593 > # error false is not defined
7594 > #endif
7595 > #if false
7596 > # error false is not 0
7597 > #endif
7598 > #ifndef true
7599 > # error true is not defined
7600 > #endif
7601 > #if true != 1
7602 > # error true is not 1
7603 > #endif
7604 > #ifndef __bool_true_false_are_defined
7605 > # error __bool_true_false_are_defined is not defined
7606 > #endif
7607 >
7608 >        struct s { _Bool s: 1; _Bool t; } s;
7609 >
7610 >        char a[true == 1 ? 1 : -1];
7611 >        char b[false == 0 ? 1 : -1];
7612 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7613 >        char d[(bool) -0.5 == true ? 1 : -1];
7614 >        bool e = &s;
7615 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7616 >        char g[true];
7617 >        char h[sizeof (_Bool)];
7618 >        char i[sizeof s.t];
7619 >
7620 > #ifdef FC_DUMMY_MAIN
7621 > #ifndef FC_DUMMY_MAIN_EQ_F77
7622 > #  ifdef __cplusplus
7623 >     extern "C"
7624 > #  endif
7625 >   int FC_DUMMY_MAIN() { return 1; }
7626 > #endif
7627 > #endif
7628 > int
7629 > main ()
7630 > {
7631 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7632 >  ;
7633 >  return 0;
7634 > }
7635 > _ACEOF
7636 > rm -f conftest.$ac_objext
7637 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7638 >  (eval $ac_compile) 2>conftest.er1
7639 >  ac_status=$?
7640 >  grep -v '^ *+' conftest.er1 >conftest.err
7641 >  rm -f conftest.er1
7642 >  cat conftest.err >&5
7643 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644 >  (exit $ac_status); } &&
7645 >         { ac_try='test -z "$ac_c_werror_flag"
7646 >                         || test ! -s conftest.err'
7647 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7648 >  (eval $ac_try) 2>&5
7649 >  ac_status=$?
7650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7651 >  (exit $ac_status); }; } &&
7652 >         { ac_try='test -s conftest.$ac_objext'
7653 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654 >  (eval $ac_try) 2>&5
7655 >  ac_status=$?
7656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657 >  (exit $ac_status); }; }; then
7658 >  ac_cv_header_stdbool_h=yes
7659 > else
7660 >  echo "$as_me: failed program was:" >&5
7661 > sed 's/^/| /' conftest.$ac_ext >&5
7662 >
7663 > ac_cv_header_stdbool_h=no
7664 > fi
7665 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666 > fi
7667 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7668 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7669 > echo "$as_me:$LINENO: checking for _Bool" >&5
7670 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7671 > if test "${ac_cv_type__Bool+set}" = set; then
7672 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7673 > else
7674 >  cat >conftest.$ac_ext <<_ACEOF
7675 > /* confdefs.h.  */
7676 > _ACEOF
7677 > cat confdefs.h >>conftest.$ac_ext
7678 > cat >>conftest.$ac_ext <<_ACEOF
7679 > /* end confdefs.h.  */
7680 > $ac_includes_default
7681 > #ifdef FC_DUMMY_MAIN
7682 > #ifndef FC_DUMMY_MAIN_EQ_F77
7683 > #  ifdef __cplusplus
7684 >     extern "C"
7685 > #  endif
7686 >   int FC_DUMMY_MAIN() { return 1; }
7687 > #endif
7688 > #endif
7689 > int
7690 > main ()
7691 > {
7692 > if ((_Bool *) 0)
7693 >  return 0;
7694 > if (sizeof (_Bool))
7695 >  return 0;
7696 >  ;
7697 >  return 0;
7698 > }
7699 > _ACEOF
7700 > rm -f conftest.$ac_objext
7701 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7702 >  (eval $ac_compile) 2>conftest.er1
7703 >  ac_status=$?
7704 >  grep -v '^ *+' conftest.er1 >conftest.err
7705 >  rm -f conftest.er1
7706 >  cat conftest.err >&5
7707 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7708 >  (exit $ac_status); } &&
7709 >         { ac_try='test -z "$ac_c_werror_flag"
7710 >                         || test ! -s conftest.err'
7711 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7712 >  (eval $ac_try) 2>&5
7713 >  ac_status=$?
7714 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7715 >  (exit $ac_status); }; } &&
7716 >         { ac_try='test -s conftest.$ac_objext'
7717 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718 >  (eval $ac_try) 2>&5
7719 >  ac_status=$?
7720 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721 >  (exit $ac_status); }; }; then
7722 >  ac_cv_type__Bool=yes
7723 > else
7724 >  echo "$as_me: failed program was:" >&5
7725 > sed 's/^/| /' conftest.$ac_ext >&5
7726 >
7727 > ac_cv_type__Bool=no
7728 > fi
7729 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730 > fi
7731 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7732 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7733 > if test $ac_cv_type__Bool = yes; then
7734 >
7735 > cat >>confdefs.h <<_ACEOF
7736 > #define HAVE__BOOL 1
7737 > _ACEOF
7738 >
7739 >
7740 > fi
7741 >
7742 > if test $ac_cv_header_stdbool_h = yes; then
7743 >
7744 > cat >>confdefs.h <<\_ACEOF
7745 > #define HAVE_STDBOOL_H 1
7746 > _ACEOF
7747 >
7748 > fi
7749 >
7750 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7751 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7752 > if test "${ac_cv_c_const+set}" = set; then
7753 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7754 > else
7755 >  cat >conftest.$ac_ext <<_ACEOF
7756 > /* confdefs.h.  */
7757 > _ACEOF
7758 > cat confdefs.h >>conftest.$ac_ext
7759 > cat >>conftest.$ac_ext <<_ACEOF
7760 > /* end confdefs.h.  */
7761 >
7762 > #ifdef FC_DUMMY_MAIN
7763 > #ifndef FC_DUMMY_MAIN_EQ_F77
7764 > #  ifdef __cplusplus
7765 >     extern "C"
7766 > #  endif
7767 >   int FC_DUMMY_MAIN() { return 1; }
7768 > #endif
7769 > #endif
7770 > int
7771 > main ()
7772 > {
7773 > /* FIXME: Include the comments suggested by Paul. */
7774 > #ifndef __cplusplus
7775 >  /* Ultrix mips cc rejects this.  */
7776 >  typedef int charset[2];
7777 >  const charset x;
7778 >  /* SunOS 4.1.1 cc rejects this.  */
7779 >  char const *const *ccp;
7780 >  char **p;
7781 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7782 >  struct point {int x, y;};
7783 >  static struct point const zero = {0,0};
7784 >  /* AIX XL C 1.02.0.0 rejects this.
7785 >     It does not let you subtract one const X* pointer from another in
7786 >     an arm of an if-expression whose if-part is not a constant
7787 >     expression */
7788 >  const char *g = "string";
7789 >  ccp = &g + (g ? g-g : 0);
7790 >  /* HPUX 7.0 cc rejects these. */
7791 >  ++ccp;
7792 >  p = (char**) ccp;
7793 >  ccp = (char const *const *) p;
7794 >  { /* SCO 3.2v4 cc rejects this.  */
7795 >    char *t;
7796 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7797 >
7798 >    *t++ = 0;
7799 >  }
7800 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7801 >    int x[] = {25, 17};
7802 >    const int *foo = &x[0];
7803 >    ++foo;
7804 >  }
7805 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7806 >    typedef const int *iptr;
7807 >    iptr p = 0;
7808 >    ++p;
7809 >  }
7810 >  { /* AIX XL C 1.02.0.0 rejects this saying
7811 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7812 >    struct s { int j; const int *ap[3]; };
7813 >    struct s *b; b->j = 5;
7814 >  }
7815 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7816 >    const int foo = 10;
7817 >  }
7818 > #endif
7819 >
7820 >  ;
7821 >  return 0;
7822 > }
7823 > _ACEOF
7824 > rm -f conftest.$ac_objext
7825 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7826 >  (eval $ac_compile) 2>conftest.er1
7827 >  ac_status=$?
7828 >  grep -v '^ *+' conftest.er1 >conftest.err
7829 >  rm -f conftest.er1
7830 >  cat conftest.err >&5
7831 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832 >  (exit $ac_status); } &&
7833 >         { ac_try='test -z "$ac_c_werror_flag"
7834 >                         || test ! -s conftest.err'
7835 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7836 >  (eval $ac_try) 2>&5
7837 >  ac_status=$?
7838 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7839 >  (exit $ac_status); }; } &&
7840 >         { ac_try='test -s conftest.$ac_objext'
7841 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7842 >  (eval $ac_try) 2>&5
7843 >  ac_status=$?
7844 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7845 >  (exit $ac_status); }; }; then
7846 >  ac_cv_c_const=yes
7847 > else
7848 >  echo "$as_me: failed program was:" >&5
7849 > sed 's/^/| /' conftest.$ac_ext >&5
7850 >
7851 > ac_cv_c_const=no
7852 > fi
7853 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7854 > fi
7855 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7856 > echo "${ECHO_T}$ac_cv_c_const" >&6
7857 > if test $ac_cv_c_const = no; then
7858 >
7859 > cat >>confdefs.h <<\_ACEOF
7860 > #define const
7861 > _ACEOF
7862 >
7863 > fi
7864 >
7865 > echo "$as_me:$LINENO: checking for inline" >&5
7866 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7867 > if test "${ac_cv_c_inline+set}" = set; then
7868 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7869 > else
7870 >  ac_cv_c_inline=no
7871 > for ac_kw in inline __inline__ __inline; do
7872 >  cat >conftest.$ac_ext <<_ACEOF
7873 > /* confdefs.h.  */
7874 > _ACEOF
7875 > cat confdefs.h >>conftest.$ac_ext
7876 > cat >>conftest.$ac_ext <<_ACEOF
7877 > /* end confdefs.h.  */
7878 > #ifndef __cplusplus
7879 > typedef int foo_t;
7880 > static $ac_kw foo_t static_foo () {return 0; }
7881 > $ac_kw foo_t foo () {return 0; }
7882 > #endif
7883 >
7884 > _ACEOF
7885 > rm -f conftest.$ac_objext
7886 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7887 >  (eval $ac_compile) 2>conftest.er1
7888 >  ac_status=$?
7889 >  grep -v '^ *+' conftest.er1 >conftest.err
7890 >  rm -f conftest.er1
7891 >  cat conftest.err >&5
7892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7893 >  (exit $ac_status); } &&
7894 >         { ac_try='test -z "$ac_c_werror_flag"
7895 >                         || test ! -s conftest.err'
7896 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7897 >  (eval $ac_try) 2>&5
7898 >  ac_status=$?
7899 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7900 >  (exit $ac_status); }; } &&
7901 >         { ac_try='test -s conftest.$ac_objext'
7902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7903 >  (eval $ac_try) 2>&5
7904 >  ac_status=$?
7905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906 >  (exit $ac_status); }; }; then
7907 >  ac_cv_c_inline=$ac_kw; break
7908 > else
7909 >  echo "$as_me: failed program was:" >&5
7910 > sed 's/^/| /' conftest.$ac_ext >&5
7911 >
7912 > fi
7913 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914 > done
7915 >
7916 > fi
7917 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7918 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7919 >
7920 >
7921 > case $ac_cv_c_inline in
7922 >  inline | yes) ;;
7923 >  *)
7924 >    case $ac_cv_c_inline in
7925 >      no) ac_val=;;
7926 >      *) ac_val=$ac_cv_c_inline;;
7927 >    esac
7928 >    cat >>confdefs.h <<_ACEOF
7929 > #ifndef __cplusplus
7930 > #define inline $ac_val
7931 > #endif
7932 > _ACEOF
7933 >    ;;
7934 > esac
7935 >
7936 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7937 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7938 > if test "${ac_cv_c_restrict+set}" = set; then
7939 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7940 > else
7941 >  ac_cv_c_restrict=no
7942 >   # Try the official restrict keyword, then gcc's __restrict, and
7943 >   # the less common variants.
7944 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7945 >     cat >conftest.$ac_ext <<_ACEOF
7946 > /* confdefs.h.  */
7947 > _ACEOF
7948 > cat confdefs.h >>conftest.$ac_ext
7949 > cat >>conftest.$ac_ext <<_ACEOF
7950 > /* end confdefs.h.  */
7951 > float * $ac_kw x;
7952 > _ACEOF
7953 > rm -f conftest.$ac_objext
7954 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7955 >  (eval $ac_compile) 2>conftest.er1
7956 >  ac_status=$?
7957 >  grep -v '^ *+' conftest.er1 >conftest.err
7958 >  rm -f conftest.er1
7959 >  cat conftest.err >&5
7960 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7961 >  (exit $ac_status); } &&
7962 >         { ac_try='test -z "$ac_c_werror_flag"
7963 >                         || test ! -s conftest.err'
7964 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7965 >  (eval $ac_try) 2>&5
7966 >  ac_status=$?
7967 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968 >  (exit $ac_status); }; } &&
7969 >         { ac_try='test -s conftest.$ac_objext'
7970 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7971 >  (eval $ac_try) 2>&5
7972 >  ac_status=$?
7973 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7974 >  (exit $ac_status); }; }; then
7975 >  ac_cv_c_restrict=$ac_kw; break
7976 > else
7977 >  echo "$as_me: failed program was:" >&5
7978 > sed 's/^/| /' conftest.$ac_ext >&5
7979 >
7980 > fi
7981 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7982 >   done
7983 >
7984 > fi
7985 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7986 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7987 > case $ac_cv_c_restrict in
7988 >   restrict) ;;
7989 >   no)
7990 > cat >>confdefs.h <<\_ACEOF
7991 > #define restrict
7992 > _ACEOF
7993 > ;;
7994 >   *)  cat >>confdefs.h <<_ACEOF
7995 > #define restrict $ac_cv_c_restrict
7996 > _ACEOF
7997 > ;;
7998 > esac
7999 >
8000 > echo "$as_me:$LINENO: checking for size_t" >&5
8001 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8002 > if test "${ac_cv_type_size_t+set}" = set; then
8003 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8004 > else
8005 >  cat >conftest.$ac_ext <<_ACEOF
8006 > /* confdefs.h.  */
8007 > _ACEOF
8008 > cat confdefs.h >>conftest.$ac_ext
8009 > cat >>conftest.$ac_ext <<_ACEOF
8010 > /* end confdefs.h.  */
8011 > $ac_includes_default
8012 > #ifdef FC_DUMMY_MAIN
8013 > #ifndef FC_DUMMY_MAIN_EQ_F77
8014 > #  ifdef __cplusplus
8015 >     extern "C"
8016 > #  endif
8017 >   int FC_DUMMY_MAIN() { return 1; }
8018 > #endif
8019 > #endif
8020 > int
8021 > main ()
8022 > {
8023 > if ((size_t *) 0)
8024 >  return 0;
8025 > if (sizeof (size_t))
8026 >  return 0;
8027 >  ;
8028 >  return 0;
8029 > }
8030 > _ACEOF
8031 > rm -f conftest.$ac_objext
8032 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8033 >  (eval $ac_compile) 2>conftest.er1
8034 >  ac_status=$?
8035 >  grep -v '^ *+' conftest.er1 >conftest.err
8036 >  rm -f conftest.er1
8037 >  cat conftest.err >&5
8038 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8039 >  (exit $ac_status); } &&
8040 >         { ac_try='test -z "$ac_c_werror_flag"
8041 >                         || test ! -s conftest.err'
8042 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8043 >  (eval $ac_try) 2>&5
8044 >  ac_status=$?
8045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8046 >  (exit $ac_status); }; } &&
8047 >         { ac_try='test -s conftest.$ac_objext'
8048 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8049 >  (eval $ac_try) 2>&5
8050 >  ac_status=$?
8051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8052 >  (exit $ac_status); }; }; then
8053 >  ac_cv_type_size_t=yes
8054 > else
8055 >  echo "$as_me: failed program was:" >&5
8056 > sed 's/^/| /' conftest.$ac_ext >&5
8057 >
8058 > ac_cv_type_size_t=no
8059 > fi
8060 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8061 > fi
8062 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8063 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
8064 > if test $ac_cv_type_size_t = yes; then
8065 >  :
8066 > else
8067 >
8068 > cat >>confdefs.h <<_ACEOF
8069 > #define size_t unsigned
8070 > _ACEOF
8071 >
8072 > fi
8073 >
8074 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8075 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8076 > if test "${ac_cv_header_time+set}" = set; then
8077 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8078 > else
8079 >  cat >conftest.$ac_ext <<_ACEOF
8080 > /* confdefs.h.  */
8081 > _ACEOF
8082 > cat confdefs.h >>conftest.$ac_ext
8083 > cat >>conftest.$ac_ext <<_ACEOF
8084 > /* end confdefs.h.  */
8085 > #include <sys/types.h>
8086 > #include <sys/time.h>
8087 > #include <time.h>
8088 >
8089 > #ifdef FC_DUMMY_MAIN
8090 > #ifndef FC_DUMMY_MAIN_EQ_F77
8091 > #  ifdef __cplusplus
8092 >     extern "C"
8093 > #  endif
8094 >   int FC_DUMMY_MAIN() { return 1; }
8095 > #endif
8096 > #endif
8097 > int
8098 > main ()
8099 > {
8100 > if ((struct tm *) 0)
8101 > return 0;
8102 >  ;
8103 >  return 0;
8104 > }
8105 > _ACEOF
8106 > rm -f conftest.$ac_objext
8107 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8108 >  (eval $ac_compile) 2>conftest.er1
8109 >  ac_status=$?
8110 >  grep -v '^ *+' conftest.er1 >conftest.err
8111 >  rm -f conftest.er1
8112 >  cat conftest.err >&5
8113 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8114 >  (exit $ac_status); } &&
8115 >         { ac_try='test -z "$ac_c_werror_flag"
8116 >                         || test ! -s conftest.err'
8117 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8118 >  (eval $ac_try) 2>&5
8119 >  ac_status=$?
8120 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121 >  (exit $ac_status); }; } &&
8122 >         { ac_try='test -s conftest.$ac_objext'
8123 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8124 >  (eval $ac_try) 2>&5
8125 >  ac_status=$?
8126 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8127 >  (exit $ac_status); }; }; then
8128 >  ac_cv_header_time=yes
8129 > else
8130 >  echo "$as_me: failed program was:" >&5
8131 > sed 's/^/| /' conftest.$ac_ext >&5
8132 >
8133 > ac_cv_header_time=no
8134 > fi
8135 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136 > fi
8137 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8138 > echo "${ECHO_T}$ac_cv_header_time" >&6
8139 > if test $ac_cv_header_time = yes; then
8140 >
8141 > cat >>confdefs.h <<\_ACEOF
8142 > #define TIME_WITH_SYS_TIME 1
8143 > _ACEOF
8144 >
8145 > fi
8146 >
8147 > echo "$as_me:$LINENO: checking for clock_t" >&5
8148 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8149 > if test "${ac_cv_type_clock_t+set}" = set; then
8150 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8151 > else
8152 >  cat >conftest.$ac_ext <<_ACEOF
8153 > /* confdefs.h.  */
8154 > _ACEOF
8155 > cat confdefs.h >>conftest.$ac_ext
8156 > cat >>conftest.$ac_ext <<_ACEOF
8157 > /* end confdefs.h.  */
8158 > $ac_includes_default
8159 > #ifdef FC_DUMMY_MAIN
8160 > #ifndef FC_DUMMY_MAIN_EQ_F77
8161 > #  ifdef __cplusplus
8162 >     extern "C"
8163 > #  endif
8164 >   int FC_DUMMY_MAIN() { return 1; }
8165 > #endif
8166 > #endif
8167 > int
8168 > main ()
8169 > {
8170 > if ((clock_t *) 0)
8171 >  return 0;
8172 > if (sizeof (clock_t))
8173 >  return 0;
8174 >  ;
8175 >  return 0;
8176 > }
8177 > _ACEOF
8178 > rm -f conftest.$ac_objext
8179 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180 >  (eval $ac_compile) 2>conftest.er1
8181 >  ac_status=$?
8182 >  grep -v '^ *+' conftest.er1 >conftest.err
8183 >  rm -f conftest.er1
8184 >  cat conftest.err >&5
8185 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186 >  (exit $ac_status); } &&
8187 >         { ac_try='test -z "$ac_c_werror_flag"
8188 >                         || test ! -s conftest.err'
8189 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190 >  (eval $ac_try) 2>&5
8191 >  ac_status=$?
8192 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193 >  (exit $ac_status); }; } &&
8194 >         { ac_try='test -s conftest.$ac_objext'
8195 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196 >  (eval $ac_try) 2>&5
8197 >  ac_status=$?
8198 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199 >  (exit $ac_status); }; }; then
8200 >  ac_cv_type_clock_t=yes
8201 > else
8202 >  echo "$as_me: failed program was:" >&5
8203 > sed 's/^/| /' conftest.$ac_ext >&5
8204 >
8205 > ac_cv_type_clock_t=no
8206 > fi
8207 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8208 > fi
8209 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8210 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8211 > if test $ac_cv_type_clock_t = yes; then
8212 >
8213 > cat >>confdefs.h <<_ACEOF
8214 > #define HAVE_CLOCK_T 1
8215 > _ACEOF
8216 >
8217 >
8218 > fi
8219 >
8220 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8221 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8222 > if test "${ac_cv_c_const+set}" = set; then
8223 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8224 > else
8225 >  cat >conftest.$ac_ext <<_ACEOF
8226 > /* confdefs.h.  */
8227 > _ACEOF
8228 > cat confdefs.h >>conftest.$ac_ext
8229 > cat >>conftest.$ac_ext <<_ACEOF
8230 > /* end confdefs.h.  */
8231 >
8232 > #ifdef FC_DUMMY_MAIN
8233 > #ifndef FC_DUMMY_MAIN_EQ_F77
8234 > #  ifdef __cplusplus
8235 >     extern "C"
8236 > #  endif
8237 >   int FC_DUMMY_MAIN() { return 1; }
8238 > #endif
8239 > #endif
8240 > int
8241 > main ()
8242 > {
8243 > /* FIXME: Include the comments suggested by Paul. */
8244 > #ifndef __cplusplus
8245 >  /* Ultrix mips cc rejects this.  */
8246 >  typedef int charset[2];
8247 >  const charset x;
8248 >  /* SunOS 4.1.1 cc rejects this.  */
8249 >  char const *const *ccp;
8250 >  char **p;
8251 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8252 >  struct point {int x, y;};
8253 >  static struct point const zero = {0,0};
8254 >  /* AIX XL C 1.02.0.0 rejects this.
8255 >     It does not let you subtract one const X* pointer from another in
8256 >     an arm of an if-expression whose if-part is not a constant
8257 >     expression */
8258 >  const char *g = "string";
8259 >  ccp = &g + (g ? g-g : 0);
8260 >  /* HPUX 7.0 cc rejects these. */
8261 >  ++ccp;
8262 >  p = (char**) ccp;
8263 >  ccp = (char const *const *) p;
8264 >  { /* SCO 3.2v4 cc rejects this.  */
8265 >    char *t;
8266 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8267 >
8268 >    *t++ = 0;
8269 >  }
8270 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8271 >    int x[] = {25, 17};
8272 >    const int *foo = &x[0];
8273 >    ++foo;
8274 >  }
8275 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8276 >    typedef const int *iptr;
8277 >    iptr p = 0;
8278 >    ++p;
8279 >  }
8280 >  { /* AIX XL C 1.02.0.0 rejects this saying
8281 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8282 >    struct s { int j; const int *ap[3]; };
8283 >    struct s *b; b->j = 5;
8284 >  }
8285 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8286 >    const int foo = 10;
8287 >  }
8288 > #endif
8289 >
8290 >  ;
8291 >  return 0;
8292 > }
8293 > _ACEOF
8294 > rm -f conftest.$ac_objext
8295 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8296 >  (eval $ac_compile) 2>conftest.er1
8297 >  ac_status=$?
8298 >  grep -v '^ *+' conftest.er1 >conftest.err
8299 >  rm -f conftest.er1
8300 >  cat conftest.err >&5
8301 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302 >  (exit $ac_status); } &&
8303 >         { ac_try='test -z "$ac_c_werror_flag"
8304 >                         || test ! -s conftest.err'
8305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306 >  (eval $ac_try) 2>&5
8307 >  ac_status=$?
8308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309 >  (exit $ac_status); }; } &&
8310 >         { ac_try='test -s conftest.$ac_objext'
8311 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8312 >  (eval $ac_try) 2>&5
8313 >  ac_status=$?
8314 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8315 >  (exit $ac_status); }; }; then
8316 >  ac_cv_c_const=yes
8317 > else
8318 >  echo "$as_me: failed program was:" >&5
8319 > sed 's/^/| /' conftest.$ac_ext >&5
8320 >
8321 > ac_cv_c_const=no
8322 > fi
8323 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8324 > fi
8325 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8326 > echo "${ECHO_T}$ac_cv_c_const" >&6
8327 > if test $ac_cv_c_const = no; then
8328 >
8329 > cat >>confdefs.h <<\_ACEOF
8330 > #define const
8331 > _ACEOF
8332 >
8333 > fi
8334 >
8335 > echo "$as_me:$LINENO: checking for inline" >&5
8336 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8337 > if test "${ac_cv_c_inline+set}" = set; then
8338 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8339 > else
8340 >  ac_cv_c_inline=no
8341 > for ac_kw in inline __inline__ __inline; do
8342 >  cat >conftest.$ac_ext <<_ACEOF
8343 > /* confdefs.h.  */
8344 > _ACEOF
8345 > cat confdefs.h >>conftest.$ac_ext
8346 > cat >>conftest.$ac_ext <<_ACEOF
8347 > /* end confdefs.h.  */
8348 > #ifndef __cplusplus
8349 > typedef int foo_t;
8350 > static $ac_kw foo_t static_foo () {return 0; }
8351 > $ac_kw foo_t foo () {return 0; }
8352 > #endif
8353 >
8354 > _ACEOF
8355 > rm -f conftest.$ac_objext
8356 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8357 >  (eval $ac_compile) 2>conftest.er1
8358 >  ac_status=$?
8359 >  grep -v '^ *+' conftest.er1 >conftest.err
8360 >  rm -f conftest.er1
8361 >  cat conftest.err >&5
8362 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8363 >  (exit $ac_status); } &&
8364 >         { ac_try='test -z "$ac_c_werror_flag"
8365 >                         || test ! -s conftest.err'
8366 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8367 >  (eval $ac_try) 2>&5
8368 >  ac_status=$?
8369 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370 >  (exit $ac_status); }; } &&
8371 >         { ac_try='test -s conftest.$ac_objext'
8372 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373 >  (eval $ac_try) 2>&5
8374 >  ac_status=$?
8375 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376 >  (exit $ac_status); }; }; then
8377 >  ac_cv_c_inline=$ac_kw; break
8378 > else
8379 >  echo "$as_me: failed program was:" >&5
8380 > sed 's/^/| /' conftest.$ac_ext >&5
8381 >
8382 > fi
8383 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8384 > done
8385 >
8386 > fi
8387 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8388 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8389 >
8390 >
8391 > case $ac_cv_c_inline in
8392 >  inline | yes) ;;
8393 >  *)
8394 >    case $ac_cv_c_inline in
8395 >      no) ac_val=;;
8396 >      *) ac_val=$ac_cv_c_inline;;
8397 >    esac
8398 >    cat >>confdefs.h <<_ACEOF
8399 > #ifndef __cplusplus
8400 > #define inline $ac_val
8401 > #endif
8402 > _ACEOF
8403 >    ;;
8404 > esac
8405 >
8406 >
8407 > # Checks for library functions.
8408 >
8409 > for ac_header in stdlib.h
8410 > do
8411 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8412 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8413 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8414 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8415 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8416 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8417 > fi
8418 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8419 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8420 > else
8421 >  # Is the header compilable?
8422 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8423 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8424 > cat >conftest.$ac_ext <<_ACEOF
8425 > /* confdefs.h.  */
8426 > _ACEOF
8427 > cat confdefs.h >>conftest.$ac_ext
8428 > cat >>conftest.$ac_ext <<_ACEOF
8429 > /* end confdefs.h.  */
8430 > $ac_includes_default
8431 > #include <$ac_header>
8432 > _ACEOF
8433 > rm -f conftest.$ac_objext
8434 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8435 >  (eval $ac_compile) 2>conftest.er1
8436 >  ac_status=$?
8437 >  grep -v '^ *+' conftest.er1 >conftest.err
8438 >  rm -f conftest.er1
8439 >  cat conftest.err >&5
8440 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8441 >  (exit $ac_status); } &&
8442 >         { ac_try='test -z "$ac_c_werror_flag"
8443 >                         || test ! -s conftest.err'
8444 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445 >  (eval $ac_try) 2>&5
8446 >  ac_status=$?
8447 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448 >  (exit $ac_status); }; } &&
8449 >         { ac_try='test -s conftest.$ac_objext'
8450 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451 >  (eval $ac_try) 2>&5
8452 >  ac_status=$?
8453 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454 >  (exit $ac_status); }; }; then
8455 >  ac_header_compiler=yes
8456 > else
8457 >  echo "$as_me: failed program was:" >&5
8458 > sed 's/^/| /' conftest.$ac_ext >&5
8459 >
8460 > ac_header_compiler=no
8461 > fi
8462 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8463 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8464 > echo "${ECHO_T}$ac_header_compiler" >&6
8465 >
8466 > # Is the header present?
8467 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8468 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8469 > cat >conftest.$ac_ext <<_ACEOF
8470 > /* confdefs.h.  */
8471 > _ACEOF
8472 > cat confdefs.h >>conftest.$ac_ext
8473 > cat >>conftest.$ac_ext <<_ACEOF
8474 > /* end confdefs.h.  */
8475 > #include <$ac_header>
8476 > _ACEOF
8477 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8478 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8479 >  ac_status=$?
8480 >  grep -v '^ *+' conftest.er1 >conftest.err
8481 >  rm -f conftest.er1
8482 >  cat conftest.err >&5
8483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484 >  (exit $ac_status); } >/dev/null; then
8485 >  if test -s conftest.err; then
8486 >    ac_cpp_err=$ac_c_preproc_warn_flag
8487 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8488 >  else
8489 >    ac_cpp_err=
8490 >  fi
8491 > else
8492 >  ac_cpp_err=yes
8493 > fi
8494 > if test -z "$ac_cpp_err"; then
8495 >  ac_header_preproc=yes
8496 > else
8497 >  echo "$as_me: failed program was:" >&5
8498 > sed 's/^/| /' conftest.$ac_ext >&5
8499 >
8500 >  ac_header_preproc=no
8501 > fi
8502 > rm -f conftest.err conftest.$ac_ext
8503 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8504 > echo "${ECHO_T}$ac_header_preproc" >&6
8505 >
8506 > # So?  What about this header?
8507 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8508 >  yes:no: )
8509 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8510 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8511 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8512 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8513 >    ac_header_preproc=yes
8514 >    ;;
8515 >  no:yes:* )
8516 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8517 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8518 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8519 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8520 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8521 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8522 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8523 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8524 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8525 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8526 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8527 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8528 >    (
8529 >      cat <<\_ASBOX
8530 > ## ------------------------------ ##
8531 > ## Report this to gezelter@nd.edu ##
8532 > ## ------------------------------ ##
8533 > _ASBOX
8534 >    ) |
8535 >      sed "s/^/$as_me: WARNING:     /" >&2
8536 >    ;;
8537 > esac
8538 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8539 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8540 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8541 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8542 > else
8543 >  eval "$as_ac_Header=\$ac_header_preproc"
8544 > fi
8545 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8546 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8547 >
8548 > fi
8549 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8550 >  cat >>confdefs.h <<_ACEOF
8551 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8552 > _ACEOF
8553 >
8554 > fi
8555 >
8556 > done
8557 >
8558 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8559 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8560 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8561 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8562 > else
8563 >  if test "$cross_compiling" = yes; then
8564 >  ac_cv_func_malloc_0_nonnull=no
8565 > else
8566 >  cat >conftest.$ac_ext <<_ACEOF
8567 > /* confdefs.h.  */
8568 > _ACEOF
8569 > cat confdefs.h >>conftest.$ac_ext
8570 > cat >>conftest.$ac_ext <<_ACEOF
8571 > /* end confdefs.h.  */
8572 > #if STDC_HEADERS || HAVE_STDLIB_H
8573 > # include <stdlib.h>
8574 > #else
8575 > char *malloc ();
8576 > #endif
8577 >
8578 > #ifdef FC_DUMMY_MAIN
8579 > #ifndef FC_DUMMY_MAIN_EQ_F77
8580 > #  ifdef __cplusplus
8581 >     extern "C"
8582 > #  endif
8583 >   int FC_DUMMY_MAIN() { return 1; }
8584 > #endif
8585 > #endif
8586 > int
8587 > main ()
8588 > {
8589 > exit (malloc (0) ? 0 : 1);
8590 >  ;
8591 >  return 0;
8592 > }
8593 > _ACEOF
8594 > rm -f conftest$ac_exeext
8595 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8596 >  (eval $ac_link) 2>&5
8597 >  ac_status=$?
8598 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8601 >  (eval $ac_try) 2>&5
8602 >  ac_status=$?
8603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604 >  (exit $ac_status); }; }; then
8605 >  ac_cv_func_malloc_0_nonnull=yes
8606 > else
8607 >  echo "$as_me: program exited with status $ac_status" >&5
8608 > echo "$as_me: failed program was:" >&5
8609 > sed 's/^/| /' conftest.$ac_ext >&5
8610 >
8611 > ( exit $ac_status )
8612 > ac_cv_func_malloc_0_nonnull=no
8613 > fi
8614 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8615 > fi
8616 > fi
8617 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8618 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8619 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8620 >
8621 > cat >>confdefs.h <<\_ACEOF
8622 > #define HAVE_MALLOC 1
8623 > _ACEOF
8624 >
8625 > else
8626 >  cat >>confdefs.h <<\_ACEOF
8627 > #define HAVE_MALLOC 0
8628 > _ACEOF
8629 >
8630 >   case $LIBOBJS in
8631 >    "malloc.$ac_objext"   | \
8632 >  *" malloc.$ac_objext"   | \
8633 >    "malloc.$ac_objext "* | \
8634 >  *" malloc.$ac_objext "* ) ;;
8635 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8636 > esac
8637 >
8638 >
8639 > cat >>confdefs.h <<\_ACEOF
8640 > #define malloc rpl_malloc
8641 > _ACEOF
8642 >
8643 > fi
8644 >
8645 >
8646 >
8647 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8648 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8649 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8650 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8651 > else
8652 >  if test "$cross_compiling" = yes; then
8653 >  ac_cv_func_memcmp_working=no
8654 > else
8655 >  cat >conftest.$ac_ext <<_ACEOF
8656 > /* confdefs.h.  */
8657 > _ACEOF
8658 > cat confdefs.h >>conftest.$ac_ext
8659 > cat >>conftest.$ac_ext <<_ACEOF
8660 > /* end confdefs.h.  */
8661 > $ac_includes_default
8662 > #ifdef FC_DUMMY_MAIN
8663 > #ifndef FC_DUMMY_MAIN_EQ_F77
8664 > #  ifdef __cplusplus
8665 >     extern "C"
8666 > #  endif
8667 >   int FC_DUMMY_MAIN() { return 1; }
8668 > #endif
8669 > #endif
8670 > int
8671 > main ()
8672 > {
8673 >
8674 >  /* Some versions of memcmp are not 8-bit clean.  */
8675 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8676 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8677 >    exit (1);
8678 >
8679 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8680 >     or more and with at least one buffer not starting on a 4-byte boundary.
8681 >     William Lewis provided this test program.   */
8682 >  {
8683 >    char foo[21];
8684 >    char bar[21];
8685 >    int i;
8686 >    for (i = 0; i < 4; i++)
8687 >      {
8688 >        char *a = foo + i;
8689 >        char *b = bar + i;
8690 >        strcpy (a, "--------01111111");
8691 >        strcpy (b, "--------10000000");
8692 >        if (memcmp (a, b, 16) >= 0)
8693 >          exit (1);
8694 >      }
8695 >    exit (0);
8696 >  }
8697 >
8698 >  ;
8699 >  return 0;
8700 > }
8701 > _ACEOF
8702 > rm -f conftest$ac_exeext
8703 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8704 >  (eval $ac_link) 2>&5
8705 >  ac_status=$?
8706 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8707 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8708 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709 >  (eval $ac_try) 2>&5
8710 >  ac_status=$?
8711 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712 >  (exit $ac_status); }; }; then
8713 >  ac_cv_func_memcmp_working=yes
8714 > else
8715 >  echo "$as_me: program exited with status $ac_status" >&5
8716 > echo "$as_me: failed program was:" >&5
8717 > sed 's/^/| /' conftest.$ac_ext >&5
8718 >
8719 > ( exit $ac_status )
8720 > ac_cv_func_memcmp_working=no
8721 > fi
8722 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8723 > fi
8724 > fi
8725 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8726 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8727 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8728 >    "memcmp.$ac_objext"   | \
8729 >  *" memcmp.$ac_objext"   | \
8730 >    "memcmp.$ac_objext "* | \
8731 >  *" memcmp.$ac_objext "* ) ;;
8732 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8733 > esac
8734 >
8735 >
8736 >
8737 > for ac_header in stdlib.h
8738 > do
8739 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8740 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8741 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8742 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8743 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8744 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8745 > fi
8746 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8747 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8748 > else
8749 >  # Is the header compilable?
8750 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8751 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8752 > cat >conftest.$ac_ext <<_ACEOF
8753 > /* confdefs.h.  */
8754 > _ACEOF
8755 > cat confdefs.h >>conftest.$ac_ext
8756 > cat >>conftest.$ac_ext <<_ACEOF
8757 > /* end confdefs.h.  */
8758 > $ac_includes_default
8759 > #include <$ac_header>
8760 > _ACEOF
8761 > rm -f conftest.$ac_objext
8762 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8763 >  (eval $ac_compile) 2>conftest.er1
8764 >  ac_status=$?
8765 >  grep -v '^ *+' conftest.er1 >conftest.err
8766 >  rm -f conftest.er1
8767 >  cat conftest.err >&5
8768 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8769 >  (exit $ac_status); } &&
8770 >         { ac_try='test -z "$ac_c_werror_flag"
8771 >                         || test ! -s conftest.err'
8772 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8773 >  (eval $ac_try) 2>&5
8774 >  ac_status=$?
8775 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8776 >  (exit $ac_status); }; } &&
8777 >         { ac_try='test -s conftest.$ac_objext'
8778 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779 >  (eval $ac_try) 2>&5
8780 >  ac_status=$?
8781 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782 >  (exit $ac_status); }; }; then
8783 >  ac_header_compiler=yes
8784 > else
8785 >  echo "$as_me: failed program was:" >&5
8786 > sed 's/^/| /' conftest.$ac_ext >&5
8787 >
8788 > ac_header_compiler=no
8789 > fi
8790 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8791 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8792 > echo "${ECHO_T}$ac_header_compiler" >&6
8793 >
8794 > # Is the header present?
8795 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8796 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8797 > cat >conftest.$ac_ext <<_ACEOF
8798 > /* confdefs.h.  */
8799 > _ACEOF
8800 > cat confdefs.h >>conftest.$ac_ext
8801 > cat >>conftest.$ac_ext <<_ACEOF
8802 > /* end confdefs.h.  */
8803 > #include <$ac_header>
8804 > _ACEOF
8805 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8806 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8807 >  ac_status=$?
8808 >  grep -v '^ *+' conftest.er1 >conftest.err
8809 >  rm -f conftest.er1
8810 >  cat conftest.err >&5
8811 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8812 >  (exit $ac_status); } >/dev/null; then
8813 >  if test -s conftest.err; then
8814 >    ac_cpp_err=$ac_c_preproc_warn_flag
8815 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8816 >  else
8817 >    ac_cpp_err=
8818 >  fi
8819 > else
8820 >  ac_cpp_err=yes
8821 > fi
8822 > if test -z "$ac_cpp_err"; then
8823 >  ac_header_preproc=yes
8824 > else
8825 >  echo "$as_me: failed program was:" >&5
8826 > sed 's/^/| /' conftest.$ac_ext >&5
8827 >
8828 >  ac_header_preproc=no
8829 > fi
8830 > rm -f conftest.err conftest.$ac_ext
8831 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8832 > echo "${ECHO_T}$ac_header_preproc" >&6
8833 >
8834 > # So?  What about this header?
8835 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8836 >  yes:no: )
8837 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8838 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8839 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8840 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8841 >    ac_header_preproc=yes
8842 >    ;;
8843 >  no:yes:* )
8844 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8845 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8846 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8847 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8848 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8849 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8850 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8851 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8852 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8853 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8854 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8855 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8856 >    (
8857 >      cat <<\_ASBOX
8858 > ## ------------------------------ ##
8859 > ## Report this to gezelter@nd.edu ##
8860 > ## ------------------------------ ##
8861 > _ASBOX
8862 >    ) |
8863 >      sed "s/^/$as_me: WARNING:     /" >&2
8864 >    ;;
8865 > esac
8866 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8867 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8868 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8869 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8870 > else
8871 >  eval "$as_ac_Header=\$ac_header_preproc"
8872 > fi
8873 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8874 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8875 >
8876 > fi
8877 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8878 >  cat >>confdefs.h <<_ACEOF
8879 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8880 > _ACEOF
8881 >
8882 > fi
8883 >
8884 > done
8885 >
8886 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8887 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8888 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8890 > else
8891 >  if test "$cross_compiling" = yes; then
8892 >  ac_cv_func_realloc_0_nonnull=no
8893 > else
8894 >  cat >conftest.$ac_ext <<_ACEOF
8895 > /* confdefs.h.  */
8896 > _ACEOF
8897 > cat confdefs.h >>conftest.$ac_ext
8898 > cat >>conftest.$ac_ext <<_ACEOF
8899 > /* end confdefs.h.  */
8900 > #if STDC_HEADERS || HAVE_STDLIB_H
8901 > # include <stdlib.h>
8902 > #else
8903 > char *realloc ();
8904 > #endif
8905 >
8906 > #ifdef FC_DUMMY_MAIN
8907 > #ifndef FC_DUMMY_MAIN_EQ_F77
8908 > #  ifdef __cplusplus
8909 >     extern "C"
8910 > #  endif
8911 >   int FC_DUMMY_MAIN() { return 1; }
8912 > #endif
8913 > #endif
8914 > int
8915 > main ()
8916 > {
8917 > exit (realloc (0, 0) ? 0 : 1);
8918 >  ;
8919 >  return 0;
8920 > }
8921 > _ACEOF
8922 > rm -f conftest$ac_exeext
8923 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8924 >  (eval $ac_link) 2>&5
8925 >  ac_status=$?
8926 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8928 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929 >  (eval $ac_try) 2>&5
8930 >  ac_status=$?
8931 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932 >  (exit $ac_status); }; }; then
8933 >  ac_cv_func_realloc_0_nonnull=yes
8934 > else
8935 >  echo "$as_me: program exited with status $ac_status" >&5
8936 > echo "$as_me: failed program was:" >&5
8937 > sed 's/^/| /' conftest.$ac_ext >&5
8938 >
8939 > ( exit $ac_status )
8940 > ac_cv_func_realloc_0_nonnull=no
8941 > fi
8942 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8943 > fi
8944 > fi
8945 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8946 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8947 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8948 >
8949 > cat >>confdefs.h <<\_ACEOF
8950 > #define HAVE_REALLOC 1
8951 > _ACEOF
8952 >
8953 > else
8954 >  cat >>confdefs.h <<\_ACEOF
8955 > #define HAVE_REALLOC 0
8956 > _ACEOF
8957 >
8958 >   case $LIBOBJS in
8959 >    "realloc.$ac_objext"   | \
8960 >  *" realloc.$ac_objext"   | \
8961 >    "realloc.$ac_objext "* | \
8962 >  *" realloc.$ac_objext "* ) ;;
8963 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8964 > esac
8965 >
8966 >
8967 > cat >>confdefs.h <<\_ACEOF
8968 > #define realloc rpl_realloc
8969 > _ACEOF
8970 >
8971 > fi
8972 >
8973 >
8974 >
8975 >
8976 >
8977 > for ac_header in sys/select.h sys/socket.h
8978 > do
8979 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8980 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8981 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8982 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8983 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8984 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8985 > fi
8986 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8987 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8988 > else
8989 >  # Is the header compilable?
8990 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8991 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8992 > cat >conftest.$ac_ext <<_ACEOF
8993 > /* confdefs.h.  */
8994 > _ACEOF
8995 > cat confdefs.h >>conftest.$ac_ext
8996 > cat >>conftest.$ac_ext <<_ACEOF
8997 > /* end confdefs.h.  */
8998 > $ac_includes_default
8999 > #include <$ac_header>
9000 > _ACEOF
9001 > rm -f conftest.$ac_objext
9002 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9003 >  (eval $ac_compile) 2>conftest.er1
9004 >  ac_status=$?
9005 >  grep -v '^ *+' conftest.er1 >conftest.err
9006 >  rm -f conftest.er1
9007 >  cat conftest.err >&5
9008 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009 >  (exit $ac_status); } &&
9010 >         { ac_try='test -z "$ac_c_werror_flag"
9011 >                         || test ! -s conftest.err'
9012 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9013 >  (eval $ac_try) 2>&5
9014 >  ac_status=$?
9015 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9016 >  (exit $ac_status); }; } &&
9017 >         { ac_try='test -s conftest.$ac_objext'
9018 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9019 >  (eval $ac_try) 2>&5
9020 >  ac_status=$?
9021 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022 >  (exit $ac_status); }; }; then
9023 >  ac_header_compiler=yes
9024 > else
9025 >  echo "$as_me: failed program was:" >&5
9026 > sed 's/^/| /' conftest.$ac_ext >&5
9027 >
9028 > ac_header_compiler=no
9029 > fi
9030 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9031 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9032 > echo "${ECHO_T}$ac_header_compiler" >&6
9033 >
9034 > # Is the header present?
9035 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9036 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9037 > cat >conftest.$ac_ext <<_ACEOF
9038 > /* confdefs.h.  */
9039 > _ACEOF
9040 > cat confdefs.h >>conftest.$ac_ext
9041 > cat >>conftest.$ac_ext <<_ACEOF
9042 > /* end confdefs.h.  */
9043 > #include <$ac_header>
9044 > _ACEOF
9045 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9046 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9047 >  ac_status=$?
9048 >  grep -v '^ *+' conftest.er1 >conftest.err
9049 >  rm -f conftest.er1
9050 >  cat conftest.err >&5
9051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9052 >  (exit $ac_status); } >/dev/null; then
9053 >  if test -s conftest.err; then
9054 >    ac_cpp_err=$ac_c_preproc_warn_flag
9055 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9056 >  else
9057 >    ac_cpp_err=
9058 >  fi
9059 > else
9060 >  ac_cpp_err=yes
9061 > fi
9062 > if test -z "$ac_cpp_err"; then
9063 >  ac_header_preproc=yes
9064 > else
9065 >  echo "$as_me: failed program was:" >&5
9066 > sed 's/^/| /' conftest.$ac_ext >&5
9067 >
9068 >  ac_header_preproc=no
9069 > fi
9070 > rm -f conftest.err conftest.$ac_ext
9071 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9072 > echo "${ECHO_T}$ac_header_preproc" >&6
9073 >
9074 > # So?  What about this header?
9075 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9076 >  yes:no: )
9077 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9078 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9079 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9080 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9081 >    ac_header_preproc=yes
9082 >    ;;
9083 >  no:yes:* )
9084 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9085 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9086 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9087 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9088 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9089 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9090 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9091 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9092 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9093 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9094 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9095 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9096 >    (
9097 >      cat <<\_ASBOX
9098 > ## ------------------------------ ##
9099 > ## Report this to gezelter@nd.edu ##
9100 > ## ------------------------------ ##
9101 > _ASBOX
9102 >    ) |
9103 >      sed "s/^/$as_me: WARNING:     /" >&2
9104 >    ;;
9105 > esac
9106 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9107 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9108 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9109 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9110 > else
9111 >  eval "$as_ac_Header=\$ac_header_preproc"
9112 > fi
9113 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9114 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9115 >
9116 > fi
9117 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9118 >  cat >>confdefs.h <<_ACEOF
9119 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9120 > _ACEOF
9121 >
9122 > fi
9123 >
9124 > done
9125 >
9126 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
9127 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9128 > if test "${ac_cv_func_select_args+set}" = set; then
9129 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9130 > else
9131 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9132 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9133 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9134 >   cat >conftest.$ac_ext <<_ACEOF
9135 > /* confdefs.h.  */
9136 > _ACEOF
9137 > cat confdefs.h >>conftest.$ac_ext
9138 > cat >>conftest.$ac_ext <<_ACEOF
9139 > /* end confdefs.h.  */
9140 > $ac_includes_default
9141 > #if HAVE_SYS_SELECT_H
9142 > # include <sys/select.h>
9143 > #endif
9144 > #if HAVE_SYS_SOCKET_H
9145 > # include <sys/socket.h>
9146 > #endif
9147 >
9148 > #ifdef FC_DUMMY_MAIN
9149 > #ifndef FC_DUMMY_MAIN_EQ_F77
9150 > #  ifdef __cplusplus
9151 >     extern "C"
9152 > #  endif
9153 >   int FC_DUMMY_MAIN() { return 1; }
9154 > #endif
9155 > #endif
9156 > int
9157 > main ()
9158 > {
9159 > extern int select ($ac_arg1,
9160 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
9161 >                                            $ac_arg5);
9162 >  ;
9163 >  return 0;
9164 > }
9165 > _ACEOF
9166 > rm -f conftest.$ac_objext
9167 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9168 >  (eval $ac_compile) 2>conftest.er1
9169 >  ac_status=$?
9170 >  grep -v '^ *+' conftest.er1 >conftest.err
9171 >  rm -f conftest.er1
9172 >  cat conftest.err >&5
9173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174 >  (exit $ac_status); } &&
9175 >         { ac_try='test -z "$ac_c_werror_flag"
9176 >                         || test ! -s conftest.err'
9177 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9178 >  (eval $ac_try) 2>&5
9179 >  ac_status=$?
9180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181 >  (exit $ac_status); }; } &&
9182 >         { ac_try='test -s conftest.$ac_objext'
9183 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9184 >  (eval $ac_try) 2>&5
9185 >  ac_status=$?
9186 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9187 >  (exit $ac_status); }; }; then
9188 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9189 > else
9190 >  echo "$as_me: failed program was:" >&5
9191 > sed 's/^/| /' conftest.$ac_ext >&5
9192 >
9193 > fi
9194 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9195 >  done
9196 > done
9197 > done
9198 > # Provide a safe default value.
9199 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
9200 >
9201 > fi
9202 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9203 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
9204 > ac_save_IFS=$IFS; IFS=','
9205 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9206 > IFS=$ac_save_IFS
9207 > shift
9208 >
9209 > cat >>confdefs.h <<_ACEOF
9210 > #define SELECT_TYPE_ARG1 $1
9211 > _ACEOF
9212 >
9213 >
9214 > cat >>confdefs.h <<_ACEOF
9215 > #define SELECT_TYPE_ARG234 ($2)
9216 > _ACEOF
9217 >
9218 >
9219 > cat >>confdefs.h <<_ACEOF
9220 > #define SELECT_TYPE_ARG5 ($3)
9221 > _ACEOF
9222 >
9223 > rm -f conftest*
9224 >
9225 >
9226 > for ac_func in strftime
9227 > do
9228 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9229 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9230 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9231 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9232 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9233 > else
9234 >  cat >conftest.$ac_ext <<_ACEOF
9235 > /* confdefs.h.  */
9236 > _ACEOF
9237 > cat confdefs.h >>conftest.$ac_ext
9238 > cat >>conftest.$ac_ext <<_ACEOF
9239 > /* end confdefs.h.  */
9240 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9241 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9242 > #define $ac_func innocuous_$ac_func
9243 >
9244 > /* System header to define __stub macros and hopefully few prototypes,
9245 >    which can conflict with char $ac_func (); below.
9246 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9247 >    <limits.h> exists even on freestanding compilers.  */
9248 >
9249 > #ifdef __STDC__
9250 > # include <limits.h>
9251 > #else
9252 > # include <assert.h>
9253 > #endif
9254 >
9255 > #undef $ac_func
9256 >
9257 > /* Override any gcc2 internal prototype to avoid an error.  */
9258 > #ifdef __cplusplus
9259 > extern "C"
9260 > {
9261 > #endif
9262 > /* We use char because int might match the return type of a gcc2
9263 >   builtin and then its argument prototype would still apply.  */
9264 > char $ac_func ();
9265 > /* The GNU C library defines this for functions which it implements
9266 >    to always fail with ENOSYS.  Some functions are actually named
9267 >    something starting with __ and the normal name is an alias.  */
9268 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9269 > choke me
9270 > #else
9271 > char (*f) () = $ac_func;
9272 > #endif
9273 > #ifdef __cplusplus
9274 > }
9275 > #endif
9276 >
9277 > #ifdef FC_DUMMY_MAIN
9278 > #ifndef FC_DUMMY_MAIN_EQ_F77
9279 > #  ifdef __cplusplus
9280 >     extern "C"
9281 > #  endif
9282 >   int FC_DUMMY_MAIN() { return 1; }
9283 > #endif
9284 > #endif
9285 > int
9286 > main ()
9287 > {
9288 > return f != $ac_func;
9289 >  ;
9290 >  return 0;
9291 > }
9292 > _ACEOF
9293 > rm -f conftest.$ac_objext conftest$ac_exeext
9294 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9295 >  (eval $ac_link) 2>conftest.er1
9296 >  ac_status=$?
9297 >  grep -v '^ *+' conftest.er1 >conftest.err
9298 >  rm -f conftest.er1
9299 >  cat conftest.err >&5
9300 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301 >  (exit $ac_status); } &&
9302 >         { ac_try='test -z "$ac_c_werror_flag"
9303 >                         || test ! -s conftest.err'
9304 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305 >  (eval $ac_try) 2>&5
9306 >  ac_status=$?
9307 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308 >  (exit $ac_status); }; } &&
9309 >         { ac_try='test -s conftest$ac_exeext'
9310 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311 >  (eval $ac_try) 2>&5
9312 >  ac_status=$?
9313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314 >  (exit $ac_status); }; }; then
9315 >  eval "$as_ac_var=yes"
9316 > else
9317 >  echo "$as_me: failed program was:" >&5
9318 > sed 's/^/| /' conftest.$ac_ext >&5
9319 >
9320 > eval "$as_ac_var=no"
9321 > fi
9322 > rm -f conftest.err conftest.$ac_objext \
9323 >      conftest$ac_exeext conftest.$ac_ext
9324 > fi
9325 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9326 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9327 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9328 >  cat >>confdefs.h <<_ACEOF
9329 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9330 > _ACEOF
9331 >
9332 > else
9333 >  # strftime is in -lintl on SCO UNIX.
9334 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9335 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9336 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9337 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9338 > else
9339 >  ac_check_lib_save_LIBS=$LIBS
9340 > LIBS="-lintl  $LIBS"
9341 > cat >conftest.$ac_ext <<_ACEOF
9342 > /* confdefs.h.  */
9343 > _ACEOF
9344 > cat confdefs.h >>conftest.$ac_ext
9345 > cat >>conftest.$ac_ext <<_ACEOF
9346 > /* end confdefs.h.  */
9347 >
9348 > /* Override any gcc2 internal prototype to avoid an error.  */
9349 > #ifdef __cplusplus
9350 > extern "C"
9351 > #endif
9352 > /* We use char because int might match the return type of a gcc2
9353 >   builtin and then its argument prototype would still apply.  */
9354 > char strftime ();
9355 > #ifdef FC_DUMMY_MAIN
9356 > #ifndef FC_DUMMY_MAIN_EQ_F77
9357 > #  ifdef __cplusplus
9358 >     extern "C"
9359 > #  endif
9360 >   int FC_DUMMY_MAIN() { return 1; }
9361 > #endif
9362 > #endif
9363 > int
9364 > main ()
9365 > {
9366 > strftime ();
9367 >  ;
9368 >  return 0;
9369 > }
9370 > _ACEOF
9371 > rm -f conftest.$ac_objext conftest$ac_exeext
9372 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9373 >  (eval $ac_link) 2>conftest.er1
9374 >  ac_status=$?
9375 >  grep -v '^ *+' conftest.er1 >conftest.err
9376 >  rm -f conftest.er1
9377 >  cat conftest.err >&5
9378 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9379 >  (exit $ac_status); } &&
9380 >         { ac_try='test -z "$ac_c_werror_flag"
9381 >                         || test ! -s conftest.err'
9382 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9383 >  (eval $ac_try) 2>&5
9384 >  ac_status=$?
9385 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9386 >  (exit $ac_status); }; } &&
9387 >         { ac_try='test -s conftest$ac_exeext'
9388 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9389 >  (eval $ac_try) 2>&5
9390 >  ac_status=$?
9391 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392 >  (exit $ac_status); }; }; then
9393 >  ac_cv_lib_intl_strftime=yes
9394 > else
9395 >  echo "$as_me: failed program was:" >&5
9396 > sed 's/^/| /' conftest.$ac_ext >&5
9397 >
9398 > ac_cv_lib_intl_strftime=no
9399 > fi
9400 > rm -f conftest.err conftest.$ac_objext \
9401 >      conftest$ac_exeext conftest.$ac_ext
9402 > LIBS=$ac_check_lib_save_LIBS
9403 > fi
9404 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9405 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9406 > if test $ac_cv_lib_intl_strftime = yes; then
9407 >  cat >>confdefs.h <<\_ACEOF
9408 > #define HAVE_STRFTIME 1
9409 > _ACEOF
9410 >
9411 > LIBS="-lintl $LIBS"
9412 > fi
9413 >
9414 > fi
9415 > done
9416 >
9417 > echo "$as_me:$LINENO: checking for working strtod" >&5
9418 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9419 > if test "${ac_cv_func_strtod+set}" = set; then
9420 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9421 > else
9422 >  if test "$cross_compiling" = yes; then
9423 >  ac_cv_func_strtod=no
9424 > else
9425 >  cat >conftest.$ac_ext <<_ACEOF
9426 > /* confdefs.h.  */
9427 > _ACEOF
9428 > cat confdefs.h >>conftest.$ac_ext
9429 > cat >>conftest.$ac_ext <<_ACEOF
9430 > /* end confdefs.h.  */
9431 >
9432 > double strtod ();
9433 > int
9434 > main()
9435 > {
9436 >  {
9437 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9438 >    char *string = " +69";
9439 >    char *term;
9440 >    double value;
9441 >    value = strtod (string, &term);
9442 >    if (value != 69 || term != (string + 4))
9443 >      exit (1);
9444 >  }
9445 >
9446 >  {
9447 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9448 >       terminating character under some conditions.  */
9449 >    char *string = "NaN";
9450 >    char *term;
9451 >    strtod (string, &term);
9452 >    if (term != string && *(term - 1) == 0)
9453 >      exit (1);
9454 >  }
9455 >  exit (0);
9456 > }
9457 >
9458 > _ACEOF
9459 > rm -f conftest$ac_exeext
9460 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9461 >  (eval $ac_link) 2>&5
9462 >  ac_status=$?
9463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9465 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9466 >  (eval $ac_try) 2>&5
9467 >  ac_status=$?
9468 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469 >  (exit $ac_status); }; }; then
9470 >  ac_cv_func_strtod=yes
9471 > else
9472 >  echo "$as_me: program exited with status $ac_status" >&5
9473 > echo "$as_me: failed program was:" >&5
9474 > sed 's/^/| /' conftest.$ac_ext >&5
9475 >
9476 > ( exit $ac_status )
9477 > ac_cv_func_strtod=no
9478 > fi
9479 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9480 > fi
9481 > fi
9482 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9483 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9484 > if test $ac_cv_func_strtod = no; then
9485 >  case $LIBOBJS in
9486 >    "strtod.$ac_objext"   | \
9487 >  *" strtod.$ac_objext"   | \
9488 >    "strtod.$ac_objext "* | \
9489 >  *" strtod.$ac_objext "* ) ;;
9490 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9491   esac
9492  
9493 < ac_ext=c
9494 < ac_cpp='$CPP $CPPFLAGS'
9495 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4463 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4464 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4465 <
4466 <
4467 < ac_ext=cc
4468 < ac_cpp='$CXXCPP $CPPFLAGS'
4469 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4470 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4471 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4472 <
4473 <
4474 <
4475 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
4476 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
4477 < if test "${ac_cv_lib_m_asin+set}" = set; then
9493 > echo "$as_me:$LINENO: checking for pow" >&5
9494 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495 > if test "${ac_cv_func_pow+set}" = set; then
9496    echo $ECHO_N "(cached) $ECHO_C" >&6
9497   else
9498 <  ac_check_lib_save_LIBS=$LIBS
4481 < LIBS="-lm  $LIBS"
4482 < cat >conftest.$ac_ext <<_ACEOF
9498 >  cat >conftest.$ac_ext <<_ACEOF
9499   /* confdefs.h.  */
9500   _ACEOF
9501   cat confdefs.h >>conftest.$ac_ext
9502   cat >>conftest.$ac_ext <<_ACEOF
9503   /* end confdefs.h.  */
9504 + /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506 + #define pow innocuous_pow
9507  
9508 + /* System header to define __stub macros and hopefully few prototypes,
9509 +    which can conflict with char pow (); below.
9510 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511 +    <limits.h> exists even on freestanding compilers.  */
9512 +
9513 + #ifdef __STDC__
9514 + # include <limits.h>
9515 + #else
9516 + # include <assert.h>
9517 + #endif
9518 +
9519 + #undef pow
9520 +
9521   /* Override any gcc2 internal prototype to avoid an error.  */
9522   #ifdef __cplusplus
9523   extern "C"
9524 + {
9525   #endif
9526   /* We use char because int might match the return type of a gcc2
9527     builtin and then its argument prototype would still apply.  */
9528 < char asin ();
9528 > char pow ();
9529 > /* The GNU C library defines this for functions which it implements
9530 >    to always fail with ENOSYS.  Some functions are actually named
9531 >    something starting with __ and the normal name is an alias.  */
9532 > #if defined (__stub_pow) || defined (__stub___pow)
9533 > choke me
9534 > #else
9535 > char (*f) () = pow;
9536 > #endif
9537 > #ifdef __cplusplus
9538 > }
9539 > #endif
9540 >
9541 > #ifdef FC_DUMMY_MAIN
9542 > #ifndef FC_DUMMY_MAIN_EQ_F77
9543 > #  ifdef __cplusplus
9544 >     extern "C"
9545 > #  endif
9546 >   int FC_DUMMY_MAIN() { return 1; }
9547 > #endif
9548 > #endif
9549   int
9550   main ()
9551   {
9552 < asin ();
9552 > return f != pow;
9553    ;
9554    return 0;
9555   }
# Line 4510 | Line 9563 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9563    cat conftest.err >&5
9564    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565    (exit $ac_status); } &&
9566 <         { ac_try='test -z "$ac_cxx_werror_flag"
9566 >         { ac_try='test -z "$ac_c_werror_flag"
9567                           || test ! -s conftest.err'
9568    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569    (eval $ac_try) 2>&5
# Line 4523 | Line 9576 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9576    ac_status=$?
9577    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578    (exit $ac_status); }; }; then
9579 <  ac_cv_lib_m_asin=yes
9579 >  ac_cv_func_pow=yes
9580   else
9581    echo "$as_me: failed program was:" >&5
9582   sed 's/^/| /' conftest.$ac_ext >&5
9583  
9584 < ac_cv_lib_m_asin=no
9584 > ac_cv_func_pow=no
9585   fi
9586   rm -f conftest.err conftest.$ac_objext \
9587        conftest$ac_exeext conftest.$ac_ext
4535 – LIBS=$ac_check_lib_save_LIBS
9588   fi
9589 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
9590 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
4539 < if test $ac_cv_lib_m_asin = yes; then
4540 <  cat >>confdefs.h <<_ACEOF
4541 < #define HAVE_LIBM 1
4542 < _ACEOF
9589 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9591  
9592 <  LIBS="-lm $LIBS"
9593 <
9594 < else
9595 <  exit
4548 < fi
4549 <
4550 <
4551 < ac_ext=c
4552 < ac_cpp='$CPP $CPPFLAGS'
4553 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4554 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4555 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4556 <
4557 < ac_ext=c
4558 < ac_cpp='$CPP $CPPFLAGS'
4559 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4560 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4561 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4562 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4563 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4564 < # On Suns, sometimes $CPP names a directory.
4565 < if test -n "$CPP" && test -d "$CPP"; then
4566 <  CPP=
4567 < fi
4568 < if test -z "$CPP"; then
4569 <  if test "${ac_cv_prog_CPP+set}" = set; then
9592 > if test $ac_cv_func_pow = no; then
9593 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595 > if test "${ac_cv_lib_m_pow+set}" = set; then
9596    echo $ECHO_N "(cached) $ECHO_C" >&6
9597   else
9598 <      # Double quotes because CPP needs to be expanded
9599 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
9600 <    do
4575 <      ac_preproc_ok=false
4576 < for ac_c_preproc_warn_flag in '' yes
4577 < do
4578 <  # Use a header file that comes with gcc, so configuring glibc
4579 <  # with a fresh cross-compiler works.
4580 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4581 <  # <limits.h> exists even on freestanding compilers.
4582 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4583 <  # not just through cpp. "Syntax error" is here to catch this case.
4584 <  cat >conftest.$ac_ext <<_ACEOF
9598 >  ac_check_lib_save_LIBS=$LIBS
9599 > LIBS="-lm  $LIBS"
9600 > cat >conftest.$ac_ext <<_ACEOF
9601   /* confdefs.h.  */
9602   _ACEOF
9603   cat confdefs.h >>conftest.$ac_ext
9604   cat >>conftest.$ac_ext <<_ACEOF
9605   /* end confdefs.h.  */
4590 – #ifdef __STDC__
4591 – # include <limits.h>
4592 – #else
4593 – # include <assert.h>
4594 – #endif
4595 –                     Syntax error
4596 – _ACEOF
4597 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4598 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4599 –  ac_status=$?
4600 –  grep -v '^ *+' conftest.er1 >conftest.err
4601 –  rm -f conftest.er1
4602 –  cat conftest.err >&5
4603 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4604 –  (exit $ac_status); } >/dev/null; then
4605 –  if test -s conftest.err; then
4606 –    ac_cpp_err=$ac_c_preproc_warn_flag
4607 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4608 –  else
4609 –    ac_cpp_err=
4610 –  fi
4611 – else
4612 –  ac_cpp_err=yes
4613 – fi
4614 – if test -z "$ac_cpp_err"; then
4615 –  :
4616 – else
4617 –  echo "$as_me: failed program was:" >&5
4618 – sed 's/^/| /' conftest.$ac_ext >&5
9606  
9607 <  # Broken: fails on valid input.
9608 < continue
9609 < fi
4623 < rm -f conftest.err conftest.$ac_ext
4624 <
4625 <  # OK, works on sane cases.  Now check whether non-existent headers
4626 <  # can be detected and how.
4627 <  cat >conftest.$ac_ext <<_ACEOF
4628 < /* confdefs.h.  */
4629 < _ACEOF
4630 < cat confdefs.h >>conftest.$ac_ext
4631 < cat >>conftest.$ac_ext <<_ACEOF
4632 < /* end confdefs.h.  */
4633 < #include <ac_nonexistent.h>
4634 < _ACEOF
4635 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4636 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4637 <  ac_status=$?
4638 <  grep -v '^ *+' conftest.er1 >conftest.err
4639 <  rm -f conftest.er1
4640 <  cat conftest.err >&5
4641 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4642 <  (exit $ac_status); } >/dev/null; then
4643 <  if test -s conftest.err; then
4644 <    ac_cpp_err=$ac_c_preproc_warn_flag
4645 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4646 <  else
4647 <    ac_cpp_err=
4648 <  fi
4649 < else
4650 <  ac_cpp_err=yes
4651 < fi
4652 < if test -z "$ac_cpp_err"; then
4653 <  # Broken: success on invalid input.
4654 < continue
4655 < else
4656 <  echo "$as_me: failed program was:" >&5
4657 < sed 's/^/| /' conftest.$ac_ext >&5
4658 <
4659 <  # Passes both tests.
4660 < ac_preproc_ok=:
4661 < break
4662 < fi
4663 < rm -f conftest.err conftest.$ac_ext
4664 <
4665 < done
4666 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4667 < rm -f conftest.err conftest.$ac_ext
4668 < if $ac_preproc_ok; then
4669 <  break
4670 < fi
4671 <
4672 <    done
4673 <    ac_cv_prog_CPP=$CPP
4674 <
4675 < fi
4676 <  CPP=$ac_cv_prog_CPP
4677 < else
4678 <  ac_cv_prog_CPP=$CPP
4679 < fi
4680 < echo "$as_me:$LINENO: result: $CPP" >&5
4681 < echo "${ECHO_T}$CPP" >&6
4682 < ac_preproc_ok=false
4683 < for ac_c_preproc_warn_flag in '' yes
4684 < do
4685 <  # Use a header file that comes with gcc, so configuring glibc
4686 <  # with a fresh cross-compiler works.
4687 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4688 <  # <limits.h> exists even on freestanding compilers.
4689 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4690 <  # not just through cpp. "Syntax error" is here to catch this case.
4691 <  cat >conftest.$ac_ext <<_ACEOF
4692 < /* confdefs.h.  */
4693 < _ACEOF
4694 < cat confdefs.h >>conftest.$ac_ext
4695 < cat >>conftest.$ac_ext <<_ACEOF
4696 < /* end confdefs.h.  */
4697 < #ifdef __STDC__
4698 < # include <limits.h>
4699 < #else
4700 < # include <assert.h>
9607 > /* Override any gcc2 internal prototype to avoid an error.  */
9608 > #ifdef __cplusplus
9609 > extern "C"
9610   #endif
9611 <                     Syntax error
9612 < _ACEOF
9613 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9614 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9615 <  ac_status=$?
9616 <  grep -v '^ *+' conftest.er1 >conftest.err
9617 <  rm -f conftest.er1
9618 <  cat conftest.err >&5
9619 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9620 <  (exit $ac_status); } >/dev/null; then
9621 <  if test -s conftest.err; then
4713 <    ac_cpp_err=$ac_c_preproc_warn_flag
4714 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4715 <  else
4716 <    ac_cpp_err=
4717 <  fi
4718 < else
4719 <  ac_cpp_err=yes
4720 < fi
4721 < if test -z "$ac_cpp_err"; then
4722 <  :
4723 < else
4724 <  echo "$as_me: failed program was:" >&5
4725 < sed 's/^/| /' conftest.$ac_ext >&5
4726 <
4727 <  # Broken: fails on valid input.
4728 < continue
4729 < fi
4730 < rm -f conftest.err conftest.$ac_ext
4731 <
4732 <  # OK, works on sane cases.  Now check whether non-existent headers
4733 <  # can be detected and how.
4734 <  cat >conftest.$ac_ext <<_ACEOF
4735 < /* confdefs.h.  */
4736 < _ACEOF
4737 < cat confdefs.h >>conftest.$ac_ext
4738 < cat >>conftest.$ac_ext <<_ACEOF
4739 < /* end confdefs.h.  */
4740 < #include <ac_nonexistent.h>
4741 < _ACEOF
4742 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4743 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4744 <  ac_status=$?
4745 <  grep -v '^ *+' conftest.er1 >conftest.err
4746 <  rm -f conftest.er1
4747 <  cat conftest.err >&5
4748 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4749 <  (exit $ac_status); } >/dev/null; then
4750 <  if test -s conftest.err; then
4751 <    ac_cpp_err=$ac_c_preproc_warn_flag
4752 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4753 <  else
4754 <    ac_cpp_err=
4755 <  fi
4756 < else
4757 <  ac_cpp_err=yes
4758 < fi
4759 < if test -z "$ac_cpp_err"; then
4760 <  # Broken: success on invalid input.
4761 < continue
4762 < else
4763 <  echo "$as_me: failed program was:" >&5
4764 < sed 's/^/| /' conftest.$ac_ext >&5
4765 <
4766 <  # Passes both tests.
4767 < ac_preproc_ok=:
4768 < break
4769 < fi
4770 < rm -f conftest.err conftest.$ac_ext
4771 <
4772 < done
4773 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4774 < rm -f conftest.err conftest.$ac_ext
4775 < if $ac_preproc_ok; then
4776 <  :
4777 < else
4778 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4779 < See \`config.log' for more details." >&5
4780 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4781 < See \`config.log' for more details." >&2;}
4782 <   { (exit 1); exit 1; }; }
4783 < fi
4784 <
4785 < ac_ext=c
4786 < ac_cpp='$CPP $CPPFLAGS'
4787 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4788 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4789 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4790 <
4791 <
4792 < echo "$as_me:$LINENO: checking for egrep" >&5
4793 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4794 < if test "${ac_cv_prog_egrep+set}" = set; then
4795 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4796 < else
4797 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4798 <    then ac_cv_prog_egrep='grep -E'
4799 <    else ac_cv_prog_egrep='egrep'
4800 <    fi
4801 < fi
4802 < echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4803 < echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4804 < EGREP=$ac_cv_prog_egrep
4805 <
4806 <
4807 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
4808 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
4809 < if test "${ac_cv_header_stdc+set}" = set; then
4810 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4811 < else
4812 <  cat >conftest.$ac_ext <<_ACEOF
4813 < /* confdefs.h.  */
4814 < _ACEOF
4815 < cat confdefs.h >>conftest.$ac_ext
4816 < cat >>conftest.$ac_ext <<_ACEOF
4817 < /* end confdefs.h.  */
4818 < #include <stdlib.h>
4819 < #include <stdarg.h>
4820 < #include <string.h>
4821 < #include <float.h>
4822 <
9611 > /* We use char because int might match the return type of a gcc2
9612 >   builtin and then its argument prototype would still apply.  */
9613 > char pow ();
9614 > #ifdef FC_DUMMY_MAIN
9615 > #ifndef FC_DUMMY_MAIN_EQ_F77
9616 > #  ifdef __cplusplus
9617 >     extern "C"
9618 > #  endif
9619 >   int FC_DUMMY_MAIN() { return 1; }
9620 > #endif
9621 > #endif
9622   int
9623   main ()
9624   {
9625 <
9625 > pow ();
9626    ;
9627    return 0;
9628   }
9629   _ACEOF
9630 < rm -f conftest.$ac_objext
9631 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9632 <  (eval $ac_compile) 2>conftest.er1
9630 > rm -f conftest.$ac_objext conftest$ac_exeext
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632 >  (eval $ac_link) 2>conftest.er1
9633    ac_status=$?
9634    grep -v '^ *+' conftest.er1 >conftest.err
9635    rm -f conftest.er1
# Line 4844 | Line 9643 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9643    ac_status=$?
9644    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645    (exit $ac_status); }; } &&
9646 <         { ac_try='test -s conftest.$ac_objext'
9646 >         { ac_try='test -s conftest$ac_exeext'
9647    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648    (eval $ac_try) 2>&5
9649    ac_status=$?
9650    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651    (exit $ac_status); }; }; then
9652 <  ac_cv_header_stdc=yes
9652 >  ac_cv_lib_m_pow=yes
9653   else
9654    echo "$as_me: failed program was:" >&5
9655   sed 's/^/| /' conftest.$ac_ext >&5
9656  
9657 < ac_cv_header_stdc=no
9657 > ac_cv_lib_m_pow=no
9658   fi
9659 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9660 <
9661 < if test $ac_cv_header_stdc = yes; then
9662 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
9663 <  cat >conftest.$ac_ext <<_ACEOF
9664 < /* confdefs.h.  */
9665 < _ACEOF
9666 < cat confdefs.h >>conftest.$ac_ext
4868 < cat >>conftest.$ac_ext <<_ACEOF
4869 < /* end confdefs.h.  */
4870 < #include <string.h>
4871 <
4872 < _ACEOF
4873 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4874 <  $EGREP "memchr" >/dev/null 2>&1; then
4875 <  :
9659 > rm -f conftest.err conftest.$ac_objext \
9660 >      conftest$ac_exeext conftest.$ac_ext
9661 > LIBS=$ac_check_lib_save_LIBS
9662 > fi
9663 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665 > if test $ac_cv_lib_m_pow = yes; then
9666 >  POW_LIB=-lm
9667   else
9668 <  ac_cv_header_stdc=no
9668 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670   fi
4879 – rm -f conftest*
9671  
9672   fi
9673  
4883 – if test $ac_cv_header_stdc = yes; then
4884 –  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
4885 –  cat >conftest.$ac_ext <<_ACEOF
4886 – /* confdefs.h.  */
4887 – _ACEOF
4888 – cat confdefs.h >>conftest.$ac_ext
4889 – cat >>conftest.$ac_ext <<_ACEOF
4890 – /* end confdefs.h.  */
4891 – #include <stdlib.h>
4892 –
4893 – _ACEOF
4894 – if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4895 –  $EGREP "free" >/dev/null 2>&1; then
4896 –  :
4897 – else
4898 –  ac_cv_header_stdc=no
9674   fi
4900 – rm -f conftest*
9675  
4902 – fi
9676  
4904 – if test $ac_cv_header_stdc = yes; then
4905 –  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4906 –  if test "$cross_compiling" = yes; then
4907 –  :
4908 – else
4909 –  cat >conftest.$ac_ext <<_ACEOF
4910 – /* confdefs.h.  */
4911 – _ACEOF
4912 – cat confdefs.h >>conftest.$ac_ext
4913 – cat >>conftest.$ac_ext <<_ACEOF
4914 – /* end confdefs.h.  */
4915 – #include <ctype.h>
4916 – #if ((' ' & 0x0FF) == 0x020)
4917 – # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4918 – # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4919 – #else
4920 – # define ISLOWER(c) \
4921 –                   (('a' <= (c) && (c) <= 'i') \
4922 –                     || ('j' <= (c) && (c) <= 'r') \
4923 –                     || ('s' <= (c) && (c) <= 'z'))
4924 – # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4925 – #endif
9677  
4927 – #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4928 – int
4929 – main ()
4930 – {
4931 –  int i;
4932 –  for (i = 0; i < 256; i++)
4933 –    if (XOR (islower (i), ISLOWER (i))
4934 –        || toupper (i) != TOUPPER (i))
4935 –      exit(2);
4936 –  exit (0);
4937 – }
4938 – _ACEOF
4939 – rm -f conftest$ac_exeext
4940 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4941 –  (eval $ac_link) 2>&5
4942 –  ac_status=$?
4943 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4944 –  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4945 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4946 –  (eval $ac_try) 2>&5
4947 –  ac_status=$?
4948 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4949 –  (exit $ac_status); }; }; then
4950 –  :
4951 – else
4952 –  echo "$as_me: program exited with status $ac_status" >&5
4953 – echo "$as_me: failed program was:" >&5
4954 – sed 's/^/| /' conftest.$ac_ext >&5
9678  
4956 – ( exit $ac_status )
4957 – ac_cv_header_stdc=no
4958 – fi
4959 – rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4960 – fi
4961 – fi
4962 – fi
4963 – echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4964 – echo "${ECHO_T}$ac_cv_header_stdc" >&6
4965 – if test $ac_cv_header_stdc = yes; then
9679  
4967 – cat >>confdefs.h <<\_ACEOF
4968 – #define STDC_HEADERS 1
4969 – _ACEOF
9680  
4971 – fi
9681  
4973 – # On IRIX 5.3, sys/types and inttypes.h are conflicting.
9682  
9683  
9684  
# Line 4980 | Line 9688 | for ac_header in sys/types.h sys/stat.h stdlib.h strin
9688  
9689  
9690  
9691 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
9692 <                  inttypes.h stdint.h unistd.h
9691 >
9692 >
9693 >
9694 >
9695 >
9696 >
9697 >
9698 >
9699 >
9700 >
9701 >
9702 >
9703 > for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9704   do
9705 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9706 < echo "$as_me:$LINENO: checking for $ac_header" >&5
9707 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9708 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
9705 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9707 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9709    echo $ECHO_N "(cached) $ECHO_C" >&6
9710   else
9711    cat >conftest.$ac_ext <<_ACEOF
# Line 4995 | Line 9714 | $ac_includes_default
9714   cat confdefs.h >>conftest.$ac_ext
9715   cat >>conftest.$ac_ext <<_ACEOF
9716   /* end confdefs.h.  */
9717 < $ac_includes_default
9717 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719 > #define $ac_func innocuous_$ac_func
9720  
9721 < #include <$ac_header>
9721 > /* System header to define __stub macros and hopefully few prototypes,
9722 >    which can conflict with char $ac_func (); below.
9723 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724 >    <limits.h> exists even on freestanding compilers.  */
9725 >
9726 > #ifdef __STDC__
9727 > # include <limits.h>
9728 > #else
9729 > # include <assert.h>
9730 > #endif
9731 >
9732 > #undef $ac_func
9733 >
9734 > /* Override any gcc2 internal prototype to avoid an error.  */
9735 > #ifdef __cplusplus
9736 > extern "C"
9737 > {
9738 > #endif
9739 > /* We use char because int might match the return type of a gcc2
9740 >   builtin and then its argument prototype would still apply.  */
9741 > char $ac_func ();
9742 > /* The GNU C library defines this for functions which it implements
9743 >    to always fail with ENOSYS.  Some functions are actually named
9744 >    something starting with __ and the normal name is an alias.  */
9745 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746 > choke me
9747 > #else
9748 > char (*f) () = $ac_func;
9749 > #endif
9750 > #ifdef __cplusplus
9751 > }
9752 > #endif
9753 >
9754 > #ifdef FC_DUMMY_MAIN
9755 > #ifndef FC_DUMMY_MAIN_EQ_F77
9756 > #  ifdef __cplusplus
9757 >     extern "C"
9758 > #  endif
9759 >   int FC_DUMMY_MAIN() { return 1; }
9760 > #endif
9761 > #endif
9762 > int
9763 > main ()
9764 > {
9765 > return f != $ac_func;
9766 >  ;
9767 >  return 0;
9768 > }
9769   _ACEOF
9770 < rm -f conftest.$ac_objext
9771 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9772 <  (eval $ac_compile) 2>conftest.er1
9770 > rm -f conftest.$ac_objext conftest$ac_exeext
9771 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772 >  (eval $ac_link) 2>conftest.er1
9773    ac_status=$?
9774    grep -v '^ *+' conftest.er1 >conftest.err
9775    rm -f conftest.er1
# Line 5015 | Line 9783 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9783    ac_status=$?
9784    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785    (exit $ac_status); }; } &&
9786 <         { ac_try='test -s conftest.$ac_objext'
9786 >         { ac_try='test -s conftest$ac_exeext'
9787    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788    (eval $ac_try) 2>&5
9789    ac_status=$?
9790    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791    (exit $ac_status); }; }; then
9792 <  eval "$as_ac_Header=yes"
9792 >  eval "$as_ac_var=yes"
9793   else
9794    echo "$as_me: failed program was:" >&5
9795   sed 's/^/| /' conftest.$ac_ext >&5
9796  
9797 < eval "$as_ac_Header=no"
9797 > eval "$as_ac_var=no"
9798   fi
9799 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9799 > rm -f conftest.err conftest.$ac_objext \
9800 >      conftest$ac_exeext conftest.$ac_ext
9801   fi
9802 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9803 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9804 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
9802 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9805    cat >>confdefs.h <<_ACEOF
9806 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9806 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807   _ACEOF
9808  
9809   fi
5041 –
9810   done
5043 –
5044 –
5045 – #
5046 – # Handle user hints
5047 – #
5048 – echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5049 – echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5050 –
5051 – # Check whether --with-zlib or --without-zlib was given.
5052 – if test "${with_zlib+set}" = set; then
5053 –  withval="$with_zlib"
5054 –  if test "$withval" != no ; then
5055 –  echo "$as_me:$LINENO: result: yes" >&5
5056 – echo "${ECHO_T}yes" >&6
5057 –  if test -d "$withval"
5058 –  then
5059 –    ZLIB_HOME="$withval"
5060 –  else
5061 –    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5062 – echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5063 –  fi
5064 – else
5065 –  echo "$as_me:$LINENO: result: no" >&5
5066 – echo "${ECHO_T}no" >&6
5067 – fi
5068 – fi;
5069 –
5070 – ZLIB_HOME=/usr/local
5071 – if test ! -f "${ZLIB_HOME}/include/zlib.h"
5072 – then
5073 –        ZLIB_HOME=/usr
5074 – fi
9811  
5076 – #
5077 – # Locate zlib, if wanted
5078 – #
5079 – if test -n "${ZLIB_HOME}"
5080 – then
5081 –        ZLIB_OLD_LDFLAGS=$LDFLAGS
5082 –        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5083 –        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5084 –        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
9812  
9813 <
9814 <        ac_ext=c
9815 < ac_cpp='$CPP $CPPFLAGS'
9816 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5090 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5091 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5092 <
5093 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5094 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5095 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5096 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5097 < else
5098 <  ac_check_lib_save_LIBS=$LIBS
5099 < LIBS="-lz  $LIBS"
9813 > # special check for _system_configuration because AIX <4.3.2 do not
9814 > # contain the `physmem' member.
9815 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817   cat >conftest.$ac_ext <<_ACEOF
9818   /* confdefs.h.  */
9819   _ACEOF
9820   cat confdefs.h >>conftest.$ac_ext
9821   cat >>conftest.$ac_ext <<_ACEOF
9822   /* end confdefs.h.  */
9823 <
9824 < /* Override any gcc2 internal prototype to avoid an error.  */
9825 < #ifdef __cplusplus
9826 < extern "C"
9823 > #include <sys/systemcfg.h>
9824 > #ifdef FC_DUMMY_MAIN
9825 > #ifndef FC_DUMMY_MAIN_EQ_F77
9826 > #  ifdef __cplusplus
9827 >     extern "C"
9828 > #  endif
9829 >   int FC_DUMMY_MAIN() { return 1; }
9830   #endif
9831 < /* We use char because int might match the return type of a gcc2
5112 <   builtin and then its argument prototype would still apply.  */
5113 < char inflateEnd ();
9831 > #endif
9832   int
9833   main ()
9834   {
9835 < inflateEnd ();
9835 > double x = _system_configuration.physmem;
9836    ;
9837    return 0;
9838   }
9839   _ACEOF
9840 < rm -f conftest.$ac_objext conftest$ac_exeext
9841 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9842 <  (eval $ac_link) 2>conftest.er1
9840 > rm -f conftest.$ac_objext
9841 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842 >  (eval $ac_compile) 2>conftest.er1
9843    ac_status=$?
9844    grep -v '^ *+' conftest.er1 >conftest.err
9845    rm -f conftest.er1
# Line 5135 | Line 9853 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9853    ac_status=$?
9854    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855    (exit $ac_status); }; } &&
9856 <         { ac_try='test -s conftest$ac_exeext'
9856 >         { ac_try='test -s conftest.$ac_objext'
9857    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858    (eval $ac_try) 2>&5
9859    ac_status=$?
9860    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861    (exit $ac_status); }; }; then
9862 <  ac_cv_lib_z_inflateEnd=yes
9862 >  echo "$as_me:$LINENO: result: yes" >&5
9863 > echo "${ECHO_T}yes" >&6
9864 >
9865 > cat >>confdefs.h <<\_ACEOF
9866 > #define HAVE__SYSTEM_CONFIGURATION 1
9867 > _ACEOF
9868 >
9869   else
9870    echo "$as_me: failed program was:" >&5
9871   sed 's/^/| /' conftest.$ac_ext >&5
9872  
9873 < ac_cv_lib_z_inflateEnd=no
9873 > echo "$as_me:$LINENO: result: no" >&5
9874 > echo "${ECHO_T}no" >&6
9875   fi
9876 < rm -f conftest.err conftest.$ac_objext \
5152 <      conftest$ac_exeext conftest.$ac_ext
5153 < LIBS=$ac_check_lib_save_LIBS
5154 < fi
5155 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5156 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5157 < if test $ac_cv_lib_z_inflateEnd = yes; then
5158 <  zlib_cv_libz=yes
5159 < else
5160 <  zlib_cv_libz=no
5161 < fi
9876 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877  
9878 <        if test "${ac_cv_header_zlib_h+set}" = set; then
9879 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
9880 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
9881 < if test "${ac_cv_header_zlib_h+set}" = set; then
9878 >  # clean out junk possibly left behind by a previous configuration
9879 >  rm -f src/getopt.h
9880 >  # Check for getopt_long support
9881 >
9882 > for ac_header in getopt.h
9883 > do
9884 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9887 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889    echo $ECHO_N "(cached) $ECHO_C" >&6
9890   fi
9891 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
9892 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
9891 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893   else
9894    # Is the header compilable?
9895 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
9896 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
9895 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897   cat >conftest.$ac_ext <<_ACEOF
9898   /* confdefs.h.  */
9899   _ACEOF
# Line 5179 | Line 9901 | $ac_includes_default
9901   cat >>conftest.$ac_ext <<_ACEOF
9902   /* end confdefs.h.  */
9903   $ac_includes_default
9904 < #include <zlib.h>
9904 > #include <$ac_header>
9905   _ACEOF
9906   rm -f conftest.$ac_objext
9907   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5215 | Line 9937 | echo "$as_me:$LINENO: checking zlib.h presence" >&5
9937   echo "${ECHO_T}$ac_header_compiler" >&6
9938  
9939   # Is the header present?
9940 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
9941 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
9940 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942   cat >conftest.$ac_ext <<_ACEOF
9943   /* confdefs.h.  */
9944   _ACEOF
9945   cat confdefs.h >>conftest.$ac_ext
9946   cat >>conftest.$ac_ext <<_ACEOF
9947   /* end confdefs.h.  */
9948 < #include <zlib.h>
9948 > #include <$ac_header>
9949   _ACEOF
9950   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5257 | Line 9979 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
9979   # So?  What about this header?
9980   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981    yes:no: )
9982 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
9983 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
9985 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
9982 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986      ac_header_preproc=yes
9987      ;;
9988    no:yes:* )
9989 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
9990 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
9991 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
9992 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
9993 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
9994 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
9995 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
9996 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9997 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
9998 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
9999 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
10000 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
9989 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001      (
10002        cat <<\_ASBOX
10003   ## ------------------------------ ##
# Line 5286 | Line 10008 | echo "$as_me:$LINENO: checking for zlib.h" >&5
10008        sed "s/^/$as_me: WARNING:     /" >&2
10009      ;;
10010   esac
10011 < echo "$as_me:$LINENO: checking for zlib.h" >&5
10012 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10013 < if test "${ac_cv_header_zlib_h+set}" = set; then
10011 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10012 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014    echo $ECHO_N "(cached) $ECHO_C" >&6
10015   else
10016 <  ac_cv_header_zlib_h=$ac_header_preproc
10016 >  eval "$as_ac_Header=\$ac_header_preproc"
10017   fi
10018 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10019 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10018 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020  
10021   fi
10022 < if test $ac_cv_header_zlib_h = yes; then
10023 <  zlib_cv_zlib_h=yes
10024 < else
10025 <  zlib_cv_zlib_h=no
10022 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023 >  cat >>confdefs.h <<_ACEOF
10024 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025 > _ACEOF
10026 >
10027   fi
10028  
10029 + done
10030  
5307 –        ac_ext=c
5308 – ac_cpp='$CPP $CPPFLAGS'
5309 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5310 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5311 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
10031  
10032 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
10033 <        then
10034 <                #
10035 <                # If both library and header were found, use them
10036 <                #
10037 <
5319 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5320 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5321 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
10032 > for ac_func in getopt_long
10033 > do
10034 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10036 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10038    echo $ECHO_N "(cached) $ECHO_C" >&6
10039   else
10040 <  ac_check_lib_save_LIBS=$LIBS
5325 < LIBS="-lz  $LIBS"
5326 < cat >conftest.$ac_ext <<_ACEOF
10040 >  cat >conftest.$ac_ext <<_ACEOF
10041   /* confdefs.h.  */
10042   _ACEOF
10043   cat confdefs.h >>conftest.$ac_ext
10044   cat >>conftest.$ac_ext <<_ACEOF
10045   /* end confdefs.h.  */
10046 + /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048 + #define $ac_func innocuous_$ac_func
10049  
10050 + /* System header to define __stub macros and hopefully few prototypes,
10051 +    which can conflict with char $ac_func (); below.
10052 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053 +    <limits.h> exists even on freestanding compilers.  */
10054 +
10055 + #ifdef __STDC__
10056 + # include <limits.h>
10057 + #else
10058 + # include <assert.h>
10059 + #endif
10060 +
10061 + #undef $ac_func
10062 +
10063   /* Override any gcc2 internal prototype to avoid an error.  */
10064   #ifdef __cplusplus
10065   extern "C"
10066 + {
10067   #endif
10068   /* We use char because int might match the return type of a gcc2
10069     builtin and then its argument prototype would still apply.  */
10070 < char inflateEnd ();
10070 > char $ac_func ();
10071 > /* The GNU C library defines this for functions which it implements
10072 >    to always fail with ENOSYS.  Some functions are actually named
10073 >    something starting with __ and the normal name is an alias.  */
10074 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075 > choke me
10076 > #else
10077 > char (*f) () = $ac_func;
10078 > #endif
10079 > #ifdef __cplusplus
10080 > }
10081 > #endif
10082 >
10083 > #ifdef FC_DUMMY_MAIN
10084 > #ifndef FC_DUMMY_MAIN_EQ_F77
10085 > #  ifdef __cplusplus
10086 >     extern "C"
10087 > #  endif
10088 >   int FC_DUMMY_MAIN() { return 1; }
10089 > #endif
10090 > #endif
10091   int
10092   main ()
10093   {
10094 < inflateEnd ();
10094 > return f != $ac_func;
10095    ;
10096    return 0;
10097   }
# Line 5367 | Line 10118 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10118    ac_status=$?
10119    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120    (exit $ac_status); }; }; then
10121 <  ac_cv_lib_z_inflateEnd=yes
10121 >  eval "$as_ac_var=yes"
10122   else
10123    echo "$as_me: failed program was:" >&5
10124   sed 's/^/| /' conftest.$ac_ext >&5
10125  
10126 < ac_cv_lib_z_inflateEnd=no
10126 > eval "$as_ac_var=no"
10127   fi
10128   rm -f conftest.err conftest.$ac_objext \
10129        conftest$ac_exeext conftest.$ac_ext
5379 – LIBS=$ac_check_lib_save_LIBS
10130   fi
10131 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
10132 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
10133 < if test $ac_cv_lib_z_inflateEnd = yes; then
10131 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10132 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10133 > if test `eval echo '${'$as_ac_var'}'` = yes; then
10134    cat >>confdefs.h <<_ACEOF
10135 < #define HAVE_LIBZ 1
10135 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10136   _ACEOF
10137  
10138 <  LIBS="-lz $LIBS"
10139 <
10140 < fi
10141 <
10142 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5393 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5394 <                echo "$as_me:$LINENO: result: ok" >&5
5395 < echo "${ECHO_T}ok" >&6
5396 <        else
5397 <                #
5398 <                # If either header or library was not found, revert and bomb
5399 <                #
5400 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5401 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5402 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5403 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5404 <                echo "$as_me:$LINENO: result: failed" >&5
5405 < echo "${ECHO_T}failed" >&6
5406 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5407 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5408 <   { (exit 1); exit 1; }; }
5409 <        fi
5410 < fi
5411 <
5412 <
5413 <
5414 <
5415 <
5416 <
5417 <
5418 <
5419 < for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
5420 < do
5421 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5422 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5423 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5424 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5425 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10138 > else
10139 >  # FreeBSD has a gnugetopt library for this
10140 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10141 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10142 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10143    echo $ECHO_N "(cached) $ECHO_C" >&6
5427 – fi
5428 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5429 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10144   else
10145 <  # Is the header compilable?
10146 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5433 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10145 >  ac_check_lib_save_LIBS=$LIBS
10146 > LIBS="-lgnugetopt  $LIBS"
10147   cat >conftest.$ac_ext <<_ACEOF
10148   /* confdefs.h.  */
10149   _ACEOF
10150   cat confdefs.h >>conftest.$ac_ext
10151   cat >>conftest.$ac_ext <<_ACEOF
10152   /* end confdefs.h.  */
10153 < $ac_includes_default
10154 < #include <$ac_header>
10153 >
10154 > /* Override any gcc2 internal prototype to avoid an error.  */
10155 > #ifdef __cplusplus
10156 > extern "C"
10157 > #endif
10158 > /* We use char because int might match the return type of a gcc2
10159 >   builtin and then its argument prototype would still apply.  */
10160 > char getopt_long ();
10161 > #ifdef FC_DUMMY_MAIN
10162 > #ifndef FC_DUMMY_MAIN_EQ_F77
10163 > #  ifdef __cplusplus
10164 >     extern "C"
10165 > #  endif
10166 >   int FC_DUMMY_MAIN() { return 1; }
10167 > #endif
10168 > #endif
10169 > int
10170 > main ()
10171 > {
10172 > getopt_long ();
10173 >  ;
10174 >  return 0;
10175 > }
10176   _ACEOF
10177 < rm -f conftest.$ac_objext
10178 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10179 <  (eval $ac_compile) 2>conftest.er1
10177 > rm -f conftest.$ac_objext conftest$ac_exeext
10178 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10179 >  (eval $ac_link) 2>conftest.er1
10180    ac_status=$?
10181    grep -v '^ *+' conftest.er1 >conftest.err
10182    rm -f conftest.er1
# Line 5456 | Line 10190 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10190    ac_status=$?
10191    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192    (exit $ac_status); }; } &&
10193 <         { ac_try='test -s conftest.$ac_objext'
10193 >         { ac_try='test -s conftest$ac_exeext'
10194    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10195 <  (eval $ac_try) 2>&5
5462 <  ac_status=$?
5463 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5464 <  (exit $ac_status); }; }; then
5465 <  ac_header_compiler=yes
5466 < else
5467 <  echo "$as_me: failed program was:" >&5
5468 < sed 's/^/| /' conftest.$ac_ext >&5
5469 <
5470 < ac_header_compiler=no
5471 < fi
5472 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5473 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5474 < echo "${ECHO_T}$ac_header_compiler" >&6
5475 <
5476 < # Is the header present?
5477 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
5478 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 < #include <$ac_header>
5486 < _ACEOF
5487 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5488 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10195 >  (eval $ac_try) 2>&5
10196    ac_status=$?
5490 –  grep -v '^ *+' conftest.er1 >conftest.err
5491 –  rm -f conftest.er1
5492 –  cat conftest.err >&5
10197    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198 <  (exit $ac_status); } >/dev/null; then
10199 <  if test -s conftest.err; then
5496 <    ac_cpp_err=$ac_c_preproc_warn_flag
5497 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5498 <  else
5499 <    ac_cpp_err=
5500 <  fi
10198 >  (exit $ac_status); }; }; then
10199 >  ac_cv_lib_gnugetopt_getopt_long=yes
10200   else
5502 –  ac_cpp_err=yes
5503 – fi
5504 – if test -z "$ac_cpp_err"; then
5505 –  ac_header_preproc=yes
5506 – else
10201    echo "$as_me: failed program was:" >&5
10202   sed 's/^/| /' conftest.$ac_ext >&5
10203  
10204 <  ac_header_preproc=no
10204 > ac_cv_lib_gnugetopt_getopt_long=no
10205   fi
10206 < rm -f conftest.err conftest.$ac_ext
10207 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10208 < echo "${ECHO_T}$ac_header_preproc" >&6
10206 > rm -f conftest.err conftest.$ac_objext \
10207 >      conftest$ac_exeext conftest.$ac_ext
10208 > LIBS=$ac_check_lib_save_LIBS
10209 > fi
10210 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10211 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10212 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10213 >  cat >>confdefs.h <<\_ACEOF
10214 > #define HAVE_GETOPT_LONG 1
10215 > _ACEOF
10216  
5516 – # So?  What about this header?
5517 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5518 –  yes:no: )
5519 –    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5520 – echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5521 –    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5522 – echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5523 –    ac_header_preproc=yes
5524 –    ;;
5525 –  no:yes:* )
5526 –    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5527 – echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5528 –    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5529 – echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5530 –    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5531 – echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5532 –    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5533 – echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5534 –    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5535 – echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5536 –    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5537 – echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5538 –    (
5539 –      cat <<\_ASBOX
5540 – ## ------------------------------ ##
5541 – ## Report this to gezelter@nd.edu ##
5542 – ## ------------------------------ ##
5543 – _ASBOX
5544 –    ) |
5545 –      sed "s/^/$as_me: WARNING:     /" >&2
5546 –    ;;
5547 – esac
5548 – echo "$as_me:$LINENO: checking for $ac_header" >&5
5549 – echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5550 – if eval "test \"\${$as_ac_Header+set}\" = set"; then
5551 –  echo $ECHO_N "(cached) $ECHO_C" >&6
10217   else
10218 <  eval "$as_ac_Header=\$ac_header_preproc"
10219 < fi
10220 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10221 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10218 >  # use the GNU replacement
10219 >      case $LIBOBJS in
10220 >    "getopt.$ac_objext"   | \
10221 >  *" getopt.$ac_objext"   | \
10222 >    "getopt.$ac_objext "* | \
10223 >  *" getopt.$ac_objext "* ) ;;
10224 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10225 > esac
10226  
10227 < fi
10228 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10229 <  cat >>confdefs.h <<_ACEOF
10230 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10231 < _ACEOF
10227 >      case $LIBOBJS in
10228 >    "getopt1.$ac_objext"   | \
10229 >  *" getopt1.$ac_objext"   | \
10230 >    "getopt1.$ac_objext "* | \
10231 >  *" getopt1.$ac_objext "* ) ;;
10232 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10233 > esac
10234  
10235 +                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10236 +
10237   fi
10238  
10239 + fi
10240   done
10241  
10242  
10243 + ac_ext=cc
10244 + ac_cpp='$CXXCPP $CPPFLAGS'
10245 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10246 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10247 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10248  
10249  
10250 <
10251 <
10252 < for ac_header in strstream.h iostream.h fstream.h math.h time.h
5574 < do
5575 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5576 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5577 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5578 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5579 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10250 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10251 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10252 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10253    echo $ECHO_N "(cached) $ECHO_C" >&6
5581 – fi
5582 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5583 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10254   else
10255 <  # Is the header compilable?
10256 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
10257 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10258 < cat >conftest.$ac_ext <<_ACEOF
10255 >
10256 >
10257 > ac_ext=cc
10258 > ac_cpp='$CXXCPP $CPPFLAGS'
10259 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262 >
10263 > cat >conftest.$ac_ext <<_ACEOF
10264   /* confdefs.h.  */
10265   _ACEOF
10266   cat confdefs.h >>conftest.$ac_ext
10267   cat >>conftest.$ac_ext <<_ACEOF
10268   /* end confdefs.h.  */
10269 < $ac_includes_default
10270 < #include <$ac_header>
10269 > namespace Outer { namespace Inner { int i = 0; }}
10270 > #ifdef FC_DUMMY_MAIN
10271 > #ifndef FC_DUMMY_MAIN_EQ_F77
10272 > #  ifdef __cplusplus
10273 >     extern "C"
10274 > #  endif
10275 >   int FC_DUMMY_MAIN() { return 1; }
10276 > #endif
10277 > #endif
10278 > int
10279 > main ()
10280 > {
10281 > using namespace Outer::Inner; return i;
10282 >  ;
10283 >  return 0;
10284 > }
10285   _ACEOF
10286   rm -f conftest.$ac_objext
10287   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5603 | Line 10292 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10292    cat conftest.err >&5
10293    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10294    (exit $ac_status); } &&
10295 <         { ac_try='test -z "$ac_c_werror_flag"
10295 >         { ac_try='test -z "$ac_cxx_werror_flag"
10296                           || test ! -s conftest.err'
10297    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10298    (eval $ac_try) 2>&5
# Line 5616 | Line 10305 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10305    ac_status=$?
10306    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307    (exit $ac_status); }; }; then
10308 <  ac_header_compiler=yes
10308 >  ac_cv_cxx_namespaces=yes
10309   else
10310    echo "$as_me: failed program was:" >&5
10311   sed 's/^/| /' conftest.$ac_ext >&5
10312  
10313 < ac_header_compiler=no
10313 > ac_cv_cxx_namespaces=no
10314   fi
10315   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10317 < echo "${ECHO_T}$ac_header_compiler" >&6
10316 > ac_ext=cc
10317 > ac_cpp='$CXXCPP $CPPFLAGS'
10318 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10319 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10320 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10321  
5630 – # Is the header present?
5631 – echo "$as_me:$LINENO: checking $ac_header presence" >&5
5632 – echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5633 – cat >conftest.$ac_ext <<_ACEOF
5634 – /* confdefs.h.  */
5635 – _ACEOF
5636 – cat confdefs.h >>conftest.$ac_ext
5637 – cat >>conftest.$ac_ext <<_ACEOF
5638 – /* end confdefs.h.  */
5639 – #include <$ac_header>
5640 – _ACEOF
5641 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5642 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5643 –  ac_status=$?
5644 –  grep -v '^ *+' conftest.er1 >conftest.err
5645 –  rm -f conftest.er1
5646 –  cat conftest.err >&5
5647 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5648 –  (exit $ac_status); } >/dev/null; then
5649 –  if test -s conftest.err; then
5650 –    ac_cpp_err=$ac_c_preproc_warn_flag
5651 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5652 –  else
5653 –    ac_cpp_err=
5654 –  fi
5655 – else
5656 –  ac_cpp_err=yes
5657 – fi
5658 – if test -z "$ac_cpp_err"; then
5659 –  ac_header_preproc=yes
5660 – else
5661 –  echo "$as_me: failed program was:" >&5
5662 – sed 's/^/| /' conftest.$ac_ext >&5
10322  
5664 –  ac_header_preproc=no
10323   fi
10324 < rm -f conftest.err conftest.$ac_ext
10325 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10326 < echo "${ECHO_T}$ac_header_preproc" >&6
10324 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326 > if test "$ac_cv_cxx_namespaces" = yes; then
10327  
10328 < # So?  What about this header?
10329 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5672 <  yes:no: )
5673 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5674 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5675 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5676 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5677 <    ac_header_preproc=yes
5678 <    ;;
5679 <  no:yes:* )
5680 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5681 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5682 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5683 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5684 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5685 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5686 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5687 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5688 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5689 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5690 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5691 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5692 <    (
5693 <      cat <<\_ASBOX
5694 < ## ------------------------------ ##
5695 < ## Report this to gezelter@nd.edu ##
5696 < ## ------------------------------ ##
5697 < _ASBOX
5698 <    ) |
5699 <      sed "s/^/$as_me: WARNING:     /" >&2
5700 <    ;;
5701 < esac
5702 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5703 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5704 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5705 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5706 < else
5707 <  eval "$as_ac_Header=\$ac_header_preproc"
5708 < fi
5709 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5710 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5711 <
5712 < fi
5713 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5714 <  cat >>confdefs.h <<_ACEOF
5715 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10328 > cat >>confdefs.h <<\_ACEOF
10329 > #define HAVE_NAMESPACES
10330   _ACEOF
10331  
10332   fi
10333  
5720 – done
5721 –
10334   ac_ext=cc
10335   ac_cpp='$CXXCPP $CPPFLAGS'
10336   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5727 –
5728 – ac_ext=cc
5729 – ac_cpp='$CXXCPP $CPPFLAGS'
5730 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5731 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5732 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339   echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340   echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341   if test -z "$CXXCPP"; then
# Line 5950 | Line 10556 | ac_cpp='$CXXCPP $CPPFLAGS'
10556   fi
10557  
10558   ac_ext=cc
10559 + ac_cpp='$CXXCPP $CPPFLAGS'
10560 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10561 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10562 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10563 +
10564 +
10565 + echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10566 + echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10567 + if test "${ac_cv_cxx_have_stl+set}" = set; then
10568 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10569 + else
10570 +
10571 +
10572 +
10573 + ac_ext=cc
10574 + ac_cpp='$CXXCPP $CPPFLAGS'
10575 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10576 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10577 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10578 +
10579 + cat >conftest.$ac_ext <<_ACEOF
10580 + /* confdefs.h.  */
10581 + _ACEOF
10582 + cat confdefs.h >>conftest.$ac_ext
10583 + cat >>conftest.$ac_ext <<_ACEOF
10584 + /* end confdefs.h.  */
10585 + #include <list>
10586 + #include <deque>
10587 + #ifdef HAVE_NAMESPACES
10588 + using namespace std;
10589 + #endif
10590 + #ifdef FC_DUMMY_MAIN
10591 + #ifndef FC_DUMMY_MAIN_EQ_F77
10592 + #  ifdef __cplusplus
10593 +     extern "C"
10594 + #  endif
10595 +   int FC_DUMMY_MAIN() { return 1; }
10596 + #endif
10597 + #endif
10598 + int
10599 + main ()
10600 + {
10601 + list<int> x; x.push_back(5);
10602 + list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10603 +  ;
10604 +  return 0;
10605 + }
10606 + _ACEOF
10607 + rm -f conftest.$ac_objext
10608 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10609 +  (eval $ac_compile) 2>conftest.er1
10610 +  ac_status=$?
10611 +  grep -v '^ *+' conftest.er1 >conftest.err
10612 +  rm -f conftest.er1
10613 +  cat conftest.err >&5
10614 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10615 +  (exit $ac_status); } &&
10616 +         { ac_try='test -z "$ac_cxx_werror_flag"
10617 +                         || test ! -s conftest.err'
10618 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10619 +  (eval $ac_try) 2>&5
10620 +  ac_status=$?
10621 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10622 +  (exit $ac_status); }; } &&
10623 +         { ac_try='test -s conftest.$ac_objext'
10624 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10625 +  (eval $ac_try) 2>&5
10626 +  ac_status=$?
10627 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628 +  (exit $ac_status); }; }; then
10629 +  ac_cv_cxx_have_stl=yes
10630 + else
10631 +  echo "$as_me: failed program was:" >&5
10632 + sed 's/^/| /' conftest.$ac_ext >&5
10633 +
10634 + ac_cv_cxx_have_stl=no
10635 + fi
10636 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10637 + ac_ext=cc
10638   ac_cpp='$CXXCPP $CPPFLAGS'
10639   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10640   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10641   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10642  
10643  
10644 + fi
10645 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10646 + echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10647 + if test "$ac_cv_cxx_have_stl" = yes; then
10648  
10649 + cat >>confdefs.h <<\_ACEOF
10650 + #define HAVE_STL
10651 + _ACEOF
10652  
10653 + fi
10654  
10655  
10656  
10657 < for ac_header in ctype.h iostream fstream sstream strstream
10658 < do
10659 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10660 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5968 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5969 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5970 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10657 >  if test "${ac_cv_header_iostream+set}" = set; then
10658 >  echo "$as_me:$LINENO: checking for iostream" >&5
10659 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660 > if test "${ac_cv_header_iostream+set}" = set; then
10661    echo $ECHO_N "(cached) $ECHO_C" >&6
10662   fi
10663 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10664 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10663 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665   else
10666    # Is the header compilable?
10667 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
10668 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10667 > echo "$as_me:$LINENO: checking iostream usability" >&5
10668 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669   cat >conftest.$ac_ext <<_ACEOF
10670   /* confdefs.h.  */
10671   _ACEOF
# Line 5983 | Line 10673 | $ac_includes_default
10673   cat >>conftest.$ac_ext <<_ACEOF
10674   /* end confdefs.h.  */
10675   $ac_includes_default
10676 < #include <$ac_header>
10676 > #include <iostream>
10677   _ACEOF
10678   rm -f conftest.$ac_objext
10679   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6019 | Line 10709 | echo "$as_me:$LINENO: checking $ac_header presence" >&
10709   echo "${ECHO_T}$ac_header_compiler" >&6
10710  
10711   # Is the header present?
10712 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
10713 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10712 > echo "$as_me:$LINENO: checking iostream presence" >&5
10713 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714   cat >conftest.$ac_ext <<_ACEOF
10715   /* confdefs.h.  */
10716   _ACEOF
10717   cat confdefs.h >>conftest.$ac_ext
10718   cat >>conftest.$ac_ext <<_ACEOF
10719   /* end confdefs.h.  */
10720 < #include <$ac_header>
10720 > #include <iostream>
10721   _ACEOF
10722   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10723    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6061 | Line 10751 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
10751   # So?  What about this header?
10752   case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753    yes:no: )
10754 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10755 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10757 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10754 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758      ac_header_preproc=yes
10759      ;;
10760    no:yes:* )
10761 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10762 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10763 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10764 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10765 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10766 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10767 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10768 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10769 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10770 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10771 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10772 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10761 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773      (
10774        cat <<\_ASBOX
10775   ## ------------------------------ ##
# Line 6090 | Line 10780 | echo "$as_me:$LINENO: checking for $ac_header" >&5
10780        sed "s/^/$as_me: WARNING:     /" >&2
10781      ;;
10782   esac
10783 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10784 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10785 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10783 > echo "$as_me:$LINENO: checking for iostream" >&5
10784 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785 > if test "${ac_cv_header_iostream+set}" = set; then
10786    echo $ECHO_N "(cached) $ECHO_C" >&6
10787   else
10788 <  eval "$as_ac_Header=\$ac_header_preproc"
10788 >  ac_cv_header_iostream=$ac_header_preproc
10789   fi
10790 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10791 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10790 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792  
10793   fi
10794 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6105 <  cat >>confdefs.h <<_ACEOF
6106 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6107 < _ACEOF
10794 > if test $ac_cv_header_iostream = yes; then
10795  
6109 – fi
10796  
10797 < done
10797 > cat >>confdefs.h <<\_ACEOF
10798 > #define HAVE_IOSTREAM 1
10799 > _ACEOF
10800  
6113 – ac_ext=c
6114 – ac_cpp='$CPP $CPPFLAGS'
6115 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6116 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6117 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
10801  
10802 + else
10803  
10804  
10805 <
6122 < for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
10805 > for ac_header in iostream.h
10806   do
10807   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6152 | Line 10835 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10835    cat conftest.err >&5
10836    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837    (exit $ac_status); } &&
10838 <         { ac_try='test -z "$ac_c_werror_flag"
10838 >         { ac_try='test -z "$ac_cxx_werror_flag"
10839                           || test ! -s conftest.err'
10840    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10841    (eval $ac_try) 2>&5
# Line 6196 | Line 10879 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10879    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880    (exit $ac_status); } >/dev/null; then
10881    if test -s conftest.err; then
10882 <    ac_cpp_err=$ac_c_preproc_warn_flag
10883 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10882 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10883 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10884    else
10885      ac_cpp_err=
10886    fi
# Line 6217 | Line 10900 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
10900   echo "${ECHO_T}$ac_header_preproc" >&6
10901  
10902   # So?  What about this header?
10903 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10903 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904    yes:no: )
10905      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6269 | Line 10952 | done
10952   done
10953  
10954  
10955 + fi
10956  
10957  
10958  
10959 < for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
10959 >
10960 >  if test "${ac_cv_header_iomanip+set}" = set; then
10961 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10962 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963 > if test "${ac_cv_header_iomanip+set}" = set; then
10964 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10965 > fi
10966 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968 > else
10969 >  # Is the header compilable?
10970 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10971 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10972 > cat >conftest.$ac_ext <<_ACEOF
10973 > /* confdefs.h.  */
10974 > _ACEOF
10975 > cat confdefs.h >>conftest.$ac_ext
10976 > cat >>conftest.$ac_ext <<_ACEOF
10977 > /* end confdefs.h.  */
10978 > $ac_includes_default
10979 > #include <iomanip>
10980 > _ACEOF
10981 > rm -f conftest.$ac_objext
10982 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10983 >  (eval $ac_compile) 2>conftest.er1
10984 >  ac_status=$?
10985 >  grep -v '^ *+' conftest.er1 >conftest.err
10986 >  rm -f conftest.er1
10987 >  cat conftest.err >&5
10988 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989 >  (exit $ac_status); } &&
10990 >         { ac_try='test -z "$ac_cxx_werror_flag"
10991 >                         || test ! -s conftest.err'
10992 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10993 >  (eval $ac_try) 2>&5
10994 >  ac_status=$?
10995 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10996 >  (exit $ac_status); }; } &&
10997 >         { ac_try='test -s conftest.$ac_objext'
10998 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10999 >  (eval $ac_try) 2>&5
11000 >  ac_status=$?
11001 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002 >  (exit $ac_status); }; }; then
11003 >  ac_header_compiler=yes
11004 > else
11005 >  echo "$as_me: failed program was:" >&5
11006 > sed 's/^/| /' conftest.$ac_ext >&5
11007 >
11008 > ac_header_compiler=no
11009 > fi
11010 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11011 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11012 > echo "${ECHO_T}$ac_header_compiler" >&6
11013 >
11014 > # Is the header present?
11015 > echo "$as_me:$LINENO: checking iomanip presence" >&5
11016 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017 > cat >conftest.$ac_ext <<_ACEOF
11018 > /* confdefs.h.  */
11019 > _ACEOF
11020 > cat confdefs.h >>conftest.$ac_ext
11021 > cat >>conftest.$ac_ext <<_ACEOF
11022 > /* end confdefs.h.  */
11023 > #include <iomanip>
11024 > _ACEOF
11025 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11026 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11027 >  ac_status=$?
11028 >  grep -v '^ *+' conftest.er1 >conftest.err
11029 >  rm -f conftest.er1
11030 >  cat conftest.err >&5
11031 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032 >  (exit $ac_status); } >/dev/null; then
11033 >  if test -s conftest.err; then
11034 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11035 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11036 >  else
11037 >    ac_cpp_err=
11038 >  fi
11039 > else
11040 >  ac_cpp_err=yes
11041 > fi
11042 > if test -z "$ac_cpp_err"; then
11043 >  ac_header_preproc=yes
11044 > else
11045 >  echo "$as_me: failed program was:" >&5
11046 > sed 's/^/| /' conftest.$ac_ext >&5
11047 >
11048 >  ac_header_preproc=no
11049 > fi
11050 > rm -f conftest.err conftest.$ac_ext
11051 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11052 > echo "${ECHO_T}$ac_header_preproc" >&6
11053 >
11054 > # So?  What about this header?
11055 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11056 >  yes:no: )
11057 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11058 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11060 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11061 >    ac_header_preproc=yes
11062 >    ;;
11063 >  no:yes:* )
11064 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11065 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11066 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11067 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11068 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11069 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11070 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11071 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11072 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11073 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11074 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11075 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11076 >    (
11077 >      cat <<\_ASBOX
11078 > ## ------------------------------ ##
11079 > ## Report this to gezelter@nd.edu ##
11080 > ## ------------------------------ ##
11081 > _ASBOX
11082 >    ) |
11083 >      sed "s/^/$as_me: WARNING:     /" >&2
11084 >    ;;
11085 > esac
11086 > echo "$as_me:$LINENO: checking for iomanip" >&5
11087 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11088 > if test "${ac_cv_header_iomanip+set}" = set; then
11089 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11090 > else
11091 >  ac_cv_header_iomanip=$ac_header_preproc
11092 > fi
11093 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095 >
11096 > fi
11097 > if test $ac_cv_header_iomanip = yes; then
11098 >
11099 >
11100 > cat >>confdefs.h <<\_ACEOF
11101 > #define HAVE_IOMANIP 1
11102 > _ACEOF
11103 >
11104 >
11105 > else
11106 >
11107 >
11108 > for ac_header in iomanip.h
11109   do
11110   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6305 | Line 11138 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11138    cat conftest.err >&5
11139    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11140    (exit $ac_status); } &&
11141 <         { ac_try='test -z "$ac_c_werror_flag"
11141 >         { ac_try='test -z "$ac_cxx_werror_flag"
11142                           || test ! -s conftest.err'
11143    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11144    (eval $ac_try) 2>&5
# Line 6349 | Line 11182 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11182    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11183    (exit $ac_status); } >/dev/null; then
11184    if test -s conftest.err; then
11185 <    ac_cpp_err=$ac_c_preproc_warn_flag
11186 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11185 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11186 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187    else
11188      ac_cpp_err=
11189    fi
# Line 6370 | Line 11203 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11203   echo "${ECHO_T}$ac_header_preproc" >&6
11204  
11205   # So?  What about this header?
11206 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11206 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11207    yes:no: )
11208      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11209   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6422 | Line 11255 | for ac_header in machine/hal_sysinfo.h
11255   done
11256  
11257  
11258 < for ac_header in machine/hal_sysinfo.h
11258 > fi
11259 >
11260 >
11261 >
11262 >
11263 > for ac_header in cmath
11264   do
11265   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11266   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6455 | Line 11293 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11293    cat conftest.err >&5
11294    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11295    (exit $ac_status); } &&
11296 <         { ac_try='test -z "$ac_c_werror_flag"
11296 >         { ac_try='test -z "$ac_cxx_werror_flag"
11297                           || test ! -s conftest.err'
11298    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11299    (eval $ac_try) 2>&5
# Line 6499 | Line 11337 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11337    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11338    (exit $ac_status); } >/dev/null; then
11339    if test -s conftest.err; then
11340 <    ac_cpp_err=$ac_c_preproc_warn_flag
11341 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11340 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11341 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11342    else
11343      ac_cpp_err=
11344    fi
# Line 6520 | Line 11358 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11358   echo "${ECHO_T}$ac_header_preproc" >&6
11359  
11360   # So?  What about this header?
11361 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11361 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11362    yes:no: )
11363      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11364   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6574 | Line 11412 | done
11412  
11413  
11414  
11415 <
11416 <
11417 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6580 < do
6581 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6582 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6583 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6584 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11415 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11416 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11417 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11418    echo $ECHO_N "(cached) $ECHO_C" >&6
11419   else
11420 <  cat >conftest.$ac_ext <<_ACEOF
11420 >
11421 >      ac_cv_cxx_have_std_iostream=no
11422 >      ac_cv_cxx_need_use_std_iostream=no
11423 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11424 >
11425 >
11426 >        ac_ext=cc
11427 > ac_cpp='$CXXCPP $CPPFLAGS'
11428 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431 >
11432 >        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.  */
6593 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6594 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6595 – #define $ac_func innocuous_$ac_func
11438  
11439 < /* System header to define __stub macros and hopefully few prototypes,
11440 <    which can conflict with char $ac_func (); below.
6599 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6600 <    <limits.h> exists even on freestanding compilers.  */
6601 <
6602 < #ifdef __STDC__
6603 < # include <limits.h>
11439 > #ifdef HAVE_IOSTREAM
11440 > #include <iostream>
11441   #else
11442 < # include <assert.h>
11442 > #include <iostream.h>
11443   #endif
11444  
11445 < #undef $ac_func
11446 <
11447 < /* Override any gcc2 internal prototype to avoid an error.  */
11448 < #ifdef __cplusplus
11449 < extern "C"
11450 < {
11445 > #ifdef FC_DUMMY_MAIN
11446 > #ifndef FC_DUMMY_MAIN_EQ_F77
11447 > #  ifdef __cplusplus
11448 >     extern "C"
11449 > #  endif
11450 >   int FC_DUMMY_MAIN() { return 1; }
11451   #endif
6615 – /* We use char because int might match the return type of a gcc2
6616 –   builtin and then its argument prototype would still apply.  */
6617 – char $ac_func ();
6618 – /* The GNU C library defines this for functions which it implements
6619 –    to always fail with ENOSYS.  Some functions are actually named
6620 –    something starting with __ and the normal name is an alias.  */
6621 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6622 – choke me
6623 – #else
6624 – char (*f) () = $ac_func;
11452   #endif
6626 – #ifdef __cplusplus
6627 – }
6628 – #endif
6629 –
11453   int
11454   main ()
11455   {
11456 < return f != $ac_func;
11456 > std::cout<<"Hello World"<<std::endl;return 0;
11457    ;
11458    return 0;
11459   }
11460   _ACEOF
6638 – rm -f conftest.$ac_objext conftest$ac_exeext
6639 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6640 –  (eval $ac_link) 2>conftest.er1
6641 –  ac_status=$?
6642 –  grep -v '^ *+' conftest.er1 >conftest.err
6643 –  rm -f conftest.er1
6644 –  cat conftest.err >&5
6645 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6646 –  (exit $ac_status); } &&
6647 –         { ac_try='test -z "$ac_c_werror_flag"
6648 –                         || test ! -s conftest.err'
6649 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650 –  (eval $ac_try) 2>&5
6651 –  ac_status=$?
6652 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653 –  (exit $ac_status); }; } &&
6654 –         { ac_try='test -s conftest$ac_exeext'
6655 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6656 –  (eval $ac_try) 2>&5
6657 –  ac_status=$?
6658 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6659 –  (exit $ac_status); }; }; then
6660 –  eval "$as_ac_var=yes"
6661 – else
6662 –  echo "$as_me: failed program was:" >&5
6663 – sed 's/^/| /' conftest.$ac_ext >&5
6664 –
6665 – eval "$as_ac_var=no"
6666 – fi
6667 – rm -f conftest.err conftest.$ac_objext \
6668 –      conftest$ac_exeext conftest.$ac_ext
6669 – fi
6670 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6671 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6672 – if test `eval echo '${'$as_ac_var'}'` = yes; then
6673 –  cat >>confdefs.h <<_ACEOF
6674 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6675 – _ACEOF
6676 –
6677 – fi
6678 – done
6679 –
6680 – # special check for _system_configuration because AIX <4.3.2 do not
6681 – # contain the `physmem' member.
6682 – echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6683 – echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6684 – cat >conftest.$ac_ext <<_ACEOF
6685 – /* confdefs.h.  */
6686 – _ACEOF
6687 – cat confdefs.h >>conftest.$ac_ext
6688 – cat >>conftest.$ac_ext <<_ACEOF
6689 – /* end confdefs.h.  */
6690 – #include <sys/systemcfg.h>
6691 – int
6692 – main ()
6693 – {
6694 – double x = _system_configuration.physmem;
6695 –  ;
6696 –  return 0;
6697 – }
6698 – _ACEOF
11461   rm -f conftest.$ac_objext
11462   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11463    (eval $ac_compile) 2>conftest.er1
# Line 6705 | Line 11467 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11467    cat conftest.err >&5
11468    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469    (exit $ac_status); } &&
11470 <         { ac_try='test -z "$ac_c_werror_flag"
11470 >         { ac_try='test -z "$ac_cxx_werror_flag"
11471                           || test ! -s conftest.err'
11472    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473    (eval $ac_try) 2>&5
# Line 6718 | Line 11480 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11480    ac_status=$?
11481    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482    (exit $ac_status); }; }; then
11483 <  echo "$as_me:$LINENO: result: yes" >&5
6722 < echo "${ECHO_T}yes" >&6
6723 <
6724 < cat >>confdefs.h <<\_ACEOF
6725 < #define HAVE__SYSTEM_CONFIGURATION 1
6726 < _ACEOF
6727 <
11483 >  ac_cv_cxx_have_std_iostream=yes
11484   else
11485    echo "$as_me: failed program was:" >&5
11486   sed 's/^/| /' conftest.$ac_ext >&5
11487  
6732 – echo "$as_me:$LINENO: result: no" >&5
6733 – echo "${ECHO_T}no" >&6
11488   fi
11489   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11490 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6737 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6738 < if test "${ac_cv_header_time+set}" = set; then
6739 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6740 < else
6741 <  cat >conftest.$ac_ext <<_ACEOF
11490 >        cat >conftest.$ac_ext <<_ACEOF
11491   /* confdefs.h.  */
11492   _ACEOF
11493   cat confdefs.h >>conftest.$ac_ext
11494   cat >>conftest.$ac_ext <<_ACEOF
11495   /* end confdefs.h.  */
6747 – #include <sys/types.h>
6748 – #include <sys/time.h>
6749 – #include <time.h>
11496  
11497 + #define __USE_STD_IOSTREAM 1
11498 + #ifdef HAVE_IOSTREAM
11499 + #include <iostream>
11500 + #else
11501 + #include <iostream.h>
11502 + #endif
11503 +
11504 + #ifdef FC_DUMMY_MAIN
11505 + #ifndef FC_DUMMY_MAIN_EQ_F77
11506 + #  ifdef __cplusplus
11507 +     extern "C"
11508 + #  endif
11509 +   int FC_DUMMY_MAIN() { return 1; }
11510 + #endif
11511 + #endif
11512   int
11513   main ()
11514   {
11515 < if ((struct tm *) 0)
6755 < return 0;
11515 > std::cout<<"Hello World"<<std::endl;return 0;
11516    ;
11517    return 0;
11518   }
# Line 6766 | Line 11526 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11526    cat conftest.err >&5
11527    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528    (exit $ac_status); } &&
11529 <         { ac_try='test -z "$ac_c_werror_flag"
11529 >         { ac_try='test -z "$ac_cxx_werror_flag"
11530                           || test ! -s conftest.err'
11531    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532    (eval $ac_try) 2>&5
# Line 6779 | Line 11539 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11539    ac_status=$?
11540    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541    (exit $ac_status); }; }; then
11542 <  ac_cv_header_time=yes
11542 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11543   else
11544    echo "$as_me: failed program was:" >&5
11545   sed 's/^/| /' conftest.$ac_ext >&5
11546  
6787 – ac_cv_header_time=no
11547   fi
11548   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11549 +        ac_ext=cc
11550 + ac_cpp='$CXXCPP $CPPFLAGS'
11551 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11552 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11553 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11554 +
11555 +      fi
11556 +
11557   fi
11558 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11559 < echo "${ECHO_T}$ac_cv_header_time" >&6
11560 < if test $ac_cv_header_time = yes; then
11558 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11559 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11560 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11561  
11562   cat >>confdefs.h <<\_ACEOF
11563 < #define TIME_WITH_SYS_TIME 1
11563 > #define HAVE_STD_IOSTREAM 1
11564   _ACEOF
11565  
11566 < fi
11566 >  fi
11567 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568  
11569 + cat >>confdefs.h <<\_ACEOF
11570 + #define __USE_STD_IOSTREAM 1
11571 + _ACEOF
11572  
11573 < echo "$as_me:$LINENO: checking for clock_t" >&5
11574 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11575 < if test "${ac_cv_type_clock_t+set}" = set; then
11573 >  fi
11574 >
11575 >
11576 >
11577 >
11578 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581    echo $ECHO_N "(cached) $ECHO_C" >&6
11582   else
11583 <  cat >conftest.$ac_ext <<_ACEOF
11583 >
11584 >      ac_cv_cxx_have_std_stl=no
11585 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11586 >
11587 >
11588 >        ac_ext=cc
11589 > ac_cpp='$CXXCPP $CPPFLAGS'
11590 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593 >
11594 >        cat >conftest.$ac_ext <<_ACEOF
11595   /* confdefs.h.  */
11596   _ACEOF
11597   cat confdefs.h >>conftest.$ac_ext
11598   cat >>conftest.$ac_ext <<_ACEOF
11599   /* end confdefs.h.  */
11600 < $ac_includes_default
11600 > #include <list>
11601 >
11602 > #ifdef FC_DUMMY_MAIN
11603 > #ifndef FC_DUMMY_MAIN_EQ_F77
11604 > #  ifdef __cplusplus
11605 >     extern "C"
11606 > #  endif
11607 >   int FC_DUMMY_MAIN() { return 1; }
11608 > #endif
11609 > #endif
11610   int
11611   main ()
11612   {
11613 < if ((clock_t *) 0)
6818 <  return 0;
6819 < if (sizeof (clock_t))
6820 <  return 0;
11613 > std::list<int> foo;return 0;
11614    ;
11615    return 0;
11616   }
# Line 6831 | Line 11624 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11624    cat conftest.err >&5
11625    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11626    (exit $ac_status); } &&
11627 <         { ac_try='test -z "$ac_c_werror_flag"
11627 >         { ac_try='test -z "$ac_cxx_werror_flag"
11628                           || test ! -s conftest.err'
11629    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11630    (eval $ac_try) 2>&5
# Line 6844 | Line 11637 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11637    ac_status=$?
11638    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639    (exit $ac_status); }; }; then
11640 <  ac_cv_type_clock_t=yes
11640 >  ac_cv_cxx_have_std_stl=yes
11641   else
11642    echo "$as_me: failed program was:" >&5
11643   sed 's/^/| /' conftest.$ac_ext >&5
11644  
6852 – ac_cv_type_clock_t=no
11645   fi
11646   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647 < fi
11648 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11649 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11650 < if test $ac_cv_type_clock_t = yes; then
11647 >        ac_ext=cc
11648 > ac_cpp='$CXXCPP $CPPFLAGS'
11649 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652  
11653 < cat >>confdefs.h <<_ACEOF
11654 < #define HAVE_CLOCK_T 1
11653 >      fi
11654 >
11655 > fi
11656 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11657 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11658 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11659 >
11660 > cat >>confdefs.h <<\_ACEOF
11661 > #define HAVE_STD_STL 1
11662   _ACEOF
11663  
11664 +  fi
11665  
6865 – fi
11666  
11667 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11668 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11669 < if test "${ac_cv_c_const+set}" = set; then
11667 >
11668 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671    echo $ECHO_N "(cached) $ECHO_C" >&6
11672   else
11673 <  cat >conftest.$ac_ext <<_ACEOF
11673 >
11674 >    ac_cv_cxx_have_fstream_attach=no
11675 >
11676 >
11677 >    ac_ext=cc
11678 > ac_cpp='$CXXCPP $CPPFLAGS'
11679 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11680 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11681 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11682 >
11683 >    cat >conftest.$ac_ext <<_ACEOF
11684   /* confdefs.h.  */
11685   _ACEOF
11686   cat confdefs.h >>conftest.$ac_ext
11687   cat >>conftest.$ac_ext <<_ACEOF
11688   /* end confdefs.h.  */
11689  
11690 + #ifdef HAVE_IOSTREAM
11691 + #include <fstream>
11692 + #else
11693 + #include <fstream.h>
11694 + #endif
11695 + #ifdef HAVE_STD_IOSTREAM
11696 + using namespace std;
11697 + #endif
11698 +
11699 + #ifdef FC_DUMMY_MAIN
11700 + #ifndef FC_DUMMY_MAIN_EQ_F77
11701 + #  ifdef __cplusplus
11702 +     extern "C"
11703 + #  endif
11704 +   int FC_DUMMY_MAIN() { return 1; }
11705 + #endif
11706 + #endif
11707   int
11708   main ()
11709   {
11710 < /* FIXME: Include the comments suggested by Paul. */
6883 < #ifndef __cplusplus
6884 <  /* Ultrix mips cc rejects this.  */
6885 <  typedef int charset[2];
6886 <  const charset x;
6887 <  /* SunOS 4.1.1 cc rejects this.  */
6888 <  char const *const *ccp;
6889 <  char **p;
6890 <  /* NEC SVR4.0.2 mips cc rejects this.  */
6891 <  struct point {int x, y;};
6892 <  static struct point const zero = {0,0};
6893 <  /* AIX XL C 1.02.0.0 rejects this.
6894 <     It does not let you subtract one const X* pointer from another in
6895 <     an arm of an if-expression whose if-part is not a constant
6896 <     expression */
6897 <  const char *g = "string";
6898 <  ccp = &g + (g ? g-g : 0);
6899 <  /* HPUX 7.0 cc rejects these. */
6900 <  ++ccp;
6901 <  p = (char**) ccp;
6902 <  ccp = (char const *const *) p;
6903 <  { /* SCO 3.2v4 cc rejects this.  */
6904 <    char *t;
6905 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
6906 <
6907 <    *t++ = 0;
6908 <  }
6909 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6910 <    int x[] = {25, 17};
6911 <    const int *foo = &x[0];
6912 <    ++foo;
6913 <  }
6914 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6915 <    typedef const int *iptr;
6916 <    iptr p = 0;
6917 <    ++p;
6918 <  }
6919 <  { /* AIX XL C 1.02.0.0 rejects this saying
6920 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6921 <    struct s { int j; const int *ap[3]; };
6922 <    struct s *b; b->j = 5;
6923 <  }
6924 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6925 <    const int foo = 10;
6926 <  }
6927 < #endif
6928 <
11710 > int fd=0;ofstream s;s.attach(fd);
11711    ;
11712    return 0;
11713   }
# Line 6939 | Line 11721 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11721    cat conftest.err >&5
11722    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723    (exit $ac_status); } &&
11724 <         { ac_try='test -z "$ac_c_werror_flag"
11724 >         { ac_try='test -z "$ac_cxx_werror_flag"
11725                           || test ! -s conftest.err'
11726    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727    (eval $ac_try) 2>&5
# Line 6952 | Line 11734 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11734    ac_status=$?
11735    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736    (exit $ac_status); }; }; then
11737 <  ac_cv_c_const=yes
11737 >  ac_cv_cxx_have_fstream_attach=yes
11738   else
11739    echo "$as_me: failed program was:" >&5
11740   sed 's/^/| /' conftest.$ac_ext >&5
11741  
6960 – ac_cv_c_const=no
11742   fi
11743   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744 < fi
11745 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
11746 < echo "${ECHO_T}$ac_cv_c_const" >&6
11747 < if test $ac_cv_c_const = no; then
11744 >    ac_ext=cc
11745 > ac_cpp='$CXXCPP $CPPFLAGS'
11746 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749  
6968 – cat >>confdefs.h <<\_ACEOF
6969 – #define const
6970 – _ACEOF
11750  
11751   fi
11752 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11753 + echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11754 +  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11755  
11756 < echo "$as_me:$LINENO: checking for inline" >&5
11757 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
11758 < if test "${ac_cv_c_inline+set}" = set; then
11756 > cat >>confdefs.h <<\_ACEOF
11757 > #define HAVE_FSTREAM_ATTACH 1
11758 > _ACEOF
11759 >
11760 >  fi
11761 >
11762 >
11763 >
11764 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11765 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11766 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11767    echo $ECHO_N "(cached) $ECHO_C" >&6
11768   else
11769 <  ac_cv_c_inline=no
11770 < for ac_kw in inline __inline__ __inline; do
11771 <  cat >conftest.$ac_ext <<_ACEOF
11769 >
11770 >    ac_cv_cxx_have_fstream_open=no
11771 >    ac_cv_cxx_fstream_open_prot=no
11772 >
11773 >
11774 >    ac_ext=cc
11775 > ac_cpp='$CXXCPP $CPPFLAGS'
11776 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779 >
11780 >    # Try with 2 parameters
11781 >    cat >conftest.$ac_ext <<_ACEOF
11782   /* confdefs.h.  */
11783   _ACEOF
11784   cat confdefs.h >>conftest.$ac_ext
11785   cat >>conftest.$ac_ext <<_ACEOF
11786   /* end confdefs.h.  */
11787 < #ifndef __cplusplus
11788 < typedef int foo_t;
11789 < static $ac_kw foo_t static_foo () {return 0; }
11790 < $ac_kw foo_t foo () {return 0; }
11787 >
11788 > #ifdef HAVE_IOSTREAM
11789 > #include <fstream>
11790 > #else
11791 > #include <fstream.h>
11792   #endif
11793 + #ifdef HAVE_STD_IOSTREAM
11794 + using namespace std;
11795 + #endif
11796  
11797 + #ifdef FC_DUMMY_MAIN
11798 + #ifndef FC_DUMMY_MAIN_EQ_F77
11799 + #  ifdef __cplusplus
11800 +     extern "C"
11801 + #  endif
11802 +   int FC_DUMMY_MAIN() { return 1; }
11803 + #endif
11804 + #endif
11805 + int
11806 + main ()
11807 + {
11808 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809 +  ;
11810 +  return 0;
11811 + }
11812   _ACEOF
11813   rm -f conftest.$ac_objext
11814   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7000 | Line 11819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11819    cat conftest.err >&5
11820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821    (exit $ac_status); } &&
11822 <         { ac_try='test -z "$ac_c_werror_flag"
11822 >         { ac_try='test -z "$ac_cxx_werror_flag"
11823                           || test ! -s conftest.err'
11824    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825    (eval $ac_try) 2>&5
# Line 7013 | Line 11832 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11832    ac_status=$?
11833    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834    (exit $ac_status); }; }; then
11835 <  ac_cv_c_inline=$ac_kw; break
11835 >  ac_cv_cxx_have_fstream_open=yes
11836   else
11837    echo "$as_me: failed program was:" >&5
11838   sed 's/^/| /' conftest.$ac_ext >&5
11839  
11840   fi
11841   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11842 < done
11843 <
7025 < fi
7026 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7027 < echo "${ECHO_T}$ac_cv_c_inline" >&6
7028 <
7029 <
7030 < case $ac_cv_c_inline in
7031 <  inline | yes) ;;
7032 <  *)
7033 <    case $ac_cv_c_inline in
7034 <      no) ac_val=;;
7035 <      *) ac_val=$ac_cv_c_inline;;
7036 <    esac
7037 <    cat >>confdefs.h <<_ACEOF
7038 < #ifndef __cplusplus
7039 < #define inline $ac_val
7040 < #endif
7041 < _ACEOF
7042 <    ;;
7043 < esac
7044 <
7045 <
7046 <
7047 <
7048 < for ac_func in rint sranddev
7049 < do
7050 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7051 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7052 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7053 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7054 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7055 < else
7056 <  cat >conftest.$ac_ext <<_ACEOF
11842 >    # Try with mode parameter
11843 >    cat >conftest.$ac_ext <<_ACEOF
11844   /* confdefs.h.  */
11845   _ACEOF
11846   cat confdefs.h >>conftest.$ac_ext
11847   cat >>conftest.$ac_ext <<_ACEOF
11848   /* end confdefs.h.  */
7062 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7063 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7064 – #define $ac_func innocuous_$ac_func
11849  
11850 < /* System header to define __stub macros and hopefully few prototypes,
11851 <    which can conflict with char $ac_func (); below.
7068 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7069 <    <limits.h> exists even on freestanding compilers.  */
7070 <
7071 < #ifdef __STDC__
7072 < # include <limits.h>
11850 > #ifdef HAVE_IOSTREAM
11851 > #include <fstream>
11852   #else
11853 < # include <assert.h>
11853 > #include <fstream.h>
11854   #endif
11855 <
11856 < #undef $ac_func
7078 <
7079 < /* Override any gcc2 internal prototype to avoid an error.  */
7080 < #ifdef __cplusplus
7081 < extern "C"
7082 < {
11855 > #ifdef HAVE_STD_IOSTREAM
11856 > using namespace std;
11857   #endif
11858 < /* We use char because int might match the return type of a gcc2
11859 <   builtin and then its argument prototype would still apply.  */
11860 < char $ac_func ();
11861 < /* The GNU C library defines this for functions which it implements
11862 <    to always fail with ENOSYS.  Some functions are actually named
11863 <    something starting with __ and the normal name is an alias.  */
11864 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7091 < choke me
7092 < #else
7093 < char (*f) () = $ac_func;
11858 >
11859 > #ifdef FC_DUMMY_MAIN
11860 > #ifndef FC_DUMMY_MAIN_EQ_F77
11861 > #  ifdef __cplusplus
11862 >     extern "C"
11863 > #  endif
11864 >   int FC_DUMMY_MAIN() { return 1; }
11865   #endif
7095 – #ifdef __cplusplus
7096 – }
11866   #endif
7098 –
11867   int
11868   main ()
11869   {
11870 < return f != $ac_func;
11870 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871    ;
11872    return 0;
11873   }
11874   _ACEOF
11875 < rm -f conftest.$ac_objext conftest$ac_exeext
11876 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11877 <  (eval $ac_link) 2>conftest.er1
11875 > rm -f conftest.$ac_objext
11876 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11877 >  (eval $ac_compile) 2>conftest.er1
11878    ac_status=$?
11879    grep -v '^ *+' conftest.er1 >conftest.err
11880    rm -f conftest.er1
11881    cat conftest.err >&5
11882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883    (exit $ac_status); } &&
11884 <         { ac_try='test -z "$ac_c_werror_flag"
11884 >         { ac_try='test -z "$ac_cxx_werror_flag"
11885                           || test ! -s conftest.err'
11886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887    (eval $ac_try) 2>&5
11888    ac_status=$?
11889    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11890    (exit $ac_status); }; } &&
11891 <         { ac_try='test -s conftest$ac_exeext'
11891 >         { ac_try='test -s conftest.$ac_objext'
11892    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11893    (eval $ac_try) 2>&5
11894    ac_status=$?
11895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896    (exit $ac_status); }; }; then
11897 <  eval "$as_ac_var=yes"
11897 >  ac_cv_cxx_fstream_open_prot=yes
11898   else
11899    echo "$as_me: failed program was:" >&5
11900   sed 's/^/| /' conftest.$ac_ext >&5
11901  
7134 – eval "$as_ac_var=no"
11902   fi
11903 < rm -f conftest.err conftest.$ac_objext \
11904 <      conftest$ac_exeext conftest.$ac_ext
11903 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904 >    ac_ext=cc
11905 > ac_cpp='$CXXCPP $CPPFLAGS'
11906 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909 >
11910 >
11911   fi
11912 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11913 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11914 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11915 <  cat >>confdefs.h <<_ACEOF
11916 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11912 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11913 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11914 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11915 >
11916 > cat >>confdefs.h <<\_ACEOF
11917 > #define HAVE_FSTREAM_OPEN 1
11918   _ACEOF
11919  
11920 < fi
11921 < done
11920 >  fi
11921 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11922  
11923 + cat >>confdefs.h <<\_ACEOF
11924 + #define FSTREAM_OPEN_PROT 1
11925 + _ACEOF
11926  
11927 <  # clean out junk possibly left behind by a previous configuration
7151 <  rm -f src/getopt.h
7152 <  # Check for getopt_long support
11927 >  fi
11928  
11929 < for ac_header in getopt.h
11929 >
11930 >
11931 >
11932 >
11933 >
11934 >
11935 > for ac_header in ctype.h iostream fstream sstream strstream
11936   do
11937   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11938   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7184 | Line 11965 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11965    cat conftest.err >&5
11966    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11967    (exit $ac_status); } &&
11968 <         { ac_try='test -z "$ac_c_werror_flag"
11968 >         { ac_try='test -z "$ac_cxx_werror_flag"
11969                           || test ! -s conftest.err'
11970    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11971    (eval $ac_try) 2>&5
# Line 7228 | Line 12009 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
12009    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010    (exit $ac_status); } >/dev/null; then
12011    if test -s conftest.err; then
12012 <    ac_cpp_err=$ac_c_preproc_warn_flag
12013 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
12012 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
12013 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12014    else
12015      ac_cpp_err=
12016    fi
# Line 7249 | Line 12030 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
12030   echo "${ECHO_T}$ac_header_preproc" >&6
12031  
12032   # So?  What about this header?
12033 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12033 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12034    yes:no: )
12035      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12036   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7300 | Line 12081 | done
12081  
12082   done
12083  
12084 + # AC_CPP_FUNC
12085 + # ------------------ #
12086 + # Checks to see if ANSI C99 CPP variable __func__ works.
12087 + # If not, perhaps __FUNCTION__ works instead.
12088 + # If not, we'll just define __func__ to "".
12089 + # AC_CPP_FUNC
12090  
12091 < for ac_func in getopt_long
12092 < do
12093 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12094 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7308 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7309 < if eval "test \"\${$as_ac_var+set}\" = set"; then
12091 >
12092 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12093 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12094 > if test "${ac_cv_cpp_func+set}" = set; then
12095    echo $ECHO_N "(cached) $ECHO_C" >&6
12096   else
12097    cat >conftest.$ac_ext <<_ACEOF
# Line 7315 | Line 12100 | cat >>conftest.$ac_ext <<_ACEOF
12100   cat confdefs.h >>conftest.$ac_ext
12101   cat >>conftest.$ac_ext <<_ACEOF
12102   /* end confdefs.h.  */
7318 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7319 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7320 – #define $ac_func innocuous_$ac_func
12103  
12104 < /* System header to define __stub macros and hopefully few prototypes,
12105 <    which can conflict with char $ac_func (); below.
12106 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12107 <    <limits.h> exists even on freestanding compilers.  */
12108 <
12109 < #ifdef __STDC__
7328 < # include <limits.h>
7329 < #else
7330 < # include <assert.h>
7331 < #endif
7332 <
7333 < #undef $ac_func
7334 <
7335 < /* Override any gcc2 internal prototype to avoid an error.  */
7336 < #ifdef __cplusplus
7337 < extern "C"
7338 < {
7339 < #endif
7340 < /* We use char because int might match the return type of a gcc2
7341 <   builtin and then its argument prototype would still apply.  */
7342 < char $ac_func ();
7343 < /* The GNU C library defines this for functions which it implements
7344 <    to always fail with ENOSYS.  Some functions are actually named
7345 <    something starting with __ and the normal name is an alias.  */
7346 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7347 < choke me
7348 < #else
7349 < char (*f) () = $ac_func;
12104 > #ifdef FC_DUMMY_MAIN
12105 > #ifndef FC_DUMMY_MAIN_EQ_F77
12106 > #  ifdef __cplusplus
12107 >     extern "C"
12108 > #  endif
12109 >   int FC_DUMMY_MAIN() { return 1; }
12110   #endif
7351 – #ifdef __cplusplus
7352 – }
12111   #endif
7354 –
12112   int
12113   main ()
12114   {
12115 < return f != $ac_func;
12115 > const char *foo = __func__;
12116    ;
12117    return 0;
12118   }
12119   _ACEOF
12120 < rm -f conftest.$ac_objext conftest$ac_exeext
12121 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12122 <  (eval $ac_link) 2>conftest.er1
12120 > rm -f conftest.$ac_objext
12121 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12122 >  (eval $ac_compile) 2>conftest.er1
12123    ac_status=$?
12124    grep -v '^ *+' conftest.er1 >conftest.err
12125    rm -f conftest.er1
12126    cat conftest.err >&5
12127    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12128    (exit $ac_status); } &&
12129 <         { ac_try='test -z "$ac_c_werror_flag"
12129 >         { ac_try='test -z "$ac_cxx_werror_flag"
12130                           || test ! -s conftest.err'
12131    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12132    (eval $ac_try) 2>&5
12133    ac_status=$?
12134    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12135    (exit $ac_status); }; } &&
12136 <         { ac_try='test -s conftest$ac_exeext'
12136 >         { ac_try='test -s conftest.$ac_objext'
12137    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12138    (eval $ac_try) 2>&5
12139    ac_status=$?
12140    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12141    (exit $ac_status); }; }; then
12142 <  eval "$as_ac_var=yes"
12142 >  ac_cv_cpp_func=yes
12143   else
12144    echo "$as_me: failed program was:" >&5
12145   sed 's/^/| /' conftest.$ac_ext >&5
12146  
7390 – eval "$as_ac_var=no"
7391 – fi
7392 – rm -f conftest.err conftest.$ac_objext \
7393 –      conftest$ac_exeext conftest.$ac_ext
7394 – fi
7395 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7396 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7397 – if test `eval echo '${'$as_ac_var'}'` = yes; then
7398 –  cat >>confdefs.h <<_ACEOF
7399 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7400 – _ACEOF
7401 –
7402 – else
7403 –  # FreeBSD has a gnugetopt library for this
7404 –    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7405 – echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7406 – if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7407 –  echo $ECHO_N "(cached) $ECHO_C" >&6
7408 – else
7409 –  ac_check_lib_save_LIBS=$LIBS
7410 – LIBS="-lgnugetopt  $LIBS"
12147   cat >conftest.$ac_ext <<_ACEOF
12148   /* confdefs.h.  */
12149   _ACEOF
# Line 7415 | Line 12151 | cat >>conftest.$ac_ext <<_ACEOF
12151   cat >>conftest.$ac_ext <<_ACEOF
12152   /* end confdefs.h.  */
12153  
12154 < /* Override any gcc2 internal prototype to avoid an error.  */
12155 < #ifdef __cplusplus
12156 < extern "C"
12154 > #ifdef FC_DUMMY_MAIN
12155 > #ifndef FC_DUMMY_MAIN_EQ_F77
12156 > #  ifdef __cplusplus
12157 >     extern "C"
12158 > #  endif
12159 >   int FC_DUMMY_MAIN() { return 1; }
12160   #endif
12161 < /* We use char because int might match the return type of a gcc2
7423 <   builtin and then its argument prototype would still apply.  */
7424 < char getopt_long ();
12161 > #endif
12162   int
12163   main ()
12164   {
12165 < getopt_long ();
12165 > const char *foo = __FUNCTION__;
12166    ;
12167    return 0;
12168   }
12169   _ACEOF
12170 < rm -f conftest.$ac_objext conftest$ac_exeext
12171 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12172 <  (eval $ac_link) 2>conftest.er1
12170 > rm -f conftest.$ac_objext
12171 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12172 >  (eval $ac_compile) 2>conftest.er1
12173    ac_status=$?
12174    grep -v '^ *+' conftest.er1 >conftest.err
12175    rm -f conftest.er1
12176    cat conftest.err >&5
12177    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12178    (exit $ac_status); } &&
12179 <         { ac_try='test -z "$ac_c_werror_flag"
12179 >         { ac_try='test -z "$ac_cxx_werror_flag"
12180                           || test ! -s conftest.err'
12181    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12182    (eval $ac_try) 2>&5
12183    ac_status=$?
12184    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12185    (exit $ac_status); }; } &&
12186 <         { ac_try='test -s conftest$ac_exeext'
12186 >         { ac_try='test -s conftest.$ac_objext'
12187    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12188    (eval $ac_try) 2>&5
12189    ac_status=$?
12190    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12191    (exit $ac_status); }; }; then
12192 <  ac_cv_lib_gnugetopt_getopt_long=yes
12192 >  ac_cv_cpp_func=__FUNCTION__
12193   else
12194    echo "$as_me: failed program was:" >&5
12195   sed 's/^/| /' conftest.$ac_ext >&5
12196  
12197 < ac_cv_lib_gnugetopt_getopt_long=no
12197 > ac_cv_cpp_func=no
12198   fi
12199 < rm -f conftest.err conftest.$ac_objext \
7463 <      conftest$ac_exeext conftest.$ac_ext
7464 < LIBS=$ac_check_lib_save_LIBS
12199 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12200   fi
12201 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12202 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
12203 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12204 <  cat >>confdefs.h <<\_ACEOF
12205 < #define HAVE_GETOPT_LONG 1
12201 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12202 > fi
12203 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12204 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
12205 > if test $ac_cv_cpp_func = __FUNCTION__; then
12206 >
12207 > cat >>confdefs.h <<\_ACEOF
12208 > #define __func__ __FUNCTION__
12209   _ACEOF
12210  
12211 < else
7474 <  # use the GNU replacement
7475 <      case $LIBOBJS in
7476 <    "getopt.$ac_objext"   | \
7477 <  *" getopt.$ac_objext"   | \
7478 <    "getopt.$ac_objext "* | \
7479 <  *" getopt.$ac_objext "* ) ;;
7480 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7481 < esac
12211 > elif test $ac_cv_cpp_func = no; then
12212  
12213 <      case $LIBOBJS in
12214 <    "getopt1.$ac_objext"   | \
12215 <  *" getopt1.$ac_objext"   | \
7486 <    "getopt1.$ac_objext "* | \
7487 <  *" getopt1.$ac_objext "* ) ;;
7488 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7489 < esac
12213 > cat >>confdefs.h <<\_ACEOF
12214 > #define __func__ ""
12215 > _ACEOF
12216  
7491 –                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7492 –
12217   fi
12218  
7495 – fi
7496 – done
12219  
12220  
12221  
12222 +
12223   case $debug in
12224    1)
12225       ;;
# Line 7505 | Line 12228 | case $debug in
12228  
12229  
12230  
12231 + # Try to determine "good" native compiler flags if none specified on command
12232 + # line
12233  
12234 + if test "$ac_test_FFLAGS" != "set"; then
12235 +  FCFLAGS=""
12236 +  case "${host_cpu}-${host_os}" in
12237  
12238 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12239 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
12240 +                fi;;
12241 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12242 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12243 +                fi;;
12244 +   powerpc*-aix*)
12245 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12246 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12247 +                echo "*******************************************************"
12248 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12249 +                echo "*  recommended that you use                           *"
12250 +                echo "*                                                     *"
12251 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12252 +                echo "*                                 ^^^                 *"
12253 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12254 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12255 +                echo "*******************************************************"
12256 +        fi;;
12257 +   *darwin*)
12258 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12259 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12260 +        fi
12261 +        if test "$FC" = ifort; then
12262 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12263 +        fi;;
12264 +  esac
12265 +
12266 +  if test -n "$CPU_FLAGS"; then
12267 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12268 +  fi
12269 +
12270 +  if test -z "$FCFLAGS"; then
12271 +        echo ""
12272 +        echo "*********************************************************"
12273 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12274 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12275 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12276 +        echo "*********************************************************"
12277 +        echo ""
12278 +        FCFLAGS="-O3"
12279 +  fi
12280 +
12281 +
12282 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12283 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12284 + if test "${ac_guessed_f90flags+set}" = set; then
12285 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12286 + else
12287 +
12288 +
12289 +
12290 + ac_ext=${FC_SRCEXT-f}
12291 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12292 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12293 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12294 +
12295 + echo 'program main' > conftest.$ac_ext
12296 + echo 'end program main' >> conftest.$ac_ext
12297 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12298 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12299 +  (eval $ac_compile) 2>&5
12300 +  ac_status=$?
12301 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12302 +  (exit $ac_status); }; then
12303 +        ac_guessed_f90flags=yes
12304 + else
12305 +        ac_guessed_f90flags=no
12306 + fi
12307 + rm -f conftest*
12308 + ac_ext=cc
12309 + ac_cpp='$CXXCPP $CPPFLAGS'
12310 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12311 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12312 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12313 +
12314 +
12315 + fi
12316 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12317 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12318 + if test "$ac_guessed_f90flags" = yes; then
12319 +        :
12320 +
12321 + else
12322 +        :
12323 +
12324 +        echo ""
12325 +        echo "**********************************************************"
12326 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12327 +        echo "* your compiler.                                        *"
12328 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12329 +        echo "*********************************************************"
12330 +        echo ""
12331 +        FCFLAGS=""
12332 +
12333 + fi
12334 +
12335 +
12336 + fi
12337 +
12338 +
12339 +
12340 +
12341 +
12342 +
12343 +
12344   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12345   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12346   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 7515 | Line 12349 | cat > conftest.c <<EOF
12349  
12350   cat > conftest.c <<EOF
12351   #ifdef __GNUC__
12352 <  #ifndef __INTEL_COMPILER
12352 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12353 >     no;
12354 >  #else
12355       yes;
12356    #endif
12357   #endif
# Line 7553 | Line 12389 | if test "$ac_test_CFLAGS" != "set"; then
12389                      CFLAGS="-O"
12390                  fi;;
12391    sparc-solaris2*) if test "$CC" = cc; then
12392 <                    CFLAGS="-native -fast -xO5 -dalign"
12392 >                    CFLAGS="-O -dalign"
12393                   fi;;
12394  
12395    alpha*-osf*)  if test "$CC" = cc; then
# Line 7583 | Line 12419 | if test "$ac_test_CFLAGS" != "set"; then
12419     *darwin*)
12420          if test "$CC" = xlc -o "$CC" = cc; then
12421                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12422 +        fi
12423 +        if test "$CC" = icc; then
12424 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12425          fi;;
12426    esac
12427  
# Line 7596 | Line 12435 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12435      # -malign-double for x86 systems
12436  
12437  
12438 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12439 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12438 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12439 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12440   if test "${ac_align_double+set}" = set; then
12441    echo $ECHO_N "(cached) $ECHO_C" >&6
12442   else
12443    echo 'void f(){}' > conftest.c
12444 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12444 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12445          ac_align_double=yes
12446   else
12447          ac_align_double=no
# Line 7623 | Line 12462 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12462      # -fstrict-aliasing for gcc-2.95+
12463  
12464  
12465 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12466 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12465 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12466 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12467   if test "${ac_fstrict_aliasing+set}" = set; then
12468    echo $ECHO_N "(cached) $ECHO_C" >&6
12469   else
12470    echo 'void f(){}' > conftest.c
12471 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12471 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12472          ac_fstrict_aliasing=yes
12473   else
12474          ac_fstrict_aliasing=no
# Line 7654 | Line 12493 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12493                    case "${host_cpu}" in
12494            i586*)
12495  
12496 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12497 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12496 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12497 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12498   if test "${ac_cpu_pentium+set}" = set; then
12499    echo $ECHO_N "(cached) $ECHO_C" >&6
12500   else
12501    echo 'void f(){}' > conftest.c
12502 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12502 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12503          ac_cpu_pentium=yes
12504   else
12505          ac_cpu_pentium=no
# Line 7677 | Line 12516 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12516          :
12517  
12518  
12519 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12520 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12519 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12520 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12521   if test "${ac_pentium+set}" = set; then
12522    echo $ECHO_N "(cached) $ECHO_C" >&6
12523   else
12524    echo 'void f(){}' > conftest.c
12525 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12525 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12526          ac_pentium=yes
12527   else
12528          ac_pentium=no
# Line 7706 | Line 12545 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12545                    ;;
12546            i686*)
12547  
12548 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12549 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12548 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12549 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12550   if test "${ac_cpu_pentiumpro+set}" = set; then
12551    echo $ECHO_N "(cached) $ECHO_C" >&6
12552   else
12553    echo 'void f(){}' > conftest.c
12554 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12554 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12555          ac_cpu_pentiumpro=yes
12556   else
12557          ac_cpu_pentiumpro=no
# Line 7729 | Line 12568 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12568          :
12569  
12570  
12571 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12572 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12571 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12572 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12573   if test "${ac_pentiumpro+set}" = set; then
12574    echo $ECHO_N "(cached) $ECHO_C" >&6
12575   else
12576    echo 'void f(){}' > conftest.c
12577 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12577 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12578          ac_pentiumpro=yes
12579   else
12580          ac_pentiumpro=no
# Line 7762 | Line 12601 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12601                  if test -n "$is60x"; then
12602  
12603  
12604 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12605 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12604 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12605 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12606   if test "${ac_m_cpu_60x+set}" = set; then
12607    echo $ECHO_N "(cached) $ECHO_C" >&6
12608   else
12609    echo 'void f(){}' > conftest.c
12610 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12610 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12611          ac_m_cpu_60x=yes
12612   else
12613          ac_m_cpu_60x=no
# Line 7820 | Line 12659 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12659          :
12660  
12661  
12662 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12663 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12662 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12663 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12664   if test "${ac_m_cpu_750+set}" = set; then
12665    echo $ECHO_N "(cached) $ECHO_C" >&6
12666   else
12667    echo 'void f(){}' > conftest.c
12668 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12668 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12669          ac_m_cpu_750=yes
12670   else
12671          ac_m_cpu_750=no
# Line 7853 | Line 12692 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12692                  if test -z "$CPU_FLAGS"; then
12693  
12694  
12695 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12696 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12695 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12696 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12697   if test "${ac_m_cpu_powerpc+set}" = set; then
12698    echo $ECHO_N "(cached) $ECHO_C" >&6
12699   else
12700    echo 'void f(){}' > conftest.c
12701 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12701 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12702          ac_m_cpu_powerpc=yes
12703   else
12704          ac_m_cpu_powerpc=no
# Line 7881 | Line 12720 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12720                  if test -z "$CPU_FLAGS"; then
12721  
12722  
12723 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12724 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12723 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12724 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12725   if test "${ac_m_powerpc+set}" = set; then
12726    echo $ECHO_N "(cached) $ECHO_C" >&6
12727   else
12728    echo 'void f(){}' > conftest.c
12729 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12729 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12730          ac_m_powerpc=yes
12731   else
12732          ac_m_powerpc=no
# Line 7926 | Line 12765 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12765  
12766  
12767  
12768 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12769 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12768 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12769 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12770   if test "${ac_guessed_cflags+set}" = set; then
12771    echo $ECHO_N "(cached) $ECHO_C" >&6
12772   else
12773    echo 'void f(){}' > conftest.c
12774 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12774 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12775          ac_guessed_cflags=yes
12776   else
12777          ac_guessed_cflags=no
# Line 7976 | Line 12815 | cat > conftest.cpp <<EOF
12815  
12816   cat > conftest.cpp <<EOF
12817   #ifdef __GNUC__
12818 <  #ifndef __INTEL_COMPILER
12818 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12819 >     no;
12820 >  #else
12821       yes;
12822    #endif
12823   #endif
# Line 8014 | Line 12855 | if test "$ac_test_CXXFLAGS" != "set"; then
12855                      CXXFLAGS="-O"
12856                  fi;;
12857    sparc-solaris2*) if test "$CXX" = CC; then
12858 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12858 >                    CXXFLAGS="-features=extensions -O -dalign"
12859                   fi;;
12860     rs6000*-aix*)  if test "$CXX" = xlC; then
12861                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8035 | Line 12876 | if test "$ac_test_CXXFLAGS" != "set"; then
12876     *darwin*)
12877          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12878                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12879 +        fi
12880 +        if test "$CXX" = icpc; then
12881 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12882          fi;;
12883    esac
12884  
# Line 8048 | Line 12892 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12892      # -malign-double for x86 systems
12893  
12894  
12895 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12896 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12895 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12896 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12897   if test "${ac_align_double+set}" = set; then
12898    echo $ECHO_N "(cached) $ECHO_C" >&6
12899   else
12900    echo 'void f(){}' > conftest.cpp
12901 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12901 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12902          ac_align_double=yes
12903   else
12904          ac_align_double=no
# Line 8075 | Line 12919 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12919      # -fstrict-aliasing for gcc-2.95+
12920  
12921  
12922 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12923 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12922 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12923 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12924   if test "${ac_fstrict_aliasing+set}" = set; then
12925    echo $ECHO_N "(cached) $ECHO_C" >&6
12926   else
12927    echo 'void f(){}' > conftest.cpp
12928 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12928 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12929          ac_fstrict_aliasing=yes
12930   else
12931          ac_fstrict_aliasing=no
# Line 8106 | Line 12950 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12950                    case "${host_cpu}" in
12951            i586*)
12952  
12953 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12954 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12953 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12954 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12955   if test "${ac_cpu_pentium+set}" = set; then
12956    echo $ECHO_N "(cached) $ECHO_C" >&6
12957   else
12958    echo 'void f(){}' > conftest.cpp
12959 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12959 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12960          ac_cpu_pentium=yes
12961   else
12962          ac_cpu_pentium=no
# Line 8129 | Line 12973 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12973          :
12974  
12975  
12976 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12977 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12976 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12977 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12978   if test "${ac_pentium+set}" = set; then
12979    echo $ECHO_N "(cached) $ECHO_C" >&6
12980   else
12981    echo 'void f(){}' > conftest.cpp
12982 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12982 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12983          ac_pentium=yes
12984   else
12985          ac_pentium=no
# Line 8158 | Line 13002 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
13002                    ;;
13003            i686*)
13004  
13005 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13006 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13005 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13006 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13007   if test "${ac_cpu_pentiumpro+set}" = set; then
13008    echo $ECHO_N "(cached) $ECHO_C" >&6
13009   else
13010    echo 'void f(){}' > conftest.cpp
13011 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13011 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13012          ac_cpu_pentiumpro=yes
13013   else
13014          ac_cpu_pentiumpro=no
# Line 8181 | Line 13025 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
13025          :
13026  
13027  
13028 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13029 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13028 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13029 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13030   if test "${ac_pentiumpro+set}" = set; then
13031    echo $ECHO_N "(cached) $ECHO_C" >&6
13032   else
13033    echo 'void f(){}' > conftest.cpp
13034 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13034 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13035          ac_pentiumpro=yes
13036   else
13037          ac_pentiumpro=no
# Line 8212 | Line 13056 | fi
13056                  cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
13057                  is60x=`echo $cputype | egrep "^600-9e?$"`
13058                  if test -n "$is60x"; then
8215 –
8216 –
8217 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
8218 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
8219 – if test "${ac_m_cpu_60x+set}" = set; then
8220 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8221 – else
8222 –  echo 'void f(){}' > conftest.cpp
8223 – if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
8224 –        ac_m_cpu_60x=yes
8225 – else
8226 –        ac_m_cpu_60x=no
8227 – fi
8228 – rm -f conftest*
8229 –
8230 – fi
8231 – echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
8232 – echo "${ECHO_T}$ac_m_cpu_60x" >&6
8233 – if test "$ac_m_cpu_60x" = yes; then
8234 –        :
8235 –        CPU_FLAGS=-mcpu=$cputype
8236 – else
8237 –        :
8238 –
8239 – fi
8240 –
8241 –                elif test "$cputype" = 750; then
8242 –
8243 –
8244 – echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
8245 – echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
8246 – if test "${ac_cv_prog_gxx_2_95+set}" = set; then
8247 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8248 – else
8249 –
8250 – cat > conftest.cpp <<EOF
8251 – #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8252 – #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8253 –     yes;
8254 – #  endif
8255 – #endif
8256 – EOF
8257 – if { ac_try='${CXX-c++} -E conftest.cpp'
8258 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8259 –  (eval $ac_try) 2>&5
8260 –  ac_status=$?
8261 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8262 –  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8263 –  ac_cv_prog_gxx_2_95=yes
8264 – else
8265 –  ac_cv_prog_gxx_2_95=no
8266 – fi
8267 –
8268 – fi
8269 – echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8270 – echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8271 – if test "$ac_cv_prog_gxx_2_95" = yes; then
8272 –        :
8273 –
8274 –
8275 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
8276 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
8277 – if test "${ac_m_cpu_750+set}" = set; then
8278 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8279 – else
8280 –  echo 'void f(){}' > conftest.cpp
8281 – if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
8282 –        ac_m_cpu_750=yes
8283 – else
8284 –        ac_m_cpu_750=no
8285 – fi
8286 – rm -f conftest*
8287 –
8288 – fi
8289 – echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
8290 – echo "${ECHO_T}$ac_m_cpu_750" >&6
8291 – if test "$ac_m_cpu_750" = yes; then
8292 –        :
8293 –        CPU_FLAGS=-mcpu=750
8294 – else
8295 –        :
8296 –
8297 – fi
8298 –
8299 – else
8300 –        :
8301 –
8302 – fi
8303 –
8304 –                fi
8305 –                if test -z "$CPU_FLAGS"; then
8306 –
8307 –
8308 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
8309 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
8310 – if test "${ac_m_cpu_powerpc+set}" = set; then
8311 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8312 – else
8313 –  echo 'void f(){}' > conftest.cpp
8314 – if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
8315 –        ac_m_cpu_powerpc=yes
8316 – else
8317 –        ac_m_cpu_powerpc=no
8318 – fi
8319 – rm -f conftest*
8320 –
8321 – fi
8322 – echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
8323 – echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
8324 – if test "$ac_m_cpu_powerpc" = yes; then
8325 –        :
8326 –        CPU_FLAGS=-mcpu=powerpc
8327 – else
8328 –        :
8329 –
8330 – fi
8331 –
8332 –                fi
8333 –                if test -z "$CPU_FLAGS"; then
8334 –
8335 –
8336 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
8337 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
8338 – if test "${ac_m_powerpc+set}" = set; then
8339 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8340 – else
8341 –  echo 'void f(){}' > conftest.cpp
8342 – if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
8343 –        ac_m_powerpc=yes
8344 – else
8345 –        ac_m_powerpc=no
8346 – fi
8347 – rm -f conftest*
8348 –
8349 – fi
8350 – echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
8351 – echo "${ECHO_T}$ac_m_powerpc" >&6
8352 – if test "$ac_m_powerpc" = yes; then
8353 –        :
8354 –        CPU_FLAGS=-mpowerpc
8355 – else
8356 –        :
8357 –
8358 – fi
8359 –
8360 –                fi
8361 –          esac
8362 –  fi
8363 –
8364 –  if test -n "$CPU_FLAGS"; then
8365 –        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
8366 –  fi
13059  
8368 –  if test -z "$CXXFLAGS"; then
8369 –        echo ""
8370 –        echo "**********************************************************"
8371 –        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
8372 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8373 –        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
8374 –        echo "**********************************************************"
8375 –        echo ""
8376 –        CXXFLAGS="-O3"
8377 –  fi
13060  
13061 <
13062 <
13063 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
8382 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
8383 < if test "${ac_guessed_cxxflags+set}" = set; then
8384 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8385 < else
8386 <  echo 'void f(){}' > conftest.cpp
8387 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
8388 <        ac_guessed_cxxflags=yes
8389 < else
8390 <        ac_guessed_cxxflags=no
8391 < fi
8392 < rm -f conftest*
8393 <
8394 < fi
8395 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
8396 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
8397 < if test "$ac_guessed_cxxflags" = yes; then
8398 <        :
8399 <
8400 < else
8401 <        :
8402 <
8403 <        echo ""
8404 <        echo "**********************************************************"
8405 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
8406 <        echo "* your compiler.                                         *"
8407 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8408 <        echo "**********************************************************"
8409 <        echo ""
8410 <        CXXFLAGS=""
8411 <
8412 < fi
8413 <
8414 <
8415 < fi
8416 <
8417 <
8418 <
8419 <
8420 <
8421 < # Try to determine "good" native compiler flags if none specified on command
8422 < # line
8423 <
8424 < if test x"$F90FLAGS" = x ; then
8425 <  F90FLAGS=""
8426 <  case "${host_cpu}-${host_os}" in
8427 <
8428 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8429 <                    F90FLAGS="-O"
8430 <                fi;;
8431 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8432 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8433 <                fi;;
8434 <   powerpc*-aix*)
8435 <        if test "$F90" = f90 -o "$F90" = xlf90; then
8436 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8437 <                echo "*******************************************************"
8438 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8439 <                echo "*  recommended that you use                           *"
8440 <                echo "*                                                     *"
8441 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8442 <                echo "*                                 ^^^                 *"
8443 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8444 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8445 <                echo "*******************************************************"
8446 <        fi;;
8447 <   *darwin*)
8448 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8449 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8450 <        fi;;
8451 <  esac
8452 <
8453 <  if test -n "$CPU_FLAGS"; then
8454 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
8455 <  fi
8456 <
8457 <  if test -z "$F90FLAGS"; then
8458 <        echo ""
8459 <        echo "**********************************************************"
8460 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8461 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8462 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8463 <        echo "**********************************************************"
8464 <        echo ""
8465 <        F90FLAGS="-O3"
8466 <  fi
8467 <
8468 <
8469 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8470 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8471 < if test "${ac_guessed_f90flags+set}" = set; then
8472 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8473 < else
8474 <
8475 <
8476 <
8477 < ac_ext=f90
8478 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8479 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8480 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8481 <
8482 < echo 'program main' > conftest.$ac_ext
8483 < echo 'end program main' >> conftest.$ac_ext
8484 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8485 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8486 <  (eval $ac_compile) 2>&5
8487 <  ac_status=$?
8488 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8489 <  (exit $ac_status); }; then
8490 <        ac_guessed_f90flags=yes
8491 < else
8492 <        ac_guessed_f90flags=no
8493 < fi
8494 < rm -f conftest*
8495 < ac_ext=c
8496 < ac_cpp='$CPP $CPPFLAGS'
8497 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8498 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8499 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8500 <
8501 <
8502 < fi
8503 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8504 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
8505 < if test "$ac_guessed_f90flags" = yes; then
8506 <        :
8507 <
8508 < else
8509 <        :
8510 <
8511 <        echo ""
8512 <        echo "**********************************************************"
8513 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8514 <        echo "* your compiler.                                         *"
8515 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8516 <        echo "**********************************************************"
8517 <        echo ""
8518 <        F90FLAGS=""
8519 <
8520 < fi
8521 <
8522 <
8523 < fi
8524 <
8525 <     ;;
8526 < esac
8527 <
8528 < # Find a good install program.  We prefer a C program (faster),
8529 < # so one script is as good as another.  But avoid the broken or
8530 < # incompatible versions:
8531 < # SysV /etc/install, /usr/sbin/install
8532 < # SunOS /usr/etc/install
8533 < # IRIX /sbin/install
8534 < # AIX /bin/install
8535 < # AmigaOS /C/install, which installs bootblocks on floppy discs
8536 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8537 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8538 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8539 < # OS/2's system install, which has a completely different semantic
8540 < # ./install, which can be erroneously created by make from ./install.sh.
8541 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8542 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8543 < if test -z "$INSTALL"; then
8544 < if test "${ac_cv_path_install+set}" = set; then
8545 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8546 < else
8547 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8548 < for as_dir in $PATH
8549 < do
8550 <  IFS=$as_save_IFS
8551 <  test -z "$as_dir" && as_dir=.
8552 <  # Account for people who put trailing slashes in PATH elements.
8553 < case $as_dir/ in
8554 <  ./ | .// | /cC/* | \
8555 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8556 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8557 <  /usr/ucb/* ) ;;
8558 <  *)
8559 <    # OSF1 and SCO ODT 3.0 have their own names for install.
8560 <    # Don't use installbsd from OSF since it installs stuff as root
8561 <    # by default.
8562 <    for ac_prog in ginstall scoinst install; do
8563 <      for ac_exec_ext in '' $ac_executable_extensions; do
8564 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8565 <          if test $ac_prog = install &&
8566 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8567 <            # AIX install.  It has an incompatible calling convention.
8568 <            :
8569 <          elif test $ac_prog = install &&
8570 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8571 <            # program-specific install script used by HP pwplus--don't use.
8572 <            :
8573 <          else
8574 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8575 <            break 3
8576 <          fi
8577 <        fi
8578 <      done
8579 <    done
8580 <    ;;
8581 < esac
8582 < done
8583 <
8584 <
8585 < fi
8586 <  if test "${ac_cv_path_install+set}" = set; then
8587 <    INSTALL=$ac_cv_path_install
8588 <  else
8589 <    # As a last resort, use the slow shell script.  We don't cache a
8590 <    # path for INSTALL within a source directory, because that will
8591 <    # break other packages using the cache if that directory is
8592 <    # removed, or if the path is relative.
8593 <    INSTALL=$ac_install_sh
8594 <  fi
8595 < fi
8596 < echo "$as_me:$LINENO: result: $INSTALL" >&5
8597 < echo "${ECHO_T}$INSTALL" >&6
8598 <
8599 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8600 < # It thinks the first close brace ends the variable substitution.
8601 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8602 <
8603 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8604 <
8605 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8606 <
8607 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
8608 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8609 < LN_S=$as_ln_s
8610 < if test "$LN_S" = "ln -s"; then
8611 <  echo "$as_me:$LINENO: result: yes" >&5
8612 < echo "${ECHO_T}yes" >&6
8613 < else
8614 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8615 < echo "${ECHO_T}no, using $LN_S" >&6
8616 < fi
8617 <
8618 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8619 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8620 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8621 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
13061 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063 > if test "${ac_m_cpu_60x+set}" = set; then
13064    echo $ECHO_N "(cached) $ECHO_C" >&6
13065   else
13066 <  cat >conftest.make <<\_ACEOF
13067 < all:
13068 <        @echo 'ac_maketemp="$(MAKE)"'
8627 < _ACEOF
8628 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8629 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8630 < if test -n "$ac_maketemp"; then
8631 <  eval ac_cv_prog_make_${ac_make}_set=yes
13066 >  echo 'void f(){}' > conftest.cpp
13067 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068 >        ac_m_cpu_60x=yes
13069   else
13070 <  eval ac_cv_prog_make_${ac_make}_set=no
13070 >        ac_m_cpu_60x=no
13071   fi
13072 < rm -f conftest.make
13072 > rm -f conftest*
13073 >
13074   fi
13075 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
13076 <  echo "$as_me:$LINENO: result: yes" >&5
13077 < echo "${ECHO_T}yes" >&6
13078 <  SET_MAKE=
13075 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
13076 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
13077 > if test "$ac_m_cpu_60x" = yes; then
13078 >        :
13079 >        CPU_FLAGS=-mcpu=$cputype
13080   else
13081 <  echo "$as_me:$LINENO: result: no" >&5
13082 < echo "${ECHO_T}no" >&6
8644 <  SET_MAKE="MAKE=${MAKE-make}"
13081 >        :
13082 >
13083   fi
13084  
13085 < if test -n "$ac_tool_prefix"; then
13086 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
13087 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
13088 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13089 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13090 < if test "${ac_cv_prog_RANLIB+set}" = set; then
13085 >                elif test "$cputype" = 750; then
13086 >
13087 >
13088 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
13089 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
13090 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
13091    echo $ECHO_N "(cached) $ECHO_C" >&6
13092   else
8655 –  if test -n "$RANLIB"; then
8656 –  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8657 – else
8658 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8659 – for as_dir in $PATH
8660 – do
8661 –  IFS=$as_save_IFS
8662 –  test -z "$as_dir" && as_dir=.
8663 –  for ac_exec_ext in '' $ac_executable_extensions; do
8664 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8665 –    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8666 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8667 –    break 2
8668 –  fi
8669 – done
8670 – done
13093  
13094 < fi
13095 < fi
13096 < RANLIB=$ac_cv_prog_RANLIB
13097 < if test -n "$RANLIB"; then
13098 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
13099 < echo "${ECHO_T}$RANLIB" >&6
13094 > cat > conftest.cpp <<EOF
13095 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
13096 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
13097 >     yes;
13098 > #  endif
13099 > #endif
13100 > EOF
13101 > if { ac_try='${CXX-c++} -E conftest.cpp'
13102 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13103 >  (eval $ac_try) 2>&5
13104 >  ac_status=$?
13105 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13106 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13107 >  ac_cv_prog_gxx_2_95=yes
13108   else
13109 <  echo "$as_me:$LINENO: result: no" >&5
8680 < echo "${ECHO_T}no" >&6
13109 >  ac_cv_prog_gxx_2_95=no
13110   fi
13111  
13112   fi
13113 < if test -z "$ac_cv_prog_RANLIB"; then
13114 <  ac_ct_RANLIB=$RANLIB
13115 <  # Extract the first word of "ranlib", so it can be a program name with args.
13116 < set dummy ranlib; ac_word=$2
13117 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13118 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13119 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
13113 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
13114 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
13115 > if test "$ac_cv_prog_gxx_2_95" = yes; then
13116 >        :
13117 >
13118 >
13119 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121 > if test "${ac_m_cpu_750+set}" = set; then
13122    echo $ECHO_N "(cached) $ECHO_C" >&6
13123   else
13124 <  if test -n "$ac_ct_RANLIB"; then
13125 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
13124 >  echo 'void f(){}' > conftest.cpp
13125 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126 >        ac_m_cpu_750=yes
13127   else
13128 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13129 < for as_dir in $PATH
13130 < do
8699 <  IFS=$as_save_IFS
8700 <  test -z "$as_dir" && as_dir=.
8701 <  for ac_exec_ext in '' $ac_executable_extensions; do
8702 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8703 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
8704 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8705 <    break 2
8706 <  fi
8707 < done
8708 < done
13128 >        ac_m_cpu_750=no
13129 > fi
13130 > rm -f conftest*
13131  
8710 –  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
13132   fi
13133 < fi
13134 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
13135 < if test -n "$ac_ct_RANLIB"; then
13136 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
13137 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
13133 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13134 > echo "${ECHO_T}$ac_m_cpu_750" >&6
13135 > if test "$ac_m_cpu_750" = yes; then
13136 >        :
13137 >        CPU_FLAGS=-mcpu=750
13138   else
13139 <  echo "$as_me:$LINENO: result: no" >&5
8719 < echo "${ECHO_T}no" >&6
8720 < fi
13139 >        :
13140  
8722 –  RANLIB=$ac_ct_RANLIB
8723 – else
8724 –  RANLIB="$ac_cv_prog_RANLIB"
13141   fi
13142  
8727 – for ac_prog in 'bison -y' byacc
8728 – do
8729 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
8730 – set dummy $ac_prog; ac_word=$2
8731 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8732 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8733 – if test "${ac_cv_prog_YACC+set}" = set; then
8734 –  echo $ECHO_N "(cached) $ECHO_C" >&6
13143   else
13144 <  if test -n "$YACC"; then
8737 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
8738 < else
8739 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8740 < for as_dir in $PATH
8741 < do
8742 <  IFS=$as_save_IFS
8743 <  test -z "$as_dir" && as_dir=.
8744 <  for ac_exec_ext in '' $ac_executable_extensions; do
8745 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8746 <    ac_cv_prog_YACC="$ac_prog"
8747 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8748 <    break 2
8749 <  fi
8750 < done
8751 < done
13144 >        :
13145  
13146   fi
8754 – fi
8755 – YACC=$ac_cv_prog_YACC
8756 – if test -n "$YACC"; then
8757 –  echo "$as_me:$LINENO: result: $YACC" >&5
8758 – echo "${ECHO_T}$YACC" >&6
8759 – else
8760 –  echo "$as_me:$LINENO: result: no" >&5
8761 – echo "${ECHO_T}no" >&6
8762 – fi
13147  
13148 <  test -n "$YACC" && break
13149 < done
8766 < test -n "$YACC" || YACC="yacc"
13148 >                fi
13149 >                if test -z "$CPU_FLAGS"; then
13150  
13151 < for ac_prog in flex lex
13152 < do
13153 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13154 < set dummy $ac_prog; ac_word=$2
8772 < echo "$as_me:$LINENO: checking for $ac_word" >&5
8773 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8774 < if test "${ac_cv_prog_LEX+set}" = set; then
13151 >
13152 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13153 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13154 > if test "${ac_m_cpu_powerpc+set}" = set; then
13155    echo $ECHO_N "(cached) $ECHO_C" >&6
13156   else
13157 <  if test -n "$LEX"; then
13158 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
13157 >  echo 'void f(){}' > conftest.cpp
13158 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13159 >        ac_m_cpu_powerpc=yes
13160   else
13161 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13162 < for as_dir in $PATH
13163 < do
8783 <  IFS=$as_save_IFS
8784 <  test -z "$as_dir" && as_dir=.
8785 <  for ac_exec_ext in '' $ac_executable_extensions; do
8786 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8787 <    ac_cv_prog_LEX="$ac_prog"
8788 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8789 <    break 2
8790 <  fi
8791 < done
8792 < done
13161 >        ac_m_cpu_powerpc=no
13162 > fi
13163 > rm -f conftest*
13164  
13165   fi
13166 < fi
13167 < LEX=$ac_cv_prog_LEX
13168 < if test -n "$LEX"; then
13169 <  echo "$as_me:$LINENO: result: $LEX" >&5
13170 < echo "${ECHO_T}$LEX" >&6
13166 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13167 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
13168 > if test "$ac_m_cpu_powerpc" = yes; then
13169 >        :
13170 >        CPU_FLAGS=-mcpu=powerpc
13171   else
13172 <  echo "$as_me:$LINENO: result: no" >&5
8802 < echo "${ECHO_T}no" >&6
8803 < fi
8804 <
8805 <  test -n "$LEX" && break
8806 < done
8807 < test -n "$LEX" || LEX=":"
8808 <
8809 < if test -z "$LEXLIB"
8810 < then
8811 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8812 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8813 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8814 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8815 < else
8816 <  ac_check_lib_save_LIBS=$LIBS
8817 < LIBS="-lfl  $LIBS"
8818 < cat >conftest.$ac_ext <<_ACEOF
8819 < /* confdefs.h.  */
8820 < _ACEOF
8821 < cat confdefs.h >>conftest.$ac_ext
8822 < cat >>conftest.$ac_ext <<_ACEOF
8823 < /* end confdefs.h.  */
8824 <
8825 < /* Override any gcc2 internal prototype to avoid an error.  */
8826 < #ifdef __cplusplus
8827 < extern "C"
8828 < #endif
8829 < /* We use char because int might match the return type of a gcc2
8830 <   builtin and then its argument prototype would still apply.  */
8831 < char yywrap ();
8832 < int
8833 < main ()
8834 < {
8835 < yywrap ();
8836 <  ;
8837 <  return 0;
8838 < }
8839 < _ACEOF
8840 < rm -f conftest.$ac_objext conftest$ac_exeext
8841 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8842 <  (eval $ac_link) 2>conftest.er1
8843 <  ac_status=$?
8844 <  grep -v '^ *+' conftest.er1 >conftest.err
8845 <  rm -f conftest.er1
8846 <  cat conftest.err >&5
8847 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8848 <  (exit $ac_status); } &&
8849 <         { ac_try='test -z "$ac_c_werror_flag"
8850 <                         || test ! -s conftest.err'
8851 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8852 <  (eval $ac_try) 2>&5
8853 <  ac_status=$?
8854 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8855 <  (exit $ac_status); }; } &&
8856 <         { ac_try='test -s conftest$ac_exeext'
8857 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8858 <  (eval $ac_try) 2>&5
8859 <  ac_status=$?
8860 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8861 <  (exit $ac_status); }; }; then
8862 <  ac_cv_lib_fl_yywrap=yes
8863 < else
8864 <  echo "$as_me: failed program was:" >&5
8865 < sed 's/^/| /' conftest.$ac_ext >&5
13172 >        :
13173  
8867 – ac_cv_lib_fl_yywrap=no
13174   fi
8869 – rm -f conftest.err conftest.$ac_objext \
8870 –      conftest$ac_exeext conftest.$ac_ext
8871 – LIBS=$ac_check_lib_save_LIBS
8872 – fi
8873 – echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8874 – echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8875 – if test $ac_cv_lib_fl_yywrap = yes; then
8876 –  LEXLIB="-lfl"
8877 – else
8878 –  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8879 – echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8880 – if test "${ac_cv_lib_l_yywrap+set}" = set; then
8881 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8882 – else
8883 –  ac_check_lib_save_LIBS=$LIBS
8884 – LIBS="-ll  $LIBS"
8885 – cat >conftest.$ac_ext <<_ACEOF
8886 – /* confdefs.h.  */
8887 – _ACEOF
8888 – cat confdefs.h >>conftest.$ac_ext
8889 – cat >>conftest.$ac_ext <<_ACEOF
8890 – /* end confdefs.h.  */
13175  
13176 < /* Override any gcc2 internal prototype to avoid an error.  */
13177 < #ifdef __cplusplus
8894 < extern "C"
8895 < #endif
8896 < /* We use char because int might match the return type of a gcc2
8897 <   builtin and then its argument prototype would still apply.  */
8898 < char yywrap ();
8899 < int
8900 < main ()
8901 < {
8902 < yywrap ();
8903 <  ;
8904 <  return 0;
8905 < }
8906 < _ACEOF
8907 < rm -f conftest.$ac_objext conftest$ac_exeext
8908 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8909 <  (eval $ac_link) 2>conftest.er1
8910 <  ac_status=$?
8911 <  grep -v '^ *+' conftest.er1 >conftest.err
8912 <  rm -f conftest.er1
8913 <  cat conftest.err >&5
8914 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8915 <  (exit $ac_status); } &&
8916 <         { ac_try='test -z "$ac_c_werror_flag"
8917 <                         || test ! -s conftest.err'
8918 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8919 <  (eval $ac_try) 2>&5
8920 <  ac_status=$?
8921 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8922 <  (exit $ac_status); }; } &&
8923 <         { ac_try='test -s conftest$ac_exeext'
8924 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8925 <  (eval $ac_try) 2>&5
8926 <  ac_status=$?
8927 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8928 <  (exit $ac_status); }; }; then
8929 <  ac_cv_lib_l_yywrap=yes
8930 < else
8931 <  echo "$as_me: failed program was:" >&5
8932 < sed 's/^/| /' conftest.$ac_ext >&5
13176 >                fi
13177 >                if test -z "$CPU_FLAGS"; then
13178  
8934 – ac_cv_lib_l_yywrap=no
8935 – fi
8936 – rm -f conftest.err conftest.$ac_objext \
8937 –      conftest$ac_exeext conftest.$ac_ext
8938 – LIBS=$ac_check_lib_save_LIBS
8939 – fi
8940 – echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
8941 – echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
8942 – if test $ac_cv_lib_l_yywrap = yes; then
8943 –  LEXLIB="-ll"
8944 – fi
13179  
13180 < fi
13181 <
13182 < fi
8949 <
8950 < if test "x$LEX" != "x:"; then
8951 <  echo "$as_me:$LINENO: checking lex output file root" >&5
8952 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
8953 < if test "${ac_cv_prog_lex_root+set}" = set; then
13180 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13181 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13182 > if test "${ac_m_powerpc+set}" = set; then
13183    echo $ECHO_N "(cached) $ECHO_C" >&6
13184   else
13185 <  # The minimal lex program is just a single line: %%.  But some broken lexes
13186 < # (Solaris, I think it was) want two %% lines, so accommodate them.
13187 < cat >conftest.l <<_ACEOF
8959 < %%
8960 < %%
8961 < _ACEOF
8962 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
8963 <  (eval $LEX conftest.l) 2>&5
8964 <  ac_status=$?
8965 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8966 <  (exit $ac_status); }
8967 < if test -f lex.yy.c; then
8968 <  ac_cv_prog_lex_root=lex.yy
8969 < elif test -f lexyy.c; then
8970 <  ac_cv_prog_lex_root=lexyy
13185 >  echo 'void f(){}' > conftest.cpp
13186 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13187 >        ac_m_powerpc=yes
13188   else
13189 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
8973 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
8974 <   { (exit 1); exit 1; }; }
13189 >        ac_m_powerpc=no
13190   fi
13191 < fi
8977 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
8978 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
8979 < rm -f conftest.l
8980 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13191 > rm -f conftest*
13192  
13193 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
13194 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
13195 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
13196 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13193 > fi
13194 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
13195 > echo "${ECHO_T}$ac_m_powerpc" >&6
13196 > if test "$ac_m_powerpc" = yes; then
13197 >        :
13198 >        CPU_FLAGS=-mpowerpc
13199   else
13200 <  # POSIX says lex can declare yytext either as a pointer or an array; the
8988 < # default is implementation-dependent. Figure out which it is, since
8989 < # not all implementations provide the %pointer and %array declarations.
8990 < ac_cv_prog_lex_yytext_pointer=no
8991 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
8992 < ac_save_LIBS=$LIBS
8993 < LIBS="$LIBS $LEXLIB"
8994 < cat >conftest.$ac_ext <<_ACEOF
8995 < `cat $LEX_OUTPUT_ROOT.c`
8996 < _ACEOF
8997 < rm -f conftest.$ac_objext conftest$ac_exeext
8998 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8999 <  (eval $ac_link) 2>conftest.er1
9000 <  ac_status=$?
9001 <  grep -v '^ *+' conftest.er1 >conftest.err
9002 <  rm -f conftest.er1
9003 <  cat conftest.err >&5
9004 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9005 <  (exit $ac_status); } &&
9006 <         { ac_try='test -z "$ac_c_werror_flag"
9007 <                         || test ! -s conftest.err'
9008 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9009 <  (eval $ac_try) 2>&5
9010 <  ac_status=$?
9011 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9012 <  (exit $ac_status); }; } &&
9013 <         { ac_try='test -s conftest$ac_exeext'
9014 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9015 <  (eval $ac_try) 2>&5
9016 <  ac_status=$?
9017 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9018 <  (exit $ac_status); }; }; then
9019 <  ac_cv_prog_lex_yytext_pointer=yes
9020 < else
9021 <  echo "$as_me: failed program was:" >&5
9022 < sed 's/^/| /' conftest.$ac_ext >&5
13200 >        :
13201  
13202   fi
9025 – rm -f conftest.err conftest.$ac_objext \
9026 –      conftest$ac_exeext conftest.$ac_ext
9027 – LIBS=$ac_save_LIBS
9028 – rm -f "${LEX_OUTPUT_ROOT}.c"
13203  
13204 < fi
13205 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
13206 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9033 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
13204 >                fi
13205 >          esac
13206 >  fi
13207  
13208 < cat >>confdefs.h <<\_ACEOF
13209 < #define YYTEXT_POINTER 1
13210 < _ACEOF
13208 >  if test -n "$CPU_FLAGS"; then
13209 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13210 >  fi
13211  
13212 < fi
13212 >  if test -z "$CXXFLAGS"; then
13213 >        echo ""
13214 >        echo "**********************************************************"
13215 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
13216 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13217 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
13218 >        echo "**********************************************************"
13219 >        echo ""
13220 >        CXXFLAGS="-O3"
13221 >  fi
13222  
9041 – fi
13223  
13224 <   # Extract the first word of "perl", so it can be a program name with args.
13225 < set dummy perl; ac_word=$2
13226 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13227 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9047 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
13224 >
13225 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13226 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13227 > if test "${ac_guessed_cxxflags+set}" = set; then
13228    echo $ECHO_N "(cached) $ECHO_C" >&6
13229   else
13230 <  case $PERLINTERP in
13231 <  [\\/]* | ?:[\\/]*)
13232 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9053 <  ;;
9054 <  *)
9055 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9056 < for as_dir in $PATH
9057 < do
9058 <  IFS=$as_save_IFS
9059 <  test -z "$as_dir" && as_dir=.
9060 <  for ac_exec_ext in '' $ac_executable_extensions; do
9061 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9062 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9063 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9064 <    break 2
9065 <  fi
9066 < done
9067 < done
9068 <
9069 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9070 <  ;;
9071 < esac
9072 < fi
9073 < PERLINTERP=$ac_cv_path_PERLINTERP
9074 <
9075 < if test -n "$PERLINTERP"; then
9076 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9077 < echo "${ECHO_T}$PERLINTERP" >&6
13230 >  echo 'void f(){}' > conftest.cpp
13231 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13232 >        ac_guessed_cxxflags=yes
13233   else
13234 <  echo "$as_me:$LINENO: result: no" >&5
9080 < echo "${ECHO_T}no" >&6
13234 >        ac_guessed_cxxflags=no
13235   fi
13236 + rm -f conftest*
13237  
9083 –   ac_cv_path_perlinterp="$PERLINTERP"
9084 –   _sHpB='#!'
9085 –
9086 –
9087 – # Check whether --with-perl-shebang or --without-perl-shebang was given.
9088 – if test "${with_perl_shebang+set}" = set; then
9089 –  withval="$with_perl_shebang"
9090 –  opt_perl_shebang="$withval"
9091 – else
9092 –                opt_perl_shebang="not_set"
9093 – fi;
9094 –   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9095 – echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9096 – if test "${ax_cv_opt_perl_shebang+set}" = set; then
9097 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9098 – else
9099 –   case "$opt_perl_shebang" in
9100 –                      not_set  ) ax_cv_opt_perl_shebang=''
9101 –                               ;;
9102 –                         *     )
9103 –        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9104 –                    esac
9105 –
13238   fi
13239 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
13240 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
13241 <   if test "A$ax_cv_opt_perl_shebang" != "A"
13242 <     then
9111 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9112 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9113 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9114 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
13239 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
13240 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
13241 > if test "$ac_guessed_cxxflags" = yes; then
13242 >        :
13243  
9116 – # Automatic detection of sharpbang formula starts here
9117 –     else
9118 –   _somian_shbangperl=`$PERLINTERP -V:startperl`
9119 –   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9120 –   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9121 – echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9122 – if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9123 –  echo $ECHO_N "(cached) $ECHO_C" >&6
13244   else
13245 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9126 <        if test "x$_somian_kspb_perl" == x
9127 <          then _somian_ksbp_warn_empty='durnit'
9128 <          else
9129 <          case "A$_somian_kspb_perl" in
9130 <                 A#!*perl* )
9131 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9132 <                        ;;
9133 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9134 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9135 <          esac
9136 <        fi
13245 >        :
13246  
13247 < fi
13248 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
13249 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
13250 < # The above prints Checking ... result message to user.
13251 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
13247 >        echo ""
13248 >        echo "**********************************************************"
13249 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
13250 >        echo "* your compiler.                                         *"
13251 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13252 >        echo "**********************************************************"
13253 >        echo ""
13254 >        CXXFLAGS=""
13255  
9144 –    if test A${_somian_ksbp_warn_empty+set} == Aset
9145 –      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9146 – echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9147 –    fi
9148 – # Inform user after printing result value
9149 –    if test A${_somian_ksbp_warn_defau+set} == Aset
9150 –      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9151 – echo "$as_me: Maybe Not good -" >&6;}
9152 –           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9153 – echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9154 –      else { echo "$as_me:$LINENO: OK Good result - " >&5
9155 – echo "$as_me: OK Good result - " >&6;}
9156 –           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9157 – echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9158 –    fi
9159 –  fi
9160 –
9161 – # Extract the first word of "ar", so it can be a program name with args.
9162 – set dummy ar; ac_word=$2
9163 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9164 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9165 – if test "${ac_cv_prog_AR+set}" = set; then
9166 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9167 – else
9168 –  if test -n "$AR"; then
9169 –  ac_cv_prog_AR="$AR" # Let the user override the test.
9170 – else
9171 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9172 – for as_dir in $PATH
9173 – do
9174 –  IFS=$as_save_IFS
9175 –  test -z "$as_dir" && as_dir=.
9176 –  for ac_exec_ext in '' $ac_executable_extensions; do
9177 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9178 –    ac_cv_prog_AR="ar"
9179 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9180 –    break 2
9181 –  fi
9182 – done
9183 – done
9184 –
9185 –  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13256   fi
9187 – fi
9188 – AR=$ac_cv_prog_AR
9189 – if test -n "$AR"; then
9190 –  echo "$as_me:$LINENO: result: $AR" >&5
9191 – echo "${ECHO_T}$AR" >&6
9192 – else
9193 –  echo "$as_me:$LINENO: result: no" >&5
9194 – echo "${ECHO_T}no" >&6
9195 – fi
13257  
9197 – if test "$AR" = "NONE"; then
9198 –  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9199 – echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9200 –   { (exit 1); exit 1; }; }
9201 –  cat >confcache <<\_ACEOF
9202 – # This file is a shell script that caches the results of configure
9203 – # tests run on this system so they can be shared between configure
9204 – # scripts and configure runs, see configure's option --config-cache.
9205 – # It is not useful on other systems.  If it contains results you don't
9206 – # want to keep, you may remove or edit it.
9207 – #
9208 – # config.status only pays attention to the cache file if you give it
9209 – # the --recheck option to rerun configure.
9210 – #
9211 – # `ac_cv_env_foo' variables (set or unset) will be overridden when
9212 – # loading this file, other *unset* `ac_cv_foo' will be assigned the
9213 – # following values.
13258  
9215 – _ACEOF
9216 –
9217 – # The following way of writing the cache mishandles newlines in values,
9218 – # but we know of no workaround that is simple, portable, and efficient.
9219 – # So, don't put newlines in cache variables' values.
9220 – # Ultrix sh set writes to stderr and can't be redirected directly,
9221 – # and sets the high bit in the cache file unless we assign to the vars.
9222 – {
9223 –  (set) 2>&1 |
9224 –    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9225 –    *ac_space=\ *)
9226 –      # `set' does not quote correctly, so add quotes (double-quote
9227 –      # substitution turns \\\\ into \\, and sed turns \\ into \).
9228 –      sed -n \
9229 –        "s/'/'\\\\''/g;
9230 –          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9231 –      ;;
9232 –    *)
9233 –      # `set' quotes correctly as required by POSIX, so do not add quotes.
9234 –      sed -n \
9235 –        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9236 –      ;;
9237 –    esac;
9238 – } |
9239 –  sed '
9240 –     t clear
9241 –     : clear
9242 –     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9243 –     t end
9244 –     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9245 –     : end' >>confcache
9246 – if diff $cache_file confcache >/dev/null 2>&1; then :; else
9247 –  if test -w $cache_file; then
9248 –    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9249 –    cat confcache >$cache_file
9250 –  else
9251 –    echo "not updating unwritable cache $cache_file"
9252 –  fi
13259   fi
9254 – rm -f confcache
9255 –  exit 1
9256 – fi
13260  
13261 < # Extract the first word of "ps", so it can be a program name with args.
9259 < set dummy ps; ac_word=$2
9260 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9261 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9262 < if test "${ac_cv_path_PS+set}" = set; then
9263 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9264 < else
9265 <  case $PS in
9266 <  [\\/]* | ?:[\\/]*)
9267 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
9268 <  ;;
9269 <  *)
9270 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9271 < for as_dir in $PATH
9272 < do
9273 <  IFS=$as_save_IFS
9274 <  test -z "$as_dir" && as_dir=.
9275 <  for ac_exec_ext in '' $ac_executable_extensions; do
9276 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9277 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9278 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9279 <    break 2
9280 <  fi
9281 < done
9282 < done
9283 <
9284 <  ;;
13261 >     ;;
13262   esac
9286 – fi
9287 – PS=$ac_cv_path_PS
13263  
9289 – if test -n "$PS"; then
9290 –  echo "$as_me:$LINENO: result: $PS" >&5
9291 – echo "${ECHO_T}$PS" >&6
9292 – else
9293 –  echo "$as_me:$LINENO: result: no" >&5
9294 – echo "${ECHO_T}no" >&6
9295 – fi
13264  
9297 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9298 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9299 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
9300 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9301 – else
9302 –
9303 –        if $PS ax -o rss > /dev/null 2>&1; then
9304 –                ac_cv_prog_ps_ax=yes
9305 –        else
9306 –                ac_cv_prog_ps_ax=no
9307 –        fi
9308 –        if $PS -ef -o rss > /dev/null 2>&1; then
9309 –                ac_cv_prog_ps_ef=yes
9310 –        else
9311 –                ac_cv_prog_ps_ef=no
9312 –        fi
9313 –        if test "$ac_cv_prog_ps_ax" = yes; then
9314 –                ac_cv_prog_ps_syntax=BSD
9315 –        else
9316 –                if test "$ac_cv_prog_ps_ef" = yes; then
9317 –                        ac_cv_prog_ps_syntax=POSIX
9318 –                else
9319 –                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9320 – echo "$as_me: error: Could not determine ps syntax" >&2;}
9321 –   { (exit 1); exit 1; }; }
9322 –                fi
9323 –        fi
9324 –
9325 – fi
9326 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9327 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9328 –
9329 –
9330 – cat >>confdefs.h <<_ACEOF
9331 – #define PSCOMMAND $PS
9332 – _ACEOF
9333 –
9334 –
13265   cat >>confdefs.h <<\_ACEOF
13266   #define OBAPI
13267   _ACEOF
13268  
9339 –
9340 –
9341 – if test "$ac_cv_prog_ps_syntax" = BSD; then
9342 –  cat >>confdefs.h <<\_ACEOF
9343 – #define PSTYPE_IS_BSD 1
9344 – _ACEOF
9345 –
9346 – else
9347 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
9348 –       cat >>confdefs.h <<\_ACEOF
9349 – #define PSTYPE_IS_POSIX 1
9350 – _ACEOF
13269  
9352 –   else
9353 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9354 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
9355 –   { (exit 1); exit 1; }; }
9356 –   fi
9357 – fi
13270  
13271  
13272   # Check whether --with-mpi or --without-mpi was given.
# Line 9412 | Line 13324 | cat >conftest.f90 <<EOF
13324   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13325   have_mpif_h=0
13326   rm -f conftest*
13327 < cat >conftest.f90 <<EOF
13327 > cat >conftest.$ac_ext <<EOF
13328   program main
13329     include 'mpif.h'
13330   end
13331   EOF
13332 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13332 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13333          echo "$as_me:$LINENO: result: yes" >&5
13334   echo "${ECHO_T}yes" >&6
13335          MPI_F90_INC="$MPI_INC_DIR"
# Line 9471 | Line 13383 | int
13383   /* We use char because int might match the return type of a gcc2
13384     builtin and then its argument prototype would still apply.  */
13385   char MPI_Init ();
13386 + #ifdef FC_DUMMY_MAIN
13387 + #ifndef FC_DUMMY_MAIN_EQ_F77
13388 + #  ifdef __cplusplus
13389 +     extern "C"
13390 + #  endif
13391 +   int FC_DUMMY_MAIN() { return 1; }
13392 + #endif
13393 + #endif
13394   int
13395   main ()
13396   {
# Line 9541 | Line 13461 | int
13461   /* We use char because int might match the return type of a gcc2
13462     builtin and then its argument prototype would still apply.  */
13463   char MPI_Init ();
13464 + #ifdef FC_DUMMY_MAIN
13465 + #ifndef FC_DUMMY_MAIN_EQ_F77
13466 + #  ifdef __cplusplus
13467 +     extern "C"
13468 + #  endif
13469 +   int FC_DUMMY_MAIN() { return 1; }
13470 + #endif
13471 + #endif
13472   int
13473   main ()
13474   {
# Line 9612 | Line 13540 | int
13540   /* We use char because int might match the return type of a gcc2
13541     builtin and then its argument prototype would still apply.  */
13542   char MPI_Init ();
13543 + #ifdef FC_DUMMY_MAIN
13544 + #ifndef FC_DUMMY_MAIN_EQ_F77
13545 + #  ifdef __cplusplus
13546 +     extern "C"
13547 + #  endif
13548 +   int FC_DUMMY_MAIN() { return 1; }
13549 + #endif
13550 + #endif
13551   int
13552   main ()
13553   {
# Line 9683 | Line 13619 | int
13619   /* We use char because int might match the return type of a gcc2
13620     builtin and then its argument prototype would still apply.  */
13621   char MPI_Init ();
13622 + #ifdef FC_DUMMY_MAIN
13623 + #ifndef FC_DUMMY_MAIN_EQ_F77
13624 + #  ifdef __cplusplus
13625 +     extern "C"
13626 + #  endif
13627 +   int FC_DUMMY_MAIN() { return 1; }
13628 + #endif
13629 + #endif
13630   int
13631   main ()
13632   {
# Line 9727 | Line 13671 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
13671   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13672   echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13673   if test $ac_cv_lib_mpich_MPI_Init = yes; then
13674 <  MPI_LIB="-lmpich -lpmpich"
13674 >  MPI_LIB="-lpmpich -lmpich"
13675   fi
13676  
13677   fi
# Line 9755 | Line 13699 | int
13699   /* We use char because int might match the return type of a gcc2
13700     builtin and then its argument prototype would still apply.  */
13701   char MPI_Init ();
13702 + #ifdef FC_DUMMY_MAIN
13703 + #ifndef FC_DUMMY_MAIN_EQ_F77
13704 + #  ifdef __cplusplus
13705 +     extern "C"
13706 + #  endif
13707 +   int FC_DUMMY_MAIN() { return 1; }
13708 + #endif
13709 + #endif
13710   int
13711   main ()
13712   {
# Line 10173 | Line 14125 | int
14125   cat >>conftest.$ac_ext <<_ACEOF
14126   /* end confdefs.h.  */
14127   #include <CGAL/Cartesian.h>
14128 + #ifdef FC_DUMMY_MAIN
14129 + #ifndef FC_DUMMY_MAIN_EQ_F77
14130 + #  ifdef __cplusplus
14131 +     extern "C"
14132 + #  endif
14133 +   int FC_DUMMY_MAIN() { return 1; }
14134 + #endif
14135 + #endif
14136   int
14137   main ()
14138   {
# Line 10413 | Line 14373 | fi
14373   else
14374          enable_dot=yes
14375   fi
10416 –
10417 –
10418 –
10419 –
10420 –
10421 –
10422 –
10423 – OBJEXT=".$OBJEXT"
10424 –
10425 – OOPSE=oopse
10426 –
10427 – if test "x${prefix}" = "xNONE"
10428 – then
10429 –  OOPSE_HOME=${ac_default_prefix}/oopse
10430 – else
10431 –  OOPSE_HOME=${prefix}/oopse
10432 – fi
10433 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
10434 – if test "${enable_oopse_home+set}" = set; then
10435 –  enableval="$enable_oopse_home"
10436 –  OOPSE_HOME="${enableval}"
10437 – fi;
10438 –
10439 – case "x$INSTALL" in
10440 –   x/*) ;;
10441 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10442 – esac
10443 –
10444 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
10445 –
10446 – CFLAGS=${CFLAGS-""}
10447 – CXXFLAGS=${CXXFLAGS-""}
10448 – CPPFLAGS=${CPPFLAGS-""}
10449 – FFLAGS=${FFLAGS-""}
10450 – F90FLAGS=${F90FLAGS-""}
10451 – LDFLAGS=${LDFLAGS-""}
10452 – DEBUG=${DEBUG-"-g"}
10453 –
10454 – case $debug in
10455 –  1)
10456 –     FFLAGS="$DEBUG $FFLAGS"
10457 –     F90FLAGS="$DEBUG $F90FLAGS"
10458 –     ;;
10459 –  *)
10460 –     ;;
10461 – esac
14376  
14377  
14378  
# Line 10477 | Line 14391 | esac
14391  
14392  
14393  
10480 –          ac_config_headers="$ac_config_headers src/config.h"
14394  
14395                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396  
# Line 10844 | Line 14757 | This file was extended by OOPSE $as_me 2.0, which was
14757   } >&5
14758   cat >&5 <<_CSEOF
14759  
14760 < This file was extended by OOPSE $as_me 2.0, which was
14760 > This file was extended by OOPSE $as_me 3.0, which was
14761   generated by GNU Autoconf 2.59.  Invocation command line was
14762  
14763    CONFIG_FILES    = $CONFIG_FILES
# Line 10907 | Line 14820 | OOPSE config.status 2.0
14820  
14821   cat >>$CONFIG_STATUS <<_ACEOF
14822   ac_cs_version="\\
14823 < OOPSE config.status 2.0
14823 > OOPSE config.status 3.0
14824   configured by $0, generated by GNU Autoconf 2.59,
14825    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14826  
# Line 11101 | Line 15014 | s,@PROGNAME@,$PROGNAME,;t t
15014   s,@ECHO_N@,$ECHO_N,;t t
15015   s,@ECHO_T@,$ECHO_T,;t t
15016   s,@LIBS@,$LIBS,;t t
11104 – s,@PROGNAME@,$PROGNAME,;t t
11105 – s,@debug@,$debug,;t t
15017   s,@build@,$build,;t t
15018   s,@build_cpu@,$build_cpu,;t t
15019   s,@build_vendor@,$build_vendor,;t t
# Line 11111 | Line 15022 | s,@CC@,$CC,;t t
15022   s,@host_cpu@,$host_cpu,;t t
15023   s,@host_vendor@,$host_vendor,;t t
15024   s,@host_os@,$host_os,;t t
15025 < s,@CC@,$CC,;t t
15026 < s,@CFLAGS@,$CFLAGS,;t t
15025 > s,@PROGNAME@,$PROGNAME,;t t
15026 > s,@debug@,$debug,;t t
15027 > s,@CXX@,$CXX,;t t
15028 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15029   s,@LDFLAGS@,$LDFLAGS,;t t
15030   s,@CPPFLAGS@,$CPPFLAGS,;t t
15031 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15031 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032   s,@EXEEXT@,$EXEEXT,;t t
15033   s,@OBJEXT@,$OBJEXT,;t t
15034 < s,@CXX@,$CXX,;t t
15035 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15036 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15037 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15038 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15039 < s,@F90@,$F90,;t t
11127 < s,@F90FLAGS@,$F90FLAGS,;t t
11128 < s,@ac_ct_F90@,$ac_ct_F90,;t t
11129 < s,@PREPFLAG@,$PREPFLAG,;t t
11130 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11131 < s,@F90LIBS@,$F90LIBS,;t t
11132 < s,@F90_FUNC@,$F90_FUNC,;t t
11133 < s,@F90_FUNC_@,$F90_FUNC_,;t t
11134 < s,@MOD@,$MOD,;t t
11135 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11136 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11137 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11138 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15034 > s,@CC@,$CC,;t t
15035 > s,@CFLAGS@,$CFLAGS,;t t
15036 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15037 > s,@FC@,$FC,;t t
15038 > s,@FCFLAGS@,$FCFLAGS,;t t
15039 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15040   s,@CPP@,$CPP,;t t
15041   s,@EGREP@,$EGREP,;t t
11141 – s,@CXXCPP@,$CXXCPP,;t t
11142 – s,@LIBOBJS@,$LIBOBJS,;t t
11143 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11144 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11145 – s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15042   s,@LN_S@,$LN_S,;t t
15043   s,@SET_MAKE@,$SET_MAKE,;t t
15044   s,@RANLIB@,$RANLIB,;t t
15045   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11150 – s,@YACC@,$YACC,;t t
11151 – s,@LEX@,$LEX,;t t
11152 – s,@LEXLIB@,$LEXLIB,;t t
11153 – s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046   s,@PERLINTERP@,$PERLINTERP,;t t
15047   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051   s,@AR@,$AR,;t t
15052   s,@PS@,$PS,;t t
15053 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056 + s,@FCLIBS@,$FCLIBS,;t t
15057 + s,@FC_FUNC@,$FC_FUNC,;t t
15058 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15059 + s,@MOD@,$MOD,;t t
15060 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064 + s,@LIBOBJS@,$LIBOBJS,;t t
15065 + s,@POW_LIB@,$POW_LIB,;t t
15066 + s,@CXXCPP@,$CXXCPP,;t t
15067 + s,@__func__@,$__func__,;t t
15068   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11179 | Line 15089 | s,@FFLAGS@,$FFLAGS,;t t
15089   s,@OOPSE@,$OOPSE,;t t
15090   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15091   s,@SUBDIRS@,$SUBDIRS,;t t
11182 – s,@FFLAGS@,$FFLAGS,;t t
15092   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093   CEOF
15094  

Diff Legend

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