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

Comparing trunk/configure (file contents):
Revision 566 by gezelter, Wed Jul 20 17:04:42 2005 UTC vs.
Revision 956 by gezelter, Tue May 16 02:06:37 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX 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 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 CXXCPP USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 – ac_env_CC_set=${CC+set}
757 – ac_env_CC_value=$CC
758 – ac_cv_env_CC_set=${CC+set}
759 – ac_cv_env_CC_value=$CC
760 – ac_env_CFLAGS_set=${CFLAGS+set}
761 – ac_env_CFLAGS_value=$CFLAGS
762 – ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 – ac_cv_env_CFLAGS_value=$CFLAGS
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_cv_env_CXXFLAGS_value=$CXXFLAGS
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 +  --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 997 | Line 1001 | if $ac_init_version; then
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1004 > OOPSE configure 3.0
1005   generated by GNU Autoconf 2.59
1006  
1007   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1011 | Line 1015 | running configure, to aid debugging if configure makes
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1018 > It was created by OOPSE $as_me 3.0, which was
1019   generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
# Line 1373 | 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 -*-
1377 < # Programming languages support.
1378 < # Copyright 2000, 2001
1379 < # Free Software Foundation, Inc.
1380 < #
1381 < # This program is free software; you can redistribute it and/or modify
1382 < # it under the terms of the GNU General Public License as published by
1383 < # the Free Software Foundation; either version 2, or (at your option)
1384 < # any later version.
1385 < #
1386 < # This program is distributed in the hope that it will be useful,
1387 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1388 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1389 < # GNU General Public License for more details.
1390 < #
1391 < # You should have received a copy of the GNU General Public License
1392 < # along with this program; if not, write to the Free Software
1393 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1394 < # 02111-1307, USA.
1395 < #
1396 < # As a special exception, the Free Software Foundation gives unlimited
1397 < # permission to copy, distribute and modify the configure scripts that
1398 < # are the output of Autoconf.  You need not follow the terms of the GNU
1399 < # General Public License when using or distributing such scripts, even
1400 < # though portions of the text of Autoconf appear in them.  The GNU
1401 < # General Public License (GPL) does govern all other use of the material
1402 < # that constitutes the Autoconf program.
1403 < #
1404 < # Certain portions of the Autoconf source text are designed to be copied
1405 < # (in certain cases, depending on the input) into the output of
1406 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1407 < # source text consists of comments plus executable code that decides which
1408 < # of the data portions to output in any given case.  We call these
1409 < # comments and executable code the "non-data" portions.  Autoconf never
1410 < # copies any of the non-data portions into its output.
1411 < #
1412 < # This special exception to the GPL applies to versions of Autoconf
1413 < # released by the Free Software Foundation.  When you make and
1414 < # distribute a modified version of Autoconf, you may extend this special
1415 < # exception to the GPL to apply to your modified version as well, *unless*
1416 < # your modified version has the potential to copy into its output some
1417 < # of the text that was the non-data portion of the version that you started
1418 < # with.  (In other words, unless your change moves or copies text from
1419 < # the non-data portions to the data portions.)  If your modification has
1420 < # such potential, you must delete any notice of this special exception
1421 < # to the GPL from your modified version.
1422 < #
1423 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1424 < # many others).
1425 <
1426 <
1427 < # Table of Contents:
1428 < #
1429 < # 1. Language selection
1430 < #    and routines to produce programs in a given language.
1431 < #  a. Fortran 77 (to be moved from aclang.m4)
1432 < #  b. Fortran 90
1433 < #  c. Fortran 95
1434 < #
1435 < # 2. Producing programs in a given language.
1436 < #  a. Fortran 77 (to be moved from aclang.m4)
1437 < #  b. Fortran 90
1438 < #  c. Fortran 95
1439 < #
1440 < # 3. Looking for a compiler
1441 < #    And possibly the associated preprocessor.
1442 < #  a. Fortran 77 (to be moved from aclang.m4)
1443 < #  b. Fortran 90
1444 < #  c. Fortran 95
1445 < #
1446 < # 4. Compilers' characteristics.
1447 < #  a. Fortran 77 (to be moved from aclang.m4)
1448 < #  b. Fortran 90
1449 < #  c. Fortran 95
1450 <
1451 < # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1452 < # ---------------------------------------------------------------------------
1453 < #
1454 < # Processing the elements of a list is tedious in shell programming,
1455 < # as lists tend to be implemented as space delimited strings.
1456 < #
1457 < # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1458 < # if ELEMENT is a member of LIST, otherwise it executes
1459 < # ACTION-IF-NOT-FOUND.
1460 < # _AC_LIST_MEMBER_IF
1461 <
1462 <
1463 <
1464 < # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1465 < # -------------------------------------------------
1466 < #
1467 < # Specifying options to the compiler (whether it be the C, C++ or
1468 < # Fortran 77 compiler) that are meant for the linker is compiler
1469 < # dependent.  This macro lets you give options to the compiler that
1470 < # are meant for the linker in a portable, compiler-independent way.
1471 < #
1472 < # This macro take two arguments, a list of linker options that the
1473 < # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1474 < # a shell variable (SHELL-VARIABLE).  The list of linker options are
1475 < # appended to the shell variable in a compiler-dependent way.
1476 < #
1477 < # For example, if the selected language is C, then this:
1478 < #
1479 < #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1480 < #
1481 < # will expand into this if the selected C compiler is gcc:
1482 < #
1483 < #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1484 < #
1485 < # otherwise, it will expand into this:
1486 < #
1487 < #   foo_LDFLAGS"-R /usr/local/lib/foo"
1488 < #
1489 < # You are encouraged to add support for compilers that this macro
1490 < # doesn't currently support.
1491 < # FIXME: Get rid of this macro.
1492 < # _AC_LINKER_OPTION
1493 <
1494 <
1495 <
1496 < ## ----------------------- ##
1497 < ## 1. Language selection.  ##
1498 < ## ----------------------- ##
1499 <
1500 < # ----------------------------- #
1501 < # 1b. The Fortran 90 language.  #
1502 < # ----------------------------- #
1503 <
1504 < # AC_LANG(Fortran 90)
1505 < # -------------------
1506 <
1507 <
1508 <
1509 < # _AC_LANG_ABBREV(Fortran 90)
1510 < # ---------------------------
1511 <
1512 <
1513 <
1514 < # ----------------------------- #
1515 < # 1c. The Fortran 95 language.  #
1516 < # ----------------------------- #
1517 <
1518 < # AC_LANG(Fortran 95)
1519 < # -------------------
1520 <
1521 <
1522 <
1523 < # _AC_LANG_ABBREV(Fortran 95)
1524 < # ---------------------------
1525 <
1526 <
1527 <
1528 < ## ---------------------- ##
1529 < ## 2.Producing programs.  ##
1530 < ## ---------------------- ##
1531 <
1532 < # ------------------------ #
1533 < # 2b. Fortran 90 sources.  #
1534 < # ------------------------ #
1535 <
1536 < # AC_LANG_SOURCE(Fortran 90)(BODY)
1537 < # --------------------------------
1538 <
1539 <
1540 <
1541 < # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1542 < # -----------------------------------------------
1543 <
1544 <
1545 < # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1546 < # --------------------------------------------
1547 <
1548 <
1549 <
1550 < # ------------------------ #
1551 < # 2c. Fortran 95 sources.  #
1552 < # ------------------------ #
1553 <
1554 < # AC_LANG_SOURCE(Fortran 95)(BODY)
1555 < # --------------------------------
1556 <
1557 <
1558 < # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1559 < # -----------------------------------------------
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1382  
1562 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1563 – # --------------------------------------------
1383  
1384  
1385  
1567 – ## -------------------------------------------- ##
1568 – ## 3. Looking for Compilers and Preprocessors.  ##
1569 – ## -------------------------------------------- ##
1386  
1571 – # ----------------------------- #
1572 – # 3b. The Fortran 90 compiler.  #
1573 – # ----------------------------- #
1387  
1388  
1576 – # AC_LANG_PREPROC(Fortran 90)
1577 – # ---------------------------
1578 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1389  
1390  
1391  
1582 – # AC_LANG_COMPILER(Fortran 90)
1583 – # ----------------------------
1584 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1585 – # AC_REQUIRE'able.
1392  
1393  
1394  
1589 – # AC_PROG_F90([COMPILERS...])
1590 – # ---------------------------
1591 – # COMPILERS is a space separated list of Fortran 90 compilers to search
1592 – # for.
1593 – #
1594 – # Compilers are ordered by
1595 – #  1. F90, F95
1596 – #  2. Good/tested native compilers, bad/untested native compilers
1597 – #
1598 – # pgf90 is the Portland Group F90 compilers.
1599 – # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1600 – # lf95 is the Lahey-Fujitsu compiler.
1601 – # epcf90 is the "Edinburgh Portable Compiler" F90.
1602 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1603 – # AC_PROG_F90
1395  
1396  
1606 – # ----------------------------- #
1607 – # 3c. The Fortran 95 compiler.  #
1608 – # ----------------------------- #
1397  
1398  
1611 – # AC_LANG_PREPROC(Fortran 95)
1612 – # ---------------------------
1613 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1399  
1400  
1401  
1617 – # AC_LANG_COMPILER(Fortran 95)
1618 – # ----------------------------
1619 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1620 – # AC_REQUIRE'able.
1402  
1403  
1404  
1624 – # AC_PROG_F95([COMPILERS...])
1625 – # ---------------------------
1626 – # COMPILERS is a space separated list of Fortran 95 compilers to search
1627 – # for.
1628 – #
1629 – # Compilers are ordered by
1630 – #  1. Good/tested native compilers, bad/untested native compilers
1631 – #
1632 – # xlf95 is the IBM (AIX) F95 compiler.
1633 – # lf95 is the Lahey-Fujitsu compiler.
1634 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1635 – # AC_PROG_F95
1405  
1406  
1638 – ## ------------------------------- ##
1639 – ## 4. Compilers' characteristics.  ##
1640 – ## ------------------------------- ##
1407  
1408  
1643 – # ---------------------------------------- #
1644 – # 4b. Fortan 90 compiler characteristics.  #
1645 – # ---------------------------------------- #
1409  
1410  
1648 – # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1649 – # -------------------------------------------------
1650 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1651 – # (which default value, $ac_cv_prog_f90_v, is computed by
1652 – # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1653 – # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1654 – # so that any link flags that are echoed by the compiler appear as
1655 – # space-separated items.
1656 – # _AC_PROG_F90_V_OUTPUT
1411  
1412  
1659 – # _AC_PROG_F90_V
1660 – # --------------
1661 – #
1662 – # Determine the flag that causes the Fortran 90 compiler to print
1663 – # information of library and object files (normally -v)
1664 – # Needed for AC_F90_LIBRARY_FLAGS
1665 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1666 – # _AC_PROG_F90_V
1413  
1414  
1669 – # AC_F90_LIBRARY_LDFLAGS
1670 – # ----------------------
1671 – #
1672 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1673 – # intrinsic and run-time libraries that are required to successfully
1674 – # link a Fortran 90 program or shared library.  The output variable
1675 – # F90LIBS is set to these flags.
1676 – #
1677 – # This macro is intended to be used in those situations when it is
1678 – # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1679 – # program or shared library.
1680 – #
1681 – # For example, if object files from a C++ and Fortran 90 compiler must
1682 – # be linked together, then the C++ compiler/linker must be used for
1683 – # linking (since special C++-ish things need to happen at link time
1684 – # like calling global constructors, instantiating templates, enabling
1685 – # exception support, etc.).
1686 – #
1687 – # However, the Fortran 90 intrinsic and run-time libraries must be
1688 – # linked in as well, but the C++ compiler/linker doesn't know how to
1689 – # add these Fortran 90 libraries.  Hence, the macro
1690 – # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1691 – # libraries.
1692 – #
1693 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1694 – # AC_F90_LIBRARY_LDFLAGS
1415  
1416  
1417 < # _AC_F90_NAME_MANGLING
1418 < # ---------------------
1419 < # Test for the name mangling scheme used by the Fortran 90 compiler.
1420 < #
1421 < # Sets ac_cv_f90_mangling. The value contains three fields, separated
1422 < # by commas:
1423 < #
1704 < # lower case / upper case:
1705 < #    case translation of the Fortan 90 symbols
1706 < # underscore / no underscore:
1707 < #    whether the compiler appends "_" to symbol names
1708 < # extra underscore / no extra underscore:
1709 < #    whether the compiler appends an extra "_" to symbol names already
1710 < #    containing at least one underscore
1711 < #
1712 < # _AC_F90_NAME_MANGLING
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  
1714 – # The replacement is empty.
1425  
1426  
1427  
1718 – # AC_F90_WRAPPERS
1719 – # ---------------
1720 – # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1721 – # properly mangle the names of C identifiers, and C identifiers with
1722 – # underscores, respectively, so that they match the name mangling
1723 – # scheme used by the Fortran 90 compiler.
1724 – # AC_F90_WRAPPERS
1428  
1429  
1727 – # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1728 – # ------------------------------------
1729 – # For a Fortran subroutine of given NAME, define a shell variable
1730 – # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1731 – # argument is not supplied, it defaults to NAME.
1732 – # AC_F90_FUNC
1430  
1431  
1735 – # ---------------------------------------- #
1736 – # 4c. Fortan 95 compiler characteristics.  #
1737 – # ---------------------------------------- #
1432  
1433  
1740 – # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1741 – # -------------------------------------------------
1742 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1743 – # (which default value, $ac_cv_prog_f95_v, is computed by
1744 – # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1745 – # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1746 – # so that any link flags that are echoed by the compiler appear as
1747 – # space-separated items.
1748 – # _AC_PROG_F95_V_OUTPUT
1434  
1435  
1751 – # _AC_PROG_F95_V
1752 – # --------------
1436   #
1754 – # Determine the flag that causes the Fortran 95 compiler to print
1755 – # information of library and object files (normally -v)
1756 – # Needed for AC_F95_LIBRARY_FLAGS
1757 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1758 – # _AC_PROG_F95_V
1759 –
1760 –
1761 – # AC_F95_LIBRARY_LDFLAGS
1762 – # ----------------------
1437   #
1764 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1765 – # intrinsic and run-time libraries that are required to successfully
1766 – # link a Fortran 95 program or shared library.  The output variable
1767 – # F95LIBS is set to these flags.
1438   #
1769 – # This macro is intended to be used in those situations when it is
1770 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1771 – # program or shared library.
1772 – #
1773 – # For example, if object files from a C++ and Fortran 95 compiler must
1774 – # be linked together, then the C++ compiler/linker must be used for
1775 – # linking (since special C++-ish things need to happen at link time
1776 – # like calling global constructors, instantiating templates, enabling
1777 – # exception support, etc.).
1778 – #
1779 – # However, the Fortran 95 intrinsic and run-time libraries must be
1780 – # linked in as well, but the C++ compiler/linker doesn't know how to
1781 – # add these Fortran 95 libraries.  Hence, the macro
1782 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1783 – # libraries.
1784 – #
1785 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1786 – # AC_F95_LIBRARY_LDFLAGS
1439  
1440  
1789 – # _AC_F95_NAME_MANGLING
1790 – # ---------------------
1791 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1792 – #
1793 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1794 – # by commas:
1795 – #
1796 – # lower case / upper case:
1797 – #    case translation of the Fortan 95 symbols
1798 – # underscore / no underscore:
1799 – #    whether the compiler appends "_" to symbol names
1800 – # extra underscore / no extra underscore:
1801 – #    whether the compiler appends an extra "_" to symbol names already
1802 – #    containing at least one underscore
1803 – #
1804 – # _AC_F95_NAME_MANGLING
1805 –
1806 – # The replacement is empty.
1807 –
1808 –
1809 –
1810 – # AC_F95_WRAPPERS
1811 – # ---------------
1812 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1813 – # properly mangle the names of C identifiers, and C identifiers with
1814 – # underscores, respectively, so that they match the name mangling
1815 – # scheme used by the Fortran 95 compiler.
1816 – # AC_F95_WRAPPERS
1817 –
1818 –
1819 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1820 – # ------------------------------------
1821 – # For a Fortran subroutine of given NAME, define a shell variable
1822 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1823 – # argument is not supplied, it defaults to NAME.
1824 – # AC_F95_FUNC
1825 –
1441   # AC_F90_MODULE_NAMES
1442   # -------------------
1443   #
# Line 1865 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480  
1481  
1482  
1868 –
1869 –
1870 –
1871 –
1872 –
1873 –
1874 –
1875 –
1876 –
1877 –
1878 –
1879 –
1880 –
1881 –
1882 –
1883 –
1884 –
1885 – #
1886 – #
1887 – #
1888 –
1889 –
1890 –
1891 –
1892 –
1893 –
1894 – # set program name
1895 – PROGNAME="oopse"
1896 –
1897 –
1898 – # there are two ways to do debugging.  One with the --enable-debug flag
1899 – # and one using the DEBUG environment variable
1900 –
1901 – debug=0
1902 – # Check whether --enable-debug or --disable-debug was given.
1903 – if test "${enable_debug+set}" = set; then
1904 –  enableval="$enable_debug"
1905 –  debug=1
1906 – fi;
1907 – if test "${DEBUG}"; then
1908 –
1909 – cat >>confdefs.h <<\_ACEOF
1910 – #define debug 1
1911 – _ACEOF
1912 –
1913 –  msg="$msg, debug mode"
1914 – fi
1915 –
1916 –
1483   # who am i
1484   # Make sure we can run config.sub.
1485   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1972 | Line 1538 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1538  
1539  
1540  
1541 < ac_ext=c
1542 < ac_cpp='$CPP $CPPFLAGS'
1543 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1544 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1545 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1541 > # set program name
1542 > PROGNAME="oopse"
1543 >
1544 >
1545 >
1546 >
1547 > OBJEXT=".$OBJEXT"
1548 >
1549 > OOPSE=oopse
1550 >
1551 > if test "x${prefix}" = "xNONE"
1552 > then
1553 >  OOPSE_HOME=${ac_default_prefix}/oopse
1554 > else
1555 >  OOPSE_HOME=${prefix}/oopse
1556 > fi
1557 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1558 > if test "${enable_oopse_home+set}" = set; then
1559 >  enableval="$enable_oopse_home"
1560 >  OOPSE_HOME="${enableval}"
1561 > fi;
1562 >
1563 > # there are two ways to do debugging.  One with the --enable-debug flag
1564 > # and one using the DEBUG environment variable
1565 >
1566 > debug=0
1567 > # Check whether --enable-debug or --disable-debug was given.
1568 > if test "${enable_debug+set}" = set; then
1569 >  enableval="$enable_debug"
1570 >  debug=1
1571 > fi;
1572 > if test "${DEBUG}"; then
1573 >
1574 > cat >>confdefs.h <<\_ACEOF
1575 > #define debug 1
1576 > _ACEOF
1577 >
1578 >  msg="$msg, debug mode"
1579 > fi
1580 >
1581 >
1582 > # Checks for programs.
1583 > ac_ext=cc
1584 > ac_cpp='$CXXCPP $CPPFLAGS'
1585 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1586 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1587 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1588   if test -n "$ac_tool_prefix"; then
1589 <  for ac_prog in 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 1997 | 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 2006 | Line 1614 | fi
1614  
1615   fi
1616   fi
1617 < CC=$ac_cv_prog_CC
1618 < if test -n "$CC"; then
1619 <  echo "$as_me:$LINENO: result: $CC" >&5
1620 < echo "${ECHO_T}$CC" >&6
1617 > CXX=$ac_cv_prog_CXX
1618 > if test -n "$CXX"; then
1619 >  echo "$as_me:$LINENO: result: $CXX" >&5
1620 > echo "${ECHO_T}$CXX" >&6
1621   else
1622    echo "$as_me:$LINENO: result: no" >&5
1623   echo "${ECHO_T}no" >&6
1624   fi
1625  
1626 <    test -n "$CC" && break
1626 >    test -n "$CXX" && break
1627    done
1628   fi
1629 < if test -z "$CC"; then
1630 <  ac_ct_CC=$CC
1631 <  for ac_prog in 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 2039 | 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 2048 | Line 1656 | fi
1656  
1657   fi
1658   fi
1659 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1660 < if test -n "$ac_ct_CC"; then
1661 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1662 < echo "${ECHO_T}$ac_ct_CC" >&6
1659 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1660 > if test -n "$ac_ct_CXX"; then
1661 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1662 > echo "${ECHO_T}$ac_ct_CXX" >&6
1663   else
1664    echo "$as_me:$LINENO: result: no" >&5
1665   echo "${ECHO_T}no" >&6
1666   fi
1667  
1668 <  test -n "$ac_ct_CC" && break
1668 >  test -n "$ac_ct_CXX" && break
1669   done
1670 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1671  
1672 <  CC=$ac_ct_CC
1672 >  CXX=$ac_ct_CXX
1673   fi
1674  
1675  
2067 – test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2068 – See \`config.log' for more details." >&5
2069 – echo "$as_me: error: no acceptable C compiler found in \$PATH
2070 – See \`config.log' for more details." >&2;}
2071 –   { (exit 1); exit 1; }; }
2072 –
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 2110 | Line 1713 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1713   # Try to create an executable without -o first, disregard a.out.
1714   # It will help us diagnose broken compilers, and finding out an intuition
1715   # of exeext.
1716 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1717 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1716 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1717 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1718   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1719   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1720    (eval $ac_link_default) 2>&5
# Line 2154 | 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 2167 | Line 1770 | echo "${ECHO_T}$ac_file" >&6
1770  
1771   # Check the compiler produces executables we can run.  If not, either
1772   # the compiler is broken, or we cross compile.
1773 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1774 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1773 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1774 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1775   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1776   # If not cross compiling, check that we can run a simple program.
1777   if test "$cross_compiling" != yes; then
# Line 2183 | 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 2291 | Line 1894 | ac_objext=$OBJEXT
1894   echo "${ECHO_T}$ac_cv_objext" >&6
1895   OBJEXT=$ac_cv_objext
1896   ac_objext=$OBJEXT
1897 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1898 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1899 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1897 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1898 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1899 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1900    echo $ECHO_N "(cached) $ECHO_C" >&6
1901   else
1902    cat >conftest.$ac_ext <<_ACEOF
# Line 2323 | 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 2344 | Line 1947 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
1947   ac_compiler_gnu=no
1948   fi
1949   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1950 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
1950 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1951  
1952   fi
1953 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1954 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1955 < GCC=`test $ac_compiler_gnu = yes && echo yes`
1956 < ac_test_CFLAGS=${CFLAGS+set}
1957 < ac_save_CFLAGS=$CFLAGS
1958 < CFLAGS="-g"
1959 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1960 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1961 < if test "${ac_cv_prog_cc_g+set}" = set; then
1953 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1954 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1955 > GXX=`test $ac_compiler_gnu = yes && echo yes`
1956 > ac_test_CXXFLAGS=${CXXFLAGS+set}
1957 > ac_save_CXXFLAGS=$CXXFLAGS
1958 > CXXFLAGS="-g"
1959 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1960 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1961 > if test "${ac_cv_prog_cxx_g+set}" = set; then
1962    echo $ECHO_N "(cached) $ECHO_C" >&6
1963   else
1964    cat >conftest.$ac_ext <<_ACEOF
# Line 2382 | 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 2395 | 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
2425 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2426 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2427 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2428 < else
2429 <  ac_cv_prog_cc_stdc=no
2430 < ac_save_CC=$CC
2431 < cat >conftest.$ac_ext <<_ACEOF
2432 < /* confdefs.h.  */
2433 < _ACEOF
2434 < cat confdefs.h >>conftest.$ac_ext
2435 < cat >>conftest.$ac_ext <<_ACEOF
2436 < /* end confdefs.h.  */
2437 < #include <stdarg.h>
2438 < #include <stdio.h>
2439 < #include <sys/types.h>
2440 < #include <sys/stat.h>
2441 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2442 < struct buf { int x; };
2443 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2444 < static char *e (p, i)
2445 <     char **p;
2446 <     int i;
2447 < {
2448 <  return p[i];
2449 < }
2450 < static char *f (char * (*g) (char **, int), char **p, ...)
2451 < {
2452 <  char *s;
2453 <  va_list v;
2454 <  va_start (v,p);
2455 <  s = g (p, va_arg (v,int));
2456 <  va_end (v);
2457 <  return s;
2458 < }
2459 <
2460 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2461 <   function prototypes and stuff, but not '\xHH' hex character constants.
2462 <   These don't provoke an error unfortunately, instead are silently treated
2463 <   as 'x'.  The following induces an error, until -std1 is added to get
2464 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2465 <   array size at least.  It's necessary to write '\x00'==0 to get something
2466 <   that's true only with -std1.  */
2467 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2468 <
2469 < int test (int i, double x);
2470 < struct s1 {int (*f) (int a);};
2471 < struct s2 {int (*f) (double a);};
2472 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2473 < int argc;
2474 < char **argv;
2475 < int
2476 < main ()
2477 < {
2478 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2479 <  ;
2480 <  return 0;
2481 < }
2482 < _ACEOF
2483 < # Don't try gcc -ansi; that turns off useful extensions and
2484 < # breaks some systems' header files.
2485 < # AIX                   -qlanglvl=ansi
2486 < # Ultrix and OSF/1      -std1
2487 < # HP-UX 10.20 and later -Ae
2488 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2489 < # SVR4                  -Xc -D__EXTENSIONS__
2490 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2491 < do
2492 <  CC="$ac_save_CC $ac_arg"
2493 <  rm -f conftest.$ac_objext
2494 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2495 <  (eval $ac_compile) 2>conftest.er1
2496 <  ac_status=$?
2497 <  grep -v '^ *+' conftest.er1 >conftest.err
2498 <  rm -f conftest.er1
2499 <  cat conftest.err >&5
2500 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2501 <  (exit $ac_status); } &&
2502 <         { ac_try='test -z "$ac_c_werror_flag"
2503 <                         || test ! -s conftest.err'
2504 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2505 <  (eval $ac_try) 2>&5
2506 <  ac_status=$?
2507 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2508 <  (exit $ac_status); }; } &&
2509 <         { ac_try='test -s conftest.$ac_objext'
2510 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2511 <  (eval $ac_try) 2>&5
2512 <  ac_status=$?
2513 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2514 <  (exit $ac_status); }; }; then
2515 <  ac_cv_prog_cc_stdc=$ac_arg
2516 < break
2517 < else
2518 <  echo "$as_me: failed program was:" >&5
2519 < sed 's/^/| /' conftest.$ac_ext >&5
2520 <
2521 < fi
2522 < rm -f conftest.err conftest.$ac_objext
2523 < done
2524 < rm -f conftest.$ac_ext conftest.$ac_objext
2525 < CC=$ac_save_CC
2526 <
2527 < fi
2528 <
2529 < case "x$ac_cv_prog_cc_stdc" in
2530 <  x|xno)
2531 <    echo "$as_me:$LINENO: result: none needed" >&5
2532 < echo "${ECHO_T}none needed" >&6 ;;
2533 <  *)
2534 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2535 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2536 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2537 < esac
2538 <
2539 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2540 < # in C++ we need to declare it.  In case someone uses the same compiler
2541 < # for both compiling C and C++ we need to have the C++ compiler decide
2542 < # the declaration of exit, since it's the most demanding environment.
2543 < cat >conftest.$ac_ext <<_ACEOF
2544 < #ifndef __cplusplus
2545 <  choke me
2546 < #endif
2547 < _ACEOF
2548 < rm -f conftest.$ac_objext
2549 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2550 <  (eval $ac_compile) 2>conftest.er1
2551 <  ac_status=$?
2552 <  grep -v '^ *+' conftest.er1 >conftest.err
2553 <  rm -f conftest.er1
2554 <  cat conftest.err >&5
2555 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2556 <  (exit $ac_status); } &&
2557 <         { ac_try='test -z "$ac_c_werror_flag"
2558 <                         || test ! -s conftest.err'
2559 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2560 <  (eval $ac_try) 2>&5
2561 <  ac_status=$?
2562 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2563 <  (exit $ac_status); }; } &&
2564 <         { ac_try='test -s conftest.$ac_objext'
2565 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2566 <  (eval $ac_try) 2>&5
2567 <  ac_status=$?
2568 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2569 <  (exit $ac_status); }; }; then
2570 <  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 2600 | 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 2645 | 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 2673 | Line 2130 | fi
2130    echo '#endif'             >>confdefs.h
2131   fi
2132  
2676 – else
2677 –  echo "$as_me: failed program was:" >&5
2678 – sed 's/^/| /' conftest.$ac_ext >&5
2679 –
2680 – fi
2681 – 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'
2693 < 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 2711 | 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 2720 | Line 2170 | fi
2170  
2171   fi
2172   fi
2173 < CXX=$ac_cv_prog_CXX
2174 < if test -n "$CXX"; then
2175 <  echo "$as_me:$LINENO: result: $CXX" >&5
2176 < echo "${ECHO_T}$CXX" >&6
2173 > CC=$ac_cv_prog_CC
2174 > if test -n "$CC"; then
2175 >  echo "$as_me:$LINENO: result: $CC" >&5
2176 > echo "${ECHO_T}$CC" >&6
2177   else
2178    echo "$as_me:$LINENO: result: no" >&5
2179   echo "${ECHO_T}no" >&6
2180   fi
2181  
2182 <    test -n "$CXX" && break
2182 >    test -n "$CC" && break
2183    done
2184   fi
2185 < if test -z "$CXX"; then
2186 <  ac_ct_CXX=$CXX
2187 <  for ac_prog in $CCC 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 2753 | 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 2762 | Line 2212 | fi
2212  
2213   fi
2214   fi
2215 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2216 < if test -n "$ac_ct_CXX"; then
2217 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2218 < echo "${ECHO_T}$ac_ct_CXX" >&6
2215 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2216 > if test -n "$ac_ct_CC"; then
2217 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2218 > echo "${ECHO_T}$ac_ct_CC" >&6
2219   else
2220    echo "$as_me:$LINENO: result: no" >&5
2221   echo "${ECHO_T}no" >&6
2222   fi
2223  
2224 <  test -n "$ac_ct_CXX" && break
2224 >  test -n "$ac_ct_CC" && break
2225   done
2776 – 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 2799 | Line 2254 | ac_compiler=`set X $ac_compile; echo $2`
2254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2255    (exit $ac_status); }
2256  
2257 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2258 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2259 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2257 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2258 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2259 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2260    echo $ECHO_N "(cached) $ECHO_C" >&6
2261   else
2262    cat >conftest.$ac_ext <<_ACEOF
# Line 2831 | 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 2852 | Line 2307 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2307   ac_compiler_gnu=no
2308   fi
2309   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2310 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2310 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2311  
2312   fi
2313 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2314 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2315 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2316 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2317 < ac_save_CXXFLAGS=$CXXFLAGS
2318 < CXXFLAGS="-g"
2319 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2320 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2321 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2313 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2314 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2315 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2316 > ac_test_CFLAGS=${CFLAGS+set}
2317 > ac_save_CFLAGS=$CFLAGS
2318 > CFLAGS="-g"
2319 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2320 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2321 > if test "${ac_cv_prog_cc_g+set}" = set; then
2322    echo $ECHO_N "(cached) $ECHO_C" >&6
2323   else
2324    cat >conftest.$ac_ext <<_ACEOF
# Line 2890 | 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 2903 | 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
2940 <  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
2410 < rm -f conftest.$ac_objext
2411 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2412 <  (eval $ac_compile) 2>conftest.er1
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_cxx_werror_flag"
2465 >         { ac_try='test -z "$ac_c_werror_flag"
2466 >                         || test ! -s conftest.err'
2467 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468 >  (eval $ac_try) 2>&5
2469 >  ac_status=$?
2470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471 >  (exit $ac_status); }; } &&
2472 >         { ac_try='test -s conftest.$ac_objext'
2473 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474 >  (eval $ac_try) 2>&5
2475 >  ac_status=$?
2476 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477 >  (exit $ac_status); }; }; then
2478 >  ac_cv_prog_cc_stdc=$ac_arg
2479 > break
2480 > else
2481 >  echo "$as_me: failed program was:" >&5
2482 > sed 's/^/| /' conftest.$ac_ext >&5
2483 >
2484 > fi
2485 > rm -f conftest.err conftest.$ac_objext
2486 > done
2487 > rm -f conftest.$ac_ext conftest.$ac_objext
2488 > CC=$ac_save_CC
2489 >
2490 > fi
2491 >
2492 > case "x$ac_cv_prog_cc_stdc" in
2493 >  x|xno)
2494 >    echo "$as_me:$LINENO: result: none needed" >&5
2495 > echo "${ECHO_T}none needed" >&6 ;;
2496 >  *)
2497 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2500 > esac
2501 >
2502 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2503 > # in C++ we need to declare it.  In case someone uses the same compiler
2504 > # for both compiling C and C++ we need to have the C++ compiler decide
2505 > # the declaration of exit, since it's the most demanding environment.
2506 > cat >conftest.$ac_ext <<_ACEOF
2507 > #ifndef __cplusplus
2508 >  choke me
2509 > #endif
2510 > _ACEOF
2511 > rm -f conftest.$ac_objext
2512 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513 >  (eval $ac_compile) 2>conftest.er1
2514 >  ac_status=$?
2515 >  grep -v '^ *+' conftest.er1 >conftest.err
2516 >  rm -f conftest.er1
2517 >  cat conftest.err >&5
2518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519 >  (exit $ac_status); } &&
2520 >         { ac_try='test -z "$ac_c_werror_flag"
2521 >                         || test ! -s conftest.err'
2522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2523 >  (eval $ac_try) 2>&5
2524 >  ac_status=$?
2525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2526 >  (exit $ac_status); }; } &&
2527 >         { ac_try='test -s conftest.$ac_objext'
2528 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2529 >  (eval $ac_try) 2>&5
2530 >  ac_status=$?
2531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532 >  (exit $ac_status); }; }; then
2533 >  for ac_declaration in \
2534 >   '' \
2535 >   'extern "C" void std::exit (int) throw (); using std::exit;' \
2536 >   'extern "C" void std::exit (int); using std::exit;' \
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 3007 | 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 3035 | Line 2636 | fi
2636    echo '#endif'             >>confdefs.h
2637   fi
2638  
2639 + else
2640 +  echo "$as_me: failed program was:" >&5
2641 + sed 's/^/| /' conftest.$ac_ext >&5
2642 +
2643 + fi
2644 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645   ac_ext=c
2646   ac_cpp='$CPP $CPPFLAGS'
2647   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650  
2651 <
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
3048 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3049 <  echo 'void f(){}' > conftest.cc
3050 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3051 <    echo "$as_me:$LINENO: result: yes" >&5
3052 < echo "${ECHO_T}yes" >&6
3053 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3054 <  else
3055 <    echo "$as_me:$LINENO: result: no" >&5
3056 < echo "${ECHO_T}no" >&6
3057 <  fi
3058 <  rm -f conftest*
3059 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3060 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3061 <  echo 'void f(){}' > conftest.cc
3062 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3063 <    echo "$as_me:$LINENO: result: yes" >&5
3064 < echo "${ECHO_T}yes" >&6
3065 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3066 <  else
3067 <    echo "$as_me:$LINENO: result: no" >&5
3068 < echo "${ECHO_T}no" >&6
3069 <  fi
3070 <  rm -f conftest*
3071 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3072 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3073 <  echo 'void f(){}' > conftest.cc
3074 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3075 <    echo "$as_me:$LINENO: result: yes" >&5
3076 < echo "${ECHO_T}yes" >&6
3077 <    OOPSE_TEMPLATE_FLAGS="-pto"
3078 <  else
3079 <    echo "$as_me:$LINENO: result: no" >&5
3080 < echo "${ECHO_T}no" >&6
3081 <  fi
3082 <  rm -f conftest*
3083 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3084 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3085 <  echo 'void f(){}' > conftest.cc
3086 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3087 <    echo "$as_me:$LINENO: result: yes" >&5
3088 < echo "${ECHO_T}yes" >&6
3089 <
3090 <
3091 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3092 <  else
3093 <    echo "$as_me:$LINENO: result: no" >&5
3094 < echo "${ECHO_T}no" >&6
3095 <  fi
3096 < fi
3097 <
3098 <
3099 <
3100 <
3101 < ac_ext=f90
3102 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3103 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3104 < 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 3122 | 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 3131 | Line 2681 | fi
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 3164 | 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 3173 | Line 2723 | fi
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 <
3203 < program main
3204 <
2773 >      program main
2774   #ifndef __GNUC__
2775         choke me
2776   #endif
2777  
2778 < end program main
3210 <
2778 >      end
2779   _ACEOF
2780   rm -f conftest.$ac_objext
2781   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3218 | 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 3239 | Line 2807 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
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 <
3256 <
3257 <
3258 <
3259 < # Try to determine native compiler flags that allow us to use F90 suffix
3260 < # for preprocessed f90 source.
3261 <
3262 < if test "$ac_test_PREPFLAG" != "set"; then
3263 <  PREPFLAG=""
3264 <  case "${host_cpu}-${host_os}" in
3265 <
3266 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3267 <                    PREPFLAG="-fpp1 "
3268 <                fi;;
3269 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3270 <                    PREPFLAG="-qsuffix=cpp=F90 "
3271 <                fi;;
3272 <  *darwin*)
3273 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3274 <                PREPFLAG="-qsuffix=cpp=F90 "
3275 <        fi;;
3276 <  esac
3277 <
3278 <  if test -z "$PREPFLAG"; then
3279 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3280 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3281 <        PREPFLAG=""
3282 <  fi
3283 <
3284 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3285 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3286 <
3287 <
3288 <  ac_ext=f90
3289 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3290 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3291 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3292 <
3293 <  ac_save_ext=$ac_ext
3294 <  ac_ext=F90
3295 <  ac_save_F90FLAGS=$F90FLAGS
3296 <
3297 <  if test "$PREPFLAG"; then
3298 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3299 < fi
3300 <
3301 <    cat >conftest.$ac_ext <<_ACEOF
3302 <
3303 <
3304 < program main
3305 <
3306 <  integer :: i
3307 <  i = 1
3308 <
3309 <
3310 < end program main
3311 <
2828 >      end
2829   _ACEOF
2830   rm -f conftest.$ac_objext
2831   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3319 | 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 3332 | 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
3359 < echo "${ECHO_T}no" >&6
3360 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3361 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3362 <   { (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
3372 <
3373 < if test "$ac_test_PREPDEFFLAG" != "set"; then
3374 <  PREPDEFFLAG=""
3375 <  case "${host_cpu}-${host_os}" in
3376 <
3377 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3378 <                    PREPDEFFLAG=" "
3379 <                fi;;
3380 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3381 <                    PREPDEFFLAG="-WF,"
3382 <                fi;;
3383 <  *darwin*)
3384 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3385 <                PREPDEFFLAG="-WF,"
3386 <        fi;;
3387 <  esac
3388 <
3389 <  if test -z "$PREPDEFFLAG"; then
3390 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3391 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3392 <        PREPDEFFLAG=" "
3393 <  fi
3394 <
3395 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3396 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3397 <
3398 <
3399 <  ac_ext=f90
3400 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3401 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3402 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3403 <
3404 <  ac_save_ext=$ac_ext
3405 <  ac_ext=F90
3406 <  ac_save_F90FLAGS=$F90FLAGS
3407 <
3408 <  if test "$PREPDEFFLAG"; then
3409 <  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
3443 <  (exit $ac_status); }; } &&
3444 <         { ac_try='test -s conftest.$ac_objext'
3445 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3446 <  (eval $ac_try) 2>&5
3447 <  ac_status=$?
3448 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3449 <  (exit $ac_status); }; }; then
3450 <  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
3477 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3478 <   { (exit 1); exit 1; }; }
3479 <  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  
3487 –
3488 –
3489 – ac_ext=f90
3490 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3491 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3492 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3493 – echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3494 – echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3495 – if test "${ac_cv_prog_f90_v+set}" = set; then
3496 –  echo $ECHO_N "(cached) $ECHO_C" >&6
3497 – else
3498 –
3499 – cat >conftest.$ac_ext <<_ACEOF
3500 –
3501 – program main
3502 –
3503 –
3504 – end program main
3505 –
3506 – _ACEOF
3507 – rm -f conftest.$ac_objext
3508 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3509 –  (eval $ac_compile) 2>conftest.er1
3510 –  ac_status=$?
3511 –  grep -v '^ *+' conftest.er1 >conftest.err
3512 –  rm -f conftest.er1
3513 –  cat conftest.err >&5
3514 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3515 –  (exit $ac_status); } &&
3516 –         { ac_try='test -z "$ac_f90_werror_flag"
3517 –                         || test ! -s conftest.err'
3518 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3519 –  (eval $ac_try) 2>&5
3520 –  ac_status=$?
3521 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3522 –  (exit $ac_status); }; } &&
3523 –         { ac_try='test -s conftest.$ac_objext'
3524 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3525 –  (eval $ac_try) 2>&5
3526 –  ac_status=$?
3527 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3528 –  (exit $ac_status); }; }; then
3529 –  ac_cv_prog_f90_v=
3530 – # Try some options frequently used verbose output
3531 – for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3532 –  ac_ext=f90
3533 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3534 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3535 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3536 –
3537 – cat >conftest.$ac_ext <<_ACEOF
3538 –
3539 – program main
3540 –
3541 –
3542 – end program main
3543 –
3544 – _ACEOF
3545 –
3546 – # Compile and link our simple test program by passing a flag (argument
3547 – # 1 to this macro) to the Fortran 90 compiler in order to get
3548 – # "verbose" output that we can then parse for the Fortran 90 linker
3549 – # flags.
3550 – ac_save_F90FLAGS=$F90FLAGS
3551 – F90FLAGS="$F90FLAGS $ac_verb"
3552 –
3553 – (eval echo $as_me:3553: \"$ac_link\") >&5
3554 – ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3555 – echo "$ac_f90_v_output" >&5
3556 – F90FLAGS=$ac_save_F90FLAGS
3557 –
3558 – rm -f conftest.*
3559 – ac_ext=f90
3560 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3561 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3562 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3563 –
3564 – # If we are using xlf then replace all the commas with spaces.
3565 – if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3566 –  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3200   fi
3568 –
3569 – # If we are using Cray Fortran then delete quotes.
3570 – # Use "\"" instead of '"' for font-lock-mode.
3571 – # FIXME: a more general fix for quoted arguments with spaces?
3572 – if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3573 –  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]*)
3579 <          ac_cv_prog_f90_v=$ac_verb
3580 <          break 2 ;;
3581 <     esac
3582 <  done
3583 < done
3584 < if test -z "$ac_cv_prog_f90_v"; then
3585 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3586 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3587 < 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
3591 <
3592 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3593 < echo "$as_me: WARNING: compilation failed" >&2;}
3207 >  echo "$as_me:$LINENO: result: no" >&5
3208 > echo "${ECHO_T}no" >&6
3209   fi
3595 – 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  
3616 – 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
3622 <
3623 < # Compile and link our simple test program by passing a flag (argument
3624 < # 1 to this macro) to the Fortran 90 compiler in order to get
3625 < # "verbose" output that we can then parse for the Fortran 90 linker
3626 < # flags.
3627 < ac_save_F90FLAGS=$F90FLAGS
3628 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3629 <
3630 < (eval echo $as_me:3630: \"$ac_link\") >&5
3631 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3632 < echo "$ac_f90_v_output" >&5
3633 < F90FLAGS=$ac_save_F90FLAGS
3634 <
3635 < rm -f conftest.*
3636 < ac_ext=f90
3637 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3638 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3639 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3640 <
3641 < # If we are using xlf then replace all the commas with spaces.
3642 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3643 <  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=
3297 <
3298 < # Save positional arguments (if any)
3299 < ac_save_positional="$@"
3300 <
3301 < set X $ac_f90_v_output
3302 < while test $# != 1; do
3303 <  shift
3304 <  ac_arg=$1
3305 <  case $ac_arg in
3306 <        [\\/]*.a | ?:[\\/]*.a)
3307 <            ac_exists=false
3308 <  for ac_i in $ac_cv_f90libs; do
3309 <    if test x"$ac_arg" = x"$ac_i"; then
3310 <      ac_exists=true
3311 <      break
3312 <    fi
3313 <  done
3314 <
3315 <  if test x"$ac_exists" = xtrue; then
3316 <  :
3317 < else
3318 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3319 < fi
3320 <
3321 <          ;;
3322 <        -bI:*)
3323 <            ac_exists=false
3324 <  for ac_i in $ac_cv_f90libs; do
3325 <    if test x"$ac_arg" = x"$ac_i"; then
3326 <      ac_exists=true
3327 <      break
3328 <    fi
3329 <  done
3330 <
3331 <  if test x"$ac_exists" = xtrue; then
3332 <  :
3333 < else
3334 <  if test "$ac_compiler_gnu" = yes; then
3335 <  for ac_link_opt in $ac_arg; do
3336 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
3337 <  done
3338 < else
3339 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3340 < fi
3341 < fi
3342 <
3343 <          ;;
3344 <          # Ignore these flags.
3345 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
3346 <          ;;
3347 <        -lkernel32)
3348 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3349 <          ;;
3350 <        -[LRuY])
3351 <          # These flags, when seen by themselves, take an argument.
3352 <          # We remove the space between option and argument and re-iterate
3353 <          # unless we find an empty arg or a new option (starting with -)
3354 <          case $2 in
3355 <             "" | -*);;
3356 <             *)
3357 <                ac_arg="$ac_arg$2"
3358 <
3359 <                shift; shift
3360 <                set X $ac_arg "$@"
3361 <                ;;
3362 <          esac
3363 <          ;;
3364 <        -YP,*)
3365 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
3366 <              ac_exists=false
3367 <  for ac_i in $ac_cv_f90libs; do
3368 <    if test x"$ac_j" = x"$ac_i"; then
3369 <      ac_exists=true
3370 <      break
3371 <    fi
3372 <  done
3373 <
3374 <  if test x"$ac_exists" = xtrue; then
3375 <  :
3376 < else
3377 <  ac_arg="$ac_arg $ac_j"
3378 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
3379 < fi
3380 <
3381 <          done
3382 <          ;;
3383 <        -[lLR]*)
3384 <            ac_exists=false
3385 <  for ac_i in $ac_cv_f90libs; do
3386 <    if test x"$ac_arg" = x"$ac_i"; then
3387 <      ac_exists=true
3388 <      break
3389 <    fi
3390 <  done
3391 <
3392 <  if test x"$ac_exists" = xtrue; then
3393 <  :
3394 < else
3395 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
3396 < fi
3397 <
3398 <          ;;
3399 <          # Ignore everything else.
3400 <  esac
3401 < done
3402 < # restore positional arguments
3403 < set X $ac_save_positional; shift
3404 <
3405 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
3406 < # then we insist that the "run path" must be an absolute path (i.e. it
3407 < # must begin with a "/").
3408 < case `(uname -sr) 2>/dev/null` in
3409 <   "SunOS 5"*)
3410 <      ac_ld_run_path=`echo $ac_f90_v_output |
3411 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
3412 <      test "x$ac_ld_run_path" != x &&
3413 <
3414 <        if test "$ac_compiler_gnu" = yes; then
3415 <  for ac_link_opt in $ac_ld_run_path; do
3416 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
3417 <  done
3418 < else
3419 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
3420 < fi
3421 <      ;;
3422 < esac
3423 < fi # test "x$F90LIBS" = "x"
3424 <
3425 < fi
3426 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
3427 < echo "${ECHO_T}$ac_cv_flibs" >&6
3428 < F90LIBS="$ac_cv_f90libs"
3429 <
3430 < ac_ext=f90
3431 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3432 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3433 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3434 <
3435 <
3436 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
3437 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
3438 < if test "${ac_cv_f90_mangling+set}" = set; then
3439 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3440 < else
3441 <  ac_ext=f90
3442 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3443 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3444 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3445 < cat >conftest.$ac_ext <<_ACEOF
3446 < subroutine foobar()
3447 < return
3448 < end
3449 < subroutine foo_bar()
3450 < return
3451 < end
3452 < _ACEOF
3453 < rm -f conftest.$ac_objext
3454 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3455 <  (eval $ac_compile) 2>conftest.er1
3456 <  ac_status=$?
3457 <  grep -v '^ *+' conftest.er1 >conftest.err
3458 <  rm -f conftest.er1
3459 <  cat conftest.err >&5
3460 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3461 <  (exit $ac_status); } &&
3462 <         { ac_try='test -z "$ac_f90_werror_flag"
3463 <                         || test ! -s conftest.err'
3464 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3465 <  (eval $ac_try) 2>&5
3466 <  ac_status=$?
3467 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3468 <  (exit $ac_status); }; } &&
3469 <         { ac_try='test -s conftest.$ac_objext'
3470 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3471 <  (eval $ac_try) 2>&5
3472 <  ac_status=$?
3473 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3474 <  (exit $ac_status); }; }; then
3475 <  mv conftest.$ac_objext cf90_test.$ac_objext
3476 <
3477 <  ac_ext=c
3478 < ac_cpp='$CPP $CPPFLAGS'
3479 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3480 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3481 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3482 <
3483 <  ac_save_LIBS=$LIBS
3484 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3485 <
3486 <  ac_success=no
3487 <  for ac_foobar in foobar FOOBAR; do
3488 <    for ac_underscore in "" "_"; do
3489 <      ac_func="$ac_foobar$ac_underscore"
3490 <      cat >conftest.$ac_ext <<_ACEOF
3491 < /* confdefs.h.  */
3492 < _ACEOF
3493 < cat confdefs.h >>conftest.$ac_ext
3494 < cat >>conftest.$ac_ext <<_ACEOF
3495 < /* end confdefs.h.  */
3496 <
3497 < /* Override any gcc2 internal prototype to avoid an error.  */
3498 < #ifdef __cplusplus
3499 < extern "C"
3500 < #endif
3501 < /* We use char because int might match the return type of a gcc2
3502 <   builtin and then its argument prototype would still apply.  */
3503 < char $ac_func ();
3296 >   ac_cv_path_perlinterp="$PERLINTERP"
3297 >   _sHpB='#!'
3298 >
3299 >
3300 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3301 > if test "${with_perl_shebang+set}" = set; then
3302 >  withval="$with_perl_shebang"
3303 >  opt_perl_shebang="$withval"
3304 > else
3305 >                opt_perl_shebang="not_set"
3306 > fi;
3307 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3311 > else
3312 >   case "$opt_perl_shebang" in
3313 >                      not_set  ) ax_cv_opt_perl_shebang=''
3314 >                               ;;
3315 >                         *     )
3316 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317 >                    esac
3318 >
3319 > fi
3320 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3323 >     then
3324 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328 >
3329 > # Automatic detection of sharpbang formula starts here
3330 >     else
3331 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3332 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3337 > else
3338 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339 >        if test "x$_somian_kspb_perl" == x
3340 >          then _somian_ksbp_warn_empty='durnit'
3341 >          else
3342 >          case "A$_somian_kspb_perl" in
3343 >                 A#!*perl* )
3344 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345 >                        ;;
3346 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3347 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348 >          esac
3349 >        fi
3350 >
3351 > fi
3352 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354 > # The above prints Checking ... result message to user.
3355 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356 >
3357 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3358 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360 >    fi
3361 > # Inform user after printing result value
3362 >    if test A${_somian_ksbp_warn_defau+set} == Aset
3363 >      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364 > echo "$as_me: Maybe Not good -" >&6;}
3365 >           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366 > echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367 >      else { echo "$as_me:$LINENO: OK Good result - " >&5
3368 > echo "$as_me: OK Good result - " >&6;}
3369 >           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370 > echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371 >    fi
3372 >  fi
3373 >
3374 > # Find a good install program.  We prefer a C program (faster),
3375 > # so one script is as good as another.  But avoid the broken or
3376 > # incompatible versions:
3377 > # SysV /etc/install, /usr/sbin/install
3378 > # SunOS /usr/etc/install
3379 > # IRIX /sbin/install
3380 > # AIX /bin/install
3381 > # AmigaOS /C/install, which installs bootblocks on floppy discs
3382 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385 > # OS/2's system install, which has a completely different semantic
3386 > # ./install, which can be erroneously created by make from ./install.sh.
3387 > echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388 > echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389 > if test -z "$INSTALL"; then
3390 > if test "${ac_cv_path_install+set}" = set; then
3391 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3392 > else
3393 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394 > for as_dir in $PATH
3395 > do
3396 >  IFS=$as_save_IFS
3397 >  test -z "$as_dir" && as_dir=.
3398 >  # Account for people who put trailing slashes in PATH elements.
3399 > case $as_dir/ in
3400 >  ./ | .// | /cC/* | \
3401 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402 >  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403 >  /usr/ucb/* ) ;;
3404 >  *)
3405 >    # OSF1 and SCO ODT 3.0 have their own names for install.
3406 >    # Don't use installbsd from OSF since it installs stuff as root
3407 >    # by default.
3408 >    for ac_prog in ginstall scoinst install; do
3409 >      for ac_exec_ext in '' $ac_executable_extensions; do
3410 >        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411 >          if test $ac_prog = install &&
3412 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413 >            # AIX install.  It has an incompatible calling convention.
3414 >            :
3415 >          elif test $ac_prog = install &&
3416 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417 >            # program-specific install script used by HP pwplus--don't use.
3418 >            :
3419 >          else
3420 >            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421 >            break 3
3422 >          fi
3423 >        fi
3424 >      done
3425 >    done
3426 >    ;;
3427 > esac
3428 > done
3429 >
3430 >
3431 > fi
3432 >  if test "${ac_cv_path_install+set}" = set; then
3433 >    INSTALL=$ac_cv_path_install
3434 >  else
3435 >    # As a last resort, use the slow shell script.  We don't cache a
3436 >    # path for INSTALL within a source directory, because that will
3437 >    # break other packages using the cache if that directory is
3438 >    # removed, or if the path is relative.
3439 >    INSTALL=$ac_install_sh
3440 >  fi
3441 > fi
3442 > echo "$as_me:$LINENO: result: $INSTALL" >&5
3443 > echo "${ECHO_T}$INSTALL" >&6
3444 >
3445 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446 > # It thinks the first close brace ends the variable substitution.
3447 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448 >
3449 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450 >
3451 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452 >
3453 > 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_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_fc_libs; do
4118 >    if test x"$ac_arg" = x"$ac_i"; then
4119 >      ac_exists=true
4120 >      break
4121 >    fi
4122 >  done
4123 >
4124 >  if test x"$ac_exists" = xtrue; then
4125 >  :
4126 > else
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_fc_libs; do
4134 >    if test x"$ac_arg" = x"$ac_i"; then
4135 >      ac_exists=true
4136 >      break
4137 >    fi
4138 >  done
4139 >
4140 >  if test x"$ac_exists" = xtrue; then
4141 >  :
4142 > else
4143 >  if test "$ac_compiler_gnu" = yes; then
4144 >  for ac_link_opt in $ac_arg; do
4145 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146 >  done
4147 > else
4148 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149 > fi
4150 > fi
4151 >
4152 >          ;;
4153 >          # Ignore these flags.
4154 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155 >          ;;
4156 >        -lkernel32)
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 >             *)
4166 >                ac_arg="$ac_arg$2"
4167 >                shift; shift
4168 >                set X $ac_arg "$@"
4169 >                ;;
4170 >          esac
4171 >          ;;
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_fc_libs; do
4176 >    if test x"$ac_j" = x"$ac_i"; then
4177 >      ac_exists=true
4178 >      break
4179 >    fi
4180 >  done
4181 >
4182 >  if test x"$ac_exists" = xtrue; then
4183 >  :
4184 > else
4185 >  ac_arg="$ac_arg $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_fc_libs; do
4194 >    if test x"$ac_arg" = x"$ac_i"; then
4195 >      ac_exists=true
4196 >      break
4197 >    fi
4198 >  done
4199 >
4200 >  if test x"$ac_exists" = xtrue; then
4201 >  :
4202 > else
4203 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204 > fi
4205 >
4206 >          ;;
4207 >          # Ignore everything else.
4208 >  esac
4209 > done
4210 > # restore positional arguments
4211 > set X $ac_save_positional; shift
4212 >
4213 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
4214 > # then we insist that the "run path" must be an absolute path (i.e. it
4215 > # must begin with a "/").
4216 > case `(uname -sr) 2>/dev/null` in
4217 >   "SunOS 5"*)
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 &&
4221 >        if test "$ac_compiler_gnu" = yes; then
4222 >  for ac_link_opt in $ac_ld_run_path; do
4223 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224 >  done
4225 > else
4226 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227 > fi
4228 >      ;;
4229 > esac
4230 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231 >
4232 > fi
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 >
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 >
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_fc_dm_save_LIBS=$LIBS
4255 > LIBS="$LIBS $FCLIBS"
4256 > ac_fortran_dm_var=FC_DUMMY_MAIN
4257 > ac_ext=c
4258 > ac_cpp='$CPP $CPPFLAGS'
4259 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4260 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4261 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4262 >
4263 > # First, try linking without a dummy main:
4264 > cat >conftest.$ac_ext <<_ACEOF
4265 > /* confdefs.h.  */
4266 > _ACEOF
4267 > cat confdefs.h >>conftest.$ac_ext
4268 > cat >>conftest.$ac_ext <<_ACEOF
4269 > /* end confdefs.h.  */
4270 >
4271 > #ifdef FC_DUMMY_MAIN
4272 > #ifndef FC_DUMMY_MAIN_EQ_F77
4273 > #  ifdef __cplusplus
4274 >     extern "C"
4275 > #  endif
4276 >   int FC_DUMMY_MAIN() { return 1; }
4277 > #endif
4278 > #endif
4279 > int
4280 > main ()
4281 > {
4282 >
4283 >  ;
4284 >  return 0;
4285 > }
4286 > _ACEOF
4287 > rm -f conftest.$ac_objext conftest$ac_exeext
4288 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4289 >  (eval $ac_link) 2>conftest.er1
4290 >  ac_status=$?
4291 >  grep -v '^ *+' conftest.er1 >conftest.err
4292 >  rm -f conftest.er1
4293 >  cat conftest.err >&5
4294 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4295 >  (exit $ac_status); } &&
4296 >         { ac_try='test -z "$ac_c_werror_flag"
4297 >                         || test ! -s conftest.err'
4298 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4299 >  (eval $ac_try) 2>&5
4300 >  ac_status=$?
4301 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4302 >  (exit $ac_status); }; } &&
4303 >         { ac_try='test -s conftest$ac_exeext'
4304 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4305 >  (eval $ac_try) 2>&5
4306 >  ac_status=$?
4307 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308 >  (exit $ac_status); }; }; then
4309 >  ac_cv_fortran_dummy_main=none
4310 > else
4311 >  echo "$as_me: failed program was:" >&5
4312 > sed 's/^/| /' conftest.$ac_ext >&5
4313 >
4314 > ac_cv_fortran_dummy_main=unknown
4315 > fi
4316 > rm -f conftest.err conftest.$ac_objext \
4317 >      conftest$ac_exeext conftest.$ac_ext
4318 >
4319 > if test $ac_cv_fortran_dummy_main = unknown; then
4320 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4321 >     cat >conftest.$ac_ext <<_ACEOF
4322 > /* confdefs.h.  */
4323 > _ACEOF
4324 > cat confdefs.h >>conftest.$ac_ext
4325 > cat >>conftest.$ac_ext <<_ACEOF
4326 > /* end confdefs.h.  */
4327 > #define $ac_fortran_dm_var $ac_func
4328 > #ifdef FC_DUMMY_MAIN
4329 > #ifndef FC_DUMMY_MAIN_EQ_F77
4330 > #  ifdef __cplusplus
4331 >     extern "C"
4332 > #  endif
4333 >   int FC_DUMMY_MAIN() { return 1; }
4334 > #endif
4335 > #endif
4336 > int
4337 > main ()
4338 > {
4339 >
4340 >  ;
4341 >  return 0;
4342 > }
4343 > _ACEOF
4344 > rm -f conftest.$ac_objext conftest$ac_exeext
4345 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4346 >  (eval $ac_link) 2>conftest.er1
4347 >  ac_status=$?
4348 >  grep -v '^ *+' conftest.er1 >conftest.err
4349 >  rm -f conftest.er1
4350 >  cat conftest.err >&5
4351 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4352 >  (exit $ac_status); } &&
4353 >         { ac_try='test -z "$ac_c_werror_flag"
4354 >                         || test ! -s conftest.err'
4355 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4356 >  (eval $ac_try) 2>&5
4357 >  ac_status=$?
4358 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4359 >  (exit $ac_status); }; } &&
4360 >         { ac_try='test -s conftest$ac_exeext'
4361 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4362 >  (eval $ac_try) 2>&5
4363 >  ac_status=$?
4364 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4365 >  (exit $ac_status); }; }; then
4366 >  ac_cv_fortran_dummy_main=$ac_func; break
4367 > else
4368 >  echo "$as_me: failed program was:" >&5
4369 > sed 's/^/| /' conftest.$ac_ext >&5
4370 >
4371 > fi
4372 > rm -f conftest.err conftest.$ac_objext \
4373 >      conftest$ac_exeext conftest.$ac_ext
4374 >   done
4375 > fi
4376 > ac_ext=${FC_SRCEXT-f}
4377 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4378 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4379 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4380 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4381 > rm -f conftest*
4382 > LIBS=$ac_fc_dm_save_LIBS
4383 >
4384 > fi
4385 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4386 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4387 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4388 > if test "$FC_DUMMY_MAIN" != unknown; then
4389 >  if test $FC_DUMMY_MAIN != none; then
4390 >
4391 > cat >>confdefs.h <<_ACEOF
4392 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4393 > _ACEOF
4394 >
4395 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4396 >
4397 > cat >>confdefs.h <<\_ACEOF
4398 > #define FC_DUMMY_MAIN_EQ_F77 1
4399 > _ACEOF
4400 >
4401 >  fi
4402 > fi
4403 > else
4404 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4405 > See \`config.log' for more details." >&5
4406 > echo "$as_me: error: linking to Fortran libraries from C fails
4407 > See \`config.log' for more details." >&2;}
4408 >   { (exit 1); exit 1; }; }
4409 > fi
4410 >
4411 >
4412 > ac_ext=${FC_SRCEXT-f}
4413 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4414 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4415 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4416 >
4417 > ac_ext=${FC_SRCEXT-f}
4418 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4419 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4420 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4421 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4422 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4423 > if test "${ac_cv_fc_mangling+set}" = set; then
4424 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4425 > else
4426 >  cat >conftest.$ac_ext <<_ACEOF
4427 >      subroutine foobar()
4428 >      return
4429 >      end
4430 >      subroutine foo_bar()
4431 >      return
4432 >      end
4433 > _ACEOF
4434 > rm -f conftest.$ac_objext
4435 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4436 >  (eval $ac_compile) 2>conftest.er1
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 > echo "$as_me:$LINENO: checking for pow" >&5
9494 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495 > if test "${ac_cv_func_pow+set}" = set; then
9496 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9497 > else
9498 >  cat >conftest.$ac_ext <<_ACEOF
9499 > /* confdefs.h.  */
9500 > _ACEOF
9501 > cat confdefs.h >>conftest.$ac_ext
9502 > cat >>conftest.$ac_ext <<_ACEOF
9503 > /* end confdefs.h.  */
9504 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506 > #define pow innocuous_pow
9507 >
9508 > /* System header to define __stub macros and hopefully few prototypes,
9509 >    which can conflict with char pow (); below.
9510 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511 >    <limits.h> exists even on freestanding compilers.  */
9512 >
9513 > #ifdef __STDC__
9514 > # include <limits.h>
9515 > #else
9516 > # include <assert.h>
9517 > #endif
9518 >
9519 > #undef pow
9520 >
9521 > /* Override any gcc2 internal prototype to avoid an error.  */
9522 > #ifdef __cplusplus
9523 > extern "C"
9524 > {
9525 > #endif
9526 > /* We use char because int might match the return type of a gcc2
9527 >   builtin and then its argument prototype would still apply.  */
9528 > char pow ();
9529 > /* The GNU C library defines this for functions which it implements
9530 >    to always fail with ENOSYS.  Some functions are actually named
9531 >    something starting with __ and the normal name is an alias.  */
9532 > #if defined (__stub_pow) || defined (__stub___pow)
9533 > choke me
9534 > #else
9535 > char (*f) () = pow;
9536 > #endif
9537 > #ifdef __cplusplus
9538 > }
9539 > #endif
9540 >
9541 > #ifdef FC_DUMMY_MAIN
9542 > #ifndef FC_DUMMY_MAIN_EQ_F77
9543 > #  ifdef __cplusplus
9544 >     extern "C"
9545 > #  endif
9546 >   int FC_DUMMY_MAIN() { return 1; }
9547 > #endif
9548 > #endif
9549 > int
9550 > main ()
9551 > {
9552 > return f != pow;
9553 >  ;
9554 >  return 0;
9555 > }
9556 > _ACEOF
9557 > rm -f conftest.$ac_objext conftest$ac_exeext
9558 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9559 >  (eval $ac_link) 2>conftest.er1
9560 >  ac_status=$?
9561 >  grep -v '^ *+' conftest.er1 >conftest.err
9562 >  rm -f conftest.er1
9563 >  cat conftest.err >&5
9564 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565 >  (exit $ac_status); } &&
9566 >         { ac_try='test -z "$ac_c_werror_flag"
9567 >                         || test ! -s conftest.err'
9568 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569 >  (eval $ac_try) 2>&5
9570 >  ac_status=$?
9571 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9572 >  (exit $ac_status); }; } &&
9573 >         { ac_try='test -s conftest$ac_exeext'
9574 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9575 >  (eval $ac_try) 2>&5
9576 >  ac_status=$?
9577 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578 >  (exit $ac_status); }; }; then
9579 >  ac_cv_func_pow=yes
9580 > else
9581 >  echo "$as_me: failed program was:" >&5
9582 > sed 's/^/| /' conftest.$ac_ext >&5
9583 >
9584 > ac_cv_func_pow=no
9585 > fi
9586 > rm -f conftest.err conftest.$ac_objext \
9587 >      conftest$ac_exeext conftest.$ac_ext
9588 > fi
9589 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9591 >
9592 > if test $ac_cv_func_pow = no; then
9593 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595 > if test "${ac_cv_lib_m_pow+set}" = set; then
9596 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9597 > else
9598 >  ac_check_lib_save_LIBS=$LIBS
9599 > LIBS="-lm  $LIBS"
9600 > cat >conftest.$ac_ext <<_ACEOF
9601 > /* confdefs.h.  */
9602 > _ACEOF
9603 > cat confdefs.h >>conftest.$ac_ext
9604 > cat >>conftest.$ac_ext <<_ACEOF
9605 > /* end confdefs.h.  */
9606 >
9607 > /* Override any gcc2 internal prototype to avoid an error.  */
9608 > #ifdef __cplusplus
9609 > extern "C"
9610 > #endif
9611 > /* We use char because int might match the return type of a gcc2
9612 >   builtin and then its argument prototype would still apply.  */
9613 > char pow ();
9614 > #ifdef FC_DUMMY_MAIN
9615 > #ifndef FC_DUMMY_MAIN_EQ_F77
9616 > #  ifdef __cplusplus
9617 >     extern "C"
9618 > #  endif
9619 >   int FC_DUMMY_MAIN() { return 1; }
9620 > #endif
9621 > #endif
9622 > int
9623 > main ()
9624 > {
9625 > pow ();
9626 >  ;
9627 >  return 0;
9628 > }
9629 > _ACEOF
9630 > rm -f conftest.$ac_objext conftest$ac_exeext
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632 >  (eval $ac_link) 2>conftest.er1
9633 >  ac_status=$?
9634 >  grep -v '^ *+' conftest.er1 >conftest.err
9635 >  rm -f conftest.er1
9636 >  cat conftest.err >&5
9637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638 >  (exit $ac_status); } &&
9639 >         { ac_try='test -z "$ac_c_werror_flag"
9640 >                         || test ! -s conftest.err'
9641 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642 >  (eval $ac_try) 2>&5
9643 >  ac_status=$?
9644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645 >  (exit $ac_status); }; } &&
9646 >         { ac_try='test -s conftest$ac_exeext'
9647 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648 >  (eval $ac_try) 2>&5
9649 >  ac_status=$?
9650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651 >  (exit $ac_status); }; }; then
9652 >  ac_cv_lib_m_pow=yes
9653 > else
9654 >  echo "$as_me: failed program was:" >&5
9655 > sed 's/^/| /' conftest.$ac_ext >&5
9656 >
9657 > ac_cv_lib_m_pow=no
9658 > fi
9659 > rm -f conftest.err conftest.$ac_objext \
9660 >      conftest$ac_exeext conftest.$ac_ext
9661 > LIBS=$ac_check_lib_save_LIBS
9662 > fi
9663 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665 > if test $ac_cv_lib_m_pow = yes; then
9666 >  POW_LIB=-lm
9667 > else
9668 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670 > fi
9671 >
9672 > fi
9673 >
9674 > fi
9675 >
9676 >
9677 >
9678 >
9679 >
9680 >
9681 >
9682 >
9683 >
9684 >
9685 >
9686 >
9687 >
9688 >
9689 >
9690 >
9691 >
9692 >
9693 >
9694 >
9695 >
9696 >
9697 >
9698 >
9699 >
9700 >
9701 >
9702 >
9703 > for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9704 > do
9705 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9707 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9709 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9710 > else
9711 >  cat >conftest.$ac_ext <<_ACEOF
9712 > /* confdefs.h.  */
9713 > _ACEOF
9714 > cat confdefs.h >>conftest.$ac_ext
9715 > cat >>conftest.$ac_ext <<_ACEOF
9716 > /* end confdefs.h.  */
9717 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719 > #define $ac_func innocuous_$ac_func
9720 >
9721 > /* System header to define __stub macros and hopefully few prototypes,
9722 >    which can conflict with char $ac_func (); below.
9723 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724 >    <limits.h> exists even on freestanding compilers.  */
9725 >
9726 > #ifdef __STDC__
9727 > # include <limits.h>
9728 > #else
9729 > # include <assert.h>
9730 > #endif
9731 >
9732 > #undef $ac_func
9733 >
9734 > /* Override any gcc2 internal prototype to avoid an error.  */
9735 > #ifdef __cplusplus
9736 > extern "C"
9737 > {
9738 > #endif
9739 > /* We use char because int might match the return type of a gcc2
9740 >   builtin and then its argument prototype would still apply.  */
9741 > char $ac_func ();
9742 > /* The GNU C library defines this for functions which it implements
9743 >    to always fail with ENOSYS.  Some functions are actually named
9744 >    something starting with __ and the normal name is an alias.  */
9745 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746 > choke me
9747 > #else
9748 > char (*f) () = $ac_func;
9749 > #endif
9750 > #ifdef __cplusplus
9751 > }
9752 > #endif
9753 >
9754 > #ifdef FC_DUMMY_MAIN
9755 > #ifndef FC_DUMMY_MAIN_EQ_F77
9756 > #  ifdef __cplusplus
9757 >     extern "C"
9758 > #  endif
9759 >   int FC_DUMMY_MAIN() { return 1; }
9760 > #endif
9761 > #endif
9762 > int
9763 > main ()
9764 > {
9765 > return f != $ac_func;
9766 >  ;
9767 >  return 0;
9768 > }
9769 > _ACEOF
9770 > rm -f conftest.$ac_objext conftest$ac_exeext
9771 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772 >  (eval $ac_link) 2>conftest.er1
9773 >  ac_status=$?
9774 >  grep -v '^ *+' conftest.er1 >conftest.err
9775 >  rm -f conftest.er1
9776 >  cat conftest.err >&5
9777 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9778 >  (exit $ac_status); } &&
9779 >         { ac_try='test -z "$ac_c_werror_flag"
9780 >                         || test ! -s conftest.err'
9781 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9782 >  (eval $ac_try) 2>&5
9783 >  ac_status=$?
9784 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785 >  (exit $ac_status); }; } &&
9786 >         { ac_try='test -s conftest$ac_exeext'
9787 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788 >  (eval $ac_try) 2>&5
9789 >  ac_status=$?
9790 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791 >  (exit $ac_status); }; }; then
9792 >  eval "$as_ac_var=yes"
9793 > else
9794 >  echo "$as_me: failed program was:" >&5
9795 > sed 's/^/| /' conftest.$ac_ext >&5
9796 >
9797 > eval "$as_ac_var=no"
9798 > fi
9799 > rm -f conftest.err conftest.$ac_objext \
9800 >      conftest$ac_exeext conftest.$ac_ext
9801 > fi
9802 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9805 >  cat >>confdefs.h <<_ACEOF
9806 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807 > _ACEOF
9808 >
9809 > fi
9810 > done
9811 >
9812 >
9813 > # special check for _system_configuration because AIX <4.3.2 do not
9814 > # contain the `physmem' member.
9815 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817 > cat >conftest.$ac_ext <<_ACEOF
9818 > /* confdefs.h.  */
9819 > _ACEOF
9820 > cat confdefs.h >>conftest.$ac_ext
9821 > cat >>conftest.$ac_ext <<_ACEOF
9822 > /* end confdefs.h.  */
9823 > #include <sys/systemcfg.h>
9824 > #ifdef FC_DUMMY_MAIN
9825 > #ifndef FC_DUMMY_MAIN_EQ_F77
9826 > #  ifdef __cplusplus
9827 >     extern "C"
9828 > #  endif
9829 >   int FC_DUMMY_MAIN() { return 1; }
9830 > #endif
9831 > #endif
9832 > int
9833 > main ()
9834 > {
9835 > double x = _system_configuration.physmem;
9836 >  ;
9837 >  return 0;
9838 > }
9839 > _ACEOF
9840 > rm -f conftest.$ac_objext
9841 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842 >  (eval $ac_compile) 2>conftest.er1
9843 >  ac_status=$?
9844 >  grep -v '^ *+' conftest.er1 >conftest.err
9845 >  rm -f conftest.er1
9846 >  cat conftest.err >&5
9847 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848 >  (exit $ac_status); } &&
9849 >         { ac_try='test -z "$ac_c_werror_flag"
9850 >                         || test ! -s conftest.err'
9851 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852 >  (eval $ac_try) 2>&5
9853 >  ac_status=$?
9854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855 >  (exit $ac_status); }; } &&
9856 >         { ac_try='test -s conftest.$ac_objext'
9857 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858 >  (eval $ac_try) 2>&5
9859 >  ac_status=$?
9860 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861 >  (exit $ac_status); }; }; then
9862 >  echo "$as_me:$LINENO: result: yes" >&5
9863 > echo "${ECHO_T}yes" >&6
9864 >
9865 > cat >>confdefs.h <<\_ACEOF
9866 > #define HAVE__SYSTEM_CONFIGURATION 1
9867 > _ACEOF
9868 >
9869 > else
9870 >  echo "$as_me: failed program was:" >&5
9871 > sed 's/^/| /' conftest.$ac_ext >&5
9872 >
9873 > echo "$as_me:$LINENO: result: no" >&5
9874 > echo "${ECHO_T}no" >&6
9875 > fi
9876 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877 >
9878 >  # clean out junk possibly left behind by a previous configuration
9879 >  rm -f src/getopt.h
9880 >  # Check for getopt_long support
9881 >
9882 > for ac_header in getopt.h
9883 > do
9884 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9887 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9890 > fi
9891 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893 > else
9894 >  # Is the header compilable?
9895 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897 > cat >conftest.$ac_ext <<_ACEOF
9898 > /* confdefs.h.  */
9899 > _ACEOF
9900 > cat confdefs.h >>conftest.$ac_ext
9901 > cat >>conftest.$ac_ext <<_ACEOF
9902 > /* end confdefs.h.  */
9903 > $ac_includes_default
9904 > #include <$ac_header>
9905 > _ACEOF
9906 > rm -f conftest.$ac_objext
9907 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9908 >  (eval $ac_compile) 2>conftest.er1
9909 >  ac_status=$?
9910 >  grep -v '^ *+' conftest.er1 >conftest.err
9911 >  rm -f conftest.er1
9912 >  cat conftest.err >&5
9913 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914 >  (exit $ac_status); } &&
9915 >         { ac_try='test -z "$ac_c_werror_flag"
9916 >                         || test ! -s conftest.err'
9917 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9918 >  (eval $ac_try) 2>&5
9919 >  ac_status=$?
9920 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921 >  (exit $ac_status); }; } &&
9922 >         { ac_try='test -s conftest.$ac_objext'
9923 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924 >  (eval $ac_try) 2>&5
9925 >  ac_status=$?
9926 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927 >  (exit $ac_status); }; }; then
9928 >  ac_header_compiler=yes
9929 > else
9930 >  echo "$as_me: failed program was:" >&5
9931 > sed 's/^/| /' conftest.$ac_ext >&5
9932 >
9933 > ac_header_compiler=no
9934 > fi
9935 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9936 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937 > echo "${ECHO_T}$ac_header_compiler" >&6
9938 >
9939 > # Is the header present?
9940 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942 > cat >conftest.$ac_ext <<_ACEOF
9943 > /* confdefs.h.  */
9944 > _ACEOF
9945 > cat confdefs.h >>conftest.$ac_ext
9946 > cat >>conftest.$ac_ext <<_ACEOF
9947 > /* end confdefs.h.  */
9948 > #include <$ac_header>
9949 > _ACEOF
9950 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9952 >  ac_status=$?
9953 >  grep -v '^ *+' conftest.er1 >conftest.err
9954 >  rm -f conftest.er1
9955 >  cat conftest.err >&5
9956 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9957 >  (exit $ac_status); } >/dev/null; then
9958 >  if test -s conftest.err; then
9959 >    ac_cpp_err=$ac_c_preproc_warn_flag
9960 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9961 >  else
9962 >    ac_cpp_err=
9963 >  fi
9964 > else
9965 >  ac_cpp_err=yes
9966 > fi
9967 > if test -z "$ac_cpp_err"; then
9968 >  ac_header_preproc=yes
9969 > else
9970 >  echo "$as_me: failed program was:" >&5
9971 > sed 's/^/| /' conftest.$ac_ext >&5
9972 >
9973 >  ac_header_preproc=no
9974 > fi
9975 > rm -f conftest.err conftest.$ac_ext
9976 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9977 > echo "${ECHO_T}$ac_header_preproc" >&6
9978 >
9979 > # So?  What about this header?
9980 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981 >  yes:no: )
9982 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986 >    ac_header_preproc=yes
9987 >    ;;
9988 >  no:yes:* )
9989 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001 >    (
10002 >      cat <<\_ASBOX
10003 > ## ------------------------------ ##
10004 > ## Report this to gezelter@nd.edu ##
10005 > ## ------------------------------ ##
10006 > _ASBOX
10007 >    ) |
10008 >      sed "s/^/$as_me: WARNING:     /" >&2
10009 >    ;;
10010 > esac
10011 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10012 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10015 > else
10016 >  eval "$as_ac_Header=\$ac_header_preproc"
10017 > fi
10018 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020 >
10021 > fi
10022 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023 >  cat >>confdefs.h <<_ACEOF
10024 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025 > _ACEOF
10026 >
10027 > fi
10028 >
10029 > done
10030 >
10031 >
10032 > for ac_func in getopt_long
10033 > do
10034 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10036 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10038 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10039 > else
10040 >  cat >conftest.$ac_ext <<_ACEOF
10041 > /* confdefs.h.  */
10042 > _ACEOF
10043 > cat confdefs.h >>conftest.$ac_ext
10044 > cat >>conftest.$ac_ext <<_ACEOF
10045 > /* end confdefs.h.  */
10046 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048 > #define $ac_func innocuous_$ac_func
10049 >
10050 > /* System header to define __stub macros and hopefully few prototypes,
10051 >    which can conflict with char $ac_func (); below.
10052 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053 >    <limits.h> exists even on freestanding compilers.  */
10054 >
10055 > #ifdef __STDC__
10056 > # include <limits.h>
10057 > #else
10058 > # include <assert.h>
10059 > #endif
10060 >
10061 > #undef $ac_func
10062 >
10063 > /* Override any gcc2 internal prototype to avoid an error.  */
10064 > #ifdef __cplusplus
10065 > extern "C"
10066 > {
10067 > #endif
10068 > /* We use char because int might match the return type of a gcc2
10069 >   builtin and then its argument prototype would still apply.  */
10070 > char $ac_func ();
10071 > /* The GNU C library defines this for functions which it implements
10072 >    to always fail with ENOSYS.  Some functions are actually named
10073 >    something starting with __ and the normal name is an alias.  */
10074 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075 > choke me
10076 > #else
10077 > char (*f) () = $ac_func;
10078 > #endif
10079 > #ifdef __cplusplus
10080 > }
10081 > #endif
10082 >
10083 > #ifdef FC_DUMMY_MAIN
10084 > #ifndef FC_DUMMY_MAIN_EQ_F77
10085 > #  ifdef __cplusplus
10086 >     extern "C"
10087 > #  endif
10088 >   int FC_DUMMY_MAIN() { return 1; }
10089 > #endif
10090 > #endif
10091   int
10092   main ()
10093   {
10094 < $ac_func ();
10094 > return f != $ac_func;
10095    ;
10096    return 0;
10097   }
# Line 3888 | 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_success=yes; break 2
10121 >  eval "$as_ac_var=yes"
10122   else
10123    echo "$as_me: failed program was:" >&5
10124   sed 's/^/| /' conftest.$ac_ext >&5
10125  
10126 + eval "$as_ac_var=no"
10127   fi
10128   rm -f conftest.err conftest.$ac_objext \
10129        conftest$ac_exeext conftest.$ac_ext
10130 <    done
10131 <  done
10130 > fi
10131 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10132 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10133 > if test `eval echo '${'$as_ac_var'}'` = yes; then
10134 >  cat >>confdefs.h <<_ACEOF
10135 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10136 > _ACEOF
10137  
10138 <  if test "$ac_success" = "yes"; then
10139 <     case $ac_foobar in
10140 <        foobar)
10141 <           ac_case=lower
10142 <           ac_foo_bar=foo_bar
10143 <           ;;
10144 <        FOOBAR)
10145 <           ac_case=upper
10146 <           ac_foo_bar=FOO_BAR
10147 <           ;;
3912 <     esac
3913 <
3914 <     ac_success_extra=no
3915 <     for ac_extra in "" "_"; do
3916 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3917 <
3918 <        cat >conftest.$ac_ext <<_ACEOF
10138 > else
10139 >  # FreeBSD has a gnugetopt library for this
10140 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10141 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10142 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10143 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10144 > else
10145 >  ac_check_lib_save_LIBS=$LIBS
10146 > LIBS="-lgnugetopt  $LIBS"
10147 > cat >conftest.$ac_ext <<_ACEOF
10148   /* confdefs.h.  */
10149   _ACEOF
10150   cat confdefs.h >>conftest.$ac_ext
# Line 3928 | Line 10157 | 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 $ac_func ();
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 < $ac_func ();
10172 > getopt_long ();
10173    ;
10174    return 0;
10175   }
# Line 3959 | Line 10196 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10196    ac_status=$?
10197    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198    (exit $ac_status); }; }; then
10199 <  ac_success_extra=yes; break
10199 >  ac_cv_lib_gnugetopt_getopt_long=yes
10200   else
10201    echo "$as_me: failed program was:" >&5
10202   sed 's/^/| /' conftest.$ac_ext >&5
10203  
10204 + ac_cv_lib_gnugetopt_getopt_long=no
10205   fi
10206   rm -f conftest.err conftest.$ac_objext \
10207        conftest$ac_exeext conftest.$ac_ext
10208 <     done
3971 <
3972 <     if test "$ac_success_extra" = "yes"; then
3973 <        ac_cv_f90_mangling="$ac_case case"
3974 <        if test -z "$ac_underscore"; then
3975 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
3976 <        else
3977 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
3978 <
3979 <        fi
3980 <        if test -z "$ac_extra"; then
3981 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3982 <        else
3983 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3984 <        fi
3985 <      else
3986 <        ac_cv_f90_mangling="unknown"
3987 <      fi
3988 <  else
3989 <     ac_cv_f90_mangling="unknown"
3990 <
3991 <  fi
3992 <
3993 <  LIBS=$ac_save_LIBS
3994 <  ac_ext=f90
3995 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3996 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3997 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3998 <  rm -f cf90_test* conftest*
3999 < else
4000 <  echo "$as_me: failed program was:" >&5
4001 < sed 's/^/| /' conftest.$ac_ext >&5
4002 <
10208 > LIBS=$ac_check_lib_save_LIBS
10209   fi
10210 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10211 < ac_ext=f90
10212 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
10213 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10214 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4009 <
4010 < fi
4011 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4012 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4013 <
4014 <
4015 <
4016 < case $ac_cv_f90_mangling in
4017 <  "lower case, no underscore, no extra underscore")
4018 <          cat >>confdefs.h <<\_ACEOF
4019 < #define F90_FUNC(name,NAME) name
10210 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10211 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10212 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10213 >  cat >>confdefs.h <<\_ACEOF
10214 > #define HAVE_GETOPT_LONG 1
10215   _ACEOF
10216  
10217 <          cat >>confdefs.h <<\_ACEOF
10218 < #define F90_FUNC_(name,NAME) name
10219 < _ACEOF
10220 < ;;
10221 <  "lower case, no underscore, extra underscore")
10222 <          cat >>confdefs.h <<\_ACEOF
10223 < #define F90_FUNC(name,NAME) name
10224 < _ACEOF
10217 > else
10218 >  # use the GNU replacement
10219 >      case $LIBOBJS in
10220 >    "getopt.$ac_objext"   | \
10221 >  *" getopt.$ac_objext"   | \
10222 >    "getopt.$ac_objext "* | \
10223 >  *" getopt.$ac_objext "* ) ;;
10224 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10225 > esac
10226  
10227 <          cat >>confdefs.h <<\_ACEOF
10228 < #define F90_FUNC_(name,NAME) name ## _
10229 < _ACEOF
10230 < ;;
10231 <  "lower case, underscore, no extra underscore")
10232 <          cat >>confdefs.h <<\_ACEOF
4037 < #define F90_FUNC(name,NAME) name ## _
4038 < _ACEOF
4039 <
4040 <          cat >>confdefs.h <<\_ACEOF
4041 < #define F90_FUNC_(name,NAME) name ## _
4042 < _ACEOF
4043 < ;;
4044 <  "lower case, underscore, extra underscore")
4045 <          cat >>confdefs.h <<\_ACEOF
4046 < #define F90_FUNC(name,NAME) name ## _
4047 < _ACEOF
4048 <
4049 <          cat >>confdefs.h <<\_ACEOF
4050 < #define F90_FUNC_(name,NAME) name ## __
4051 < _ACEOF
4052 < ;;
4053 <  "upper case, no underscore, no extra underscore")
4054 <          cat >>confdefs.h <<\_ACEOF
4055 < #define F90_FUNC(name,NAME) NAME
4056 < _ACEOF
4057 <
4058 <          cat >>confdefs.h <<\_ACEOF
4059 < #define F90_FUNC_(name,NAME) NAME
4060 < _ACEOF
4061 < ;;
4062 <  "upper case, no underscore, extra underscore")
4063 <          cat >>confdefs.h <<\_ACEOF
4064 < #define F90_FUNC(name,NAME) NAME
4065 < _ACEOF
4066 <
4067 <          cat >>confdefs.h <<\_ACEOF
4068 < #define F90_FUNC_(name,NAME) NAME ## _
4069 < _ACEOF
4070 < ;;
4071 <  "upper case, underscore, no extra underscore")
4072 <          cat >>confdefs.h <<\_ACEOF
4073 < #define F90_FUNC(name,NAME) NAME ## _
4074 < _ACEOF
4075 <
4076 <          cat >>confdefs.h <<\_ACEOF
4077 < #define F90_FUNC_(name,NAME) NAME ## _
4078 < _ACEOF
4079 < ;;
4080 <  "upper case, underscore, extra underscore")
4081 <          cat >>confdefs.h <<\_ACEOF
4082 < #define F90_FUNC(name,NAME) NAME ## _
4083 < _ACEOF
4084 <
4085 <          cat >>confdefs.h <<\_ACEOF
4086 < #define F90_FUNC_(name,NAME) NAME ## __
4087 < _ACEOF
4088 < ;;
4089 <  *)
4090 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4091 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4092 <          ;;
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  
4096 –
4097 –
4098 –
4099 – echo "$as_me:$LINENO: checking for module suffix" >&5
4100 – echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4101 – rm -f conftest*
4102 – # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4103 – rm -f work*
4104 – cat >conftest.f90 <<EOF
4105 –        module conftest
4106 –        integer n
4107 –        parameter (n=1)
4108 –        end module conftest
4109 – EOF
4110 – # SGI and absoft compilers generates module name in upper case!
4111 – testname="conftest"
4112 – modcase="lower"
4113 – if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4114 –    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4115 –    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4116 –    if test -z "$MOD" ; then
4117 –        MOD=`ls CONFTEST* 2>/dev/null \
4118 –                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4119 –        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4120 –        if test -n "$MOD" ; then
4121 –            testname="CONFTEST"
4122 –            modcase="upper"
4123 –        fi
4124 –    fi
4125 –    if test -z "$MOD" ; then
4126 –        echo "$as_me:$LINENO: result: unknown" >&5
4127 – echo "${ECHO_T}unknown" >&6
4128 –        # Use mod if we can't figure it out
4129 –        MOD="mod"
4130 –    else
4131 –        echo "$as_me:$LINENO: result: $MOD" >&5
4132 – echo "${ECHO_T}$MOD" >&6
4133 –    fi
4134 –    if test -s work.pcl ; then
4135 –        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4136 – echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4137 –    fi
4138 – else
4139 –    echo "$as_me:$LINENO: result: unknown" >&5
4140 – echo "${ECHO_T}unknown" >&6
10237   fi
10238  
10239 <
10240 <
4145 <
4146 <
4147 < # Check for module include path (some use -I, some (Solaris) use -M, some
4148 < # (absoft) use -p).
4149 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4150 < # specified, work.pcl and work.pc are created.  However, if you specify
4151 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4152 < # Use the module made above
4153 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4154 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4155 < rm -f conftest*
4156 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4157 < rm -f work*
4158 < cat >conftest.f90 <<EOF
4159 <        module conftest
4160 <        integer n
4161 <        parameter (n=1)
4162 <        end module conftest
4163 < EOF
4164 < # SGI and absoft compilers generates module name in upper case!
4165 < testname="conftest"
4166 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4167 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4168 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4169 <   if test -n "$mod" ; then
4170 <      testname="CONFTEST"
4171 <   fi
4172 <   madedir=0
4173 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4174 <   cp $testname.$MOD conf
4175 <   rm -f conftest* CONFTEST*
4176 <   cat >conftest1.f90 <<EOF
4177 <        program main
4178 <        use conftest
4179 <        print *, n
4180 <        end
4181 < EOF
4182 <   F90_WORK_FILES_ARG=""
4183 <   F90MODINCSPEC=""
4184 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4185 <       MODDIRFLAG="-I"
4186 <       F90MODINCSPEC="-I<dir>"
4187 <       echo "$as_me:$LINENO: result: -I" >&5
4188 < echo "${ECHO_T}-I" >&6
4189 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4190 <       MODDIRFLAG="-M"
4191 <       F90MODINCSPEC="-M<dir>"
4192 <       echo "$as_me:$LINENO: result: -M" >&5
4193 < echo "${ECHO_T}-M" >&6
4194 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4195 <       MODDIRFLAG="-p"
4196 <       F90MODINCSPEC="-p<dir>"
4197 <       echo "$as_me:$LINENO: result: -p" >&5
4198 < echo "${ECHO_T}-p" >&6
4199 <   elif test -s work.pc ; then
4200 <        cp work.pc conf/mpimod.pc
4201 <        echo "mpimod.pc" > conf/mpimod.pcl
4202 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4203 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4204 <            MODDIRFLAG='-cl,mpimod.pcl'
4205 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4206 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4207 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4208 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
10239 > fi
10240 > done
10241  
4210 –        else
4211 –            # The version of the Intel compiler that I have refuses to let
4212 –            # you put the "work catalog" list anywhere but the current
4213 –            # directory. For example, you cannot in
4214 –         :
4215 –        fi
4216 –   fi
4217 –   if test -z "MODDIRFLAG" ; then
4218 –       echo "$as_me:$LINENO: result: unknown" >&5
4219 – echo "${ECHO_T}unknown" >&6
4220 –   fi
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  
4223 –   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4224 –   if test $madedir = 1 ; then rmdir conf ; fi
4225 – fi
10249  
10250 <
10251 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
10252 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4230 < if test "${ac_cv_f90_module_names+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
10254   else
4233 –  ac_ext=f90
4234 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4235 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4236 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
10255  
10256 < # carry out the test in a new directory, so that we don't miss anything
10257 < mkdir conftest
10258 < cd conftest
10259 < cat >conftest.$ac_ext <<_ACEOF
10260 < MODULE Bar
10261 < END MODULE Bar
10256 >
10257 > ac_ext=cc
10258 > ac_cpp='$CXXCPP $CPPFLAGS'
10259 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262 >
10263 > cat >conftest.$ac_ext <<_ACEOF
10264 > /* confdefs.h.  */
10265   _ACEOF
10266 + cat confdefs.h >>conftest.$ac_ext
10267 + cat >>conftest.$ac_ext <<_ACEOF
10268 + /* end confdefs.h.  */
10269 + namespace Outer { namespace Inner { int i = 0; }}
10270 + #ifdef FC_DUMMY_MAIN
10271 + #ifndef FC_DUMMY_MAIN_EQ_F77
10272 + #  ifdef __cplusplus
10273 +     extern "C"
10274 + #  endif
10275 +   int FC_DUMMY_MAIN() { return 1; }
10276 + #endif
10277 + #endif
10278 + int
10279 + main ()
10280 + {
10281 + using namespace Outer::Inner; return i;
10282 +  ;
10283 +  return 0;
10284 + }
10285 + _ACEOF
10286   rm -f conftest.$ac_objext
10287   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10288    (eval $ac_compile) 2>conftest.er1
# Line 4251 | 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_f90_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 4264 | 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_cv_f90_module_names=
4268 < ac_file_list=*
4269 < for ac_file in $ac_file_list; do
4270 <   case $ac_file in
4271 <      # don't care for original source and object files
4272 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4273 <          :
4274 <          ;;
4275 <      # look for new files derived from the file name
4276 <      *conftest*)
4277 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4278 <            ac_exists=false
4279 <  for ac_i in $ac_cv_f90_module_names; do
4280 <    if test x"$ac_pat" = x"$ac_i"; then
4281 <      ac_exists=true
4282 <      break
4283 <    fi
4284 <  done
4285 <
4286 <  if test x"$ac_exists" = xtrue; then
4287 <  :
10308 >  ac_cv_cxx_namespaces=yes
10309   else
4289 –  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4290 – fi
4291 –
4292 –          ;;
4293 –      # look for new files derived from the module name,
4294 –      # with different case translation schemes
4295 –      *Bar*)
4296 –          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4297 –            ac_exists=false
4298 –  for ac_i in $ac_cv_f90_module_names; do
4299 –    if test x"$ac_pat" = x"$ac_i"; then
4300 –      ac_exists=true
4301 –      break
4302 –    fi
4303 –  done
4304 –
4305 –  if test x"$ac_exists" = xtrue; then
4306 –  :
4307 – else
4308 –  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4309 – fi
4310 –
4311 –          ;;
4312 –      *bar*)
4313 –          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4314 –            ac_exists=false
4315 –  for ac_i in $ac_cv_f90_module_names; do
4316 –    if test x"$ac_pat" = x"$ac_i"; then
4317 –      ac_exists=true
4318 –      break
4319 –    fi
4320 –  done
4321 –
4322 –  if test x"$ac_exists" = xtrue; then
4323 –  :
4324 – else
4325 –  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4326 – fi
4327 –
4328 –          ;;
4329 –      *BAR*)
4330 –          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4331 –            ac_exists=false
4332 –  for ac_i in $ac_cv_f90_module_names; do
4333 –    if test x"$ac_pat" = x"$ac_i"; then
4334 –      ac_exists=true
4335 –      break
4336 –    fi
4337 –  done
4338 –
4339 –  if test x"$ac_exists" = xtrue; then
4340 –  :
4341 – else
4342 –  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4343 – fi
4344 –
4345 –          ;;
4346 –       # Other files - we have no idea how they are generated
4347 –       *)
4348 –          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4349 – echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4350 –          ;;
4351 –   esac
4352 – done
4353 – if test "x$ac_cv_f90_module_names" = "x"; then
4354 –  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4355 – echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4356 – fi
4357 –
4358 – else
10310    echo "$as_me: failed program was:" >&5
10311   sed 's/^/| /' conftest.$ac_ext >&5
10312  
10313 < ac_cv_f90_module_names=
4363 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4364 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
10313 > ac_cv_cxx_namespaces=no
10314   fi
10315   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316 < cd ..
10317 < # cleanup
10318 < rm -rf conftest
10319 < ac_ext=f90
10320 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4372 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4373 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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  
4375 – fi
4376 – echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4377 – echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
10322  
10323 < # We now generate a shell script that will help us to figure out the correct
10324 < # module file names, using the value of ac_cv_f90_module_names
10325 <
10326 < echo "Generating shell script modnam"
4383 <
4384 < cat > scripts/modnam << EOF
4385 < #! /bin/sh
4386 < # This script is auto-generated by configure
4387 < #
4388 < usage="\\
4389 < Usage: \$0 [FILES]
10323 > fi
10324 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326 > if test "$ac_cv_cxx_namespaces" = yes; then
10327  
10328 < [FILES] are Fortran 90 source files.
10329 < The output is a list of module file names that the Fortran 90 compiler
10330 < generates when compiling [FILES]."
10328 > cat >>confdefs.h <<\_ACEOF
10329 > #define HAVE_NAMESPACES
10330 > _ACEOF
10331  
4395 – list=
4396 – empty=
4397 –
4398 – if test \$# -eq 0; then
4399 –   echo "\$usage"; exit 0
10332   fi
10333  
10334 < while test \$# != 0; do
10335 <
10336 <  file=\$1
10337 <  shift
10338 <
10339 < # strip suffix
10340 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
10341 <
10342 <  test ! -f \$file && continue
4411 <
4412 < # Look for module definitions and transform them to upper / lower case
4413 <  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/'\`
4414 <  upper=\`echo \$mods | tr a-z A-Z\`
4415 <  lower=\`echo \$mods | tr A-Z a-z\`
4416 <
4417 < # Here, the patterns for generating module file names were inserted by configure
4418 <  for trans in $ac_cv_f90_module_names; do
4419 <
4420 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4421 <    var=empty
4422 <    case \$pat in
4423 <       %MODULE%)
4424 <          var=upper ;;
4425 <       %Module%)
4426 <          var=mods ;;
4427 <       %module%)
4428 <          var=lower ;;
4429 <       %FILE%)
4430 <          test -n "\$mods" && var=base ;;
4431 <    esac
4432 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4433 <    list="\$list \$new"
4434 <  done
4435 < done
4436 <
4437 < echo \$list
4438 < # end of configure-generated script
4439 < EOF
4440 < chmod 755 scripts/modnam
4441 <
4442 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4443 < F90_MODULE_NAMES=empty
4444 < case $pat in
4445 <       %MODULE%)
4446 <          F90_MODULE_NAMES=UPPER ;;
4447 <       %Module%)
4448 <          F90_MODULE_NAMES=Mixed ;;
4449 <       %module%)
4450 <          F90_MODULE_NAMES=lower ;;
4451 <       *)
4452 <          F90_MODULE_NAMES=unknown ;;
4453 < esac
4454 <
4455 < ac_ext=c
4456 < ac_cpp='$CPP $CPPFLAGS'
4457 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4458 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4459 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4460 <
4461 <
4462 < ac_ext=c
4463 < ac_cpp='$CPP $CPPFLAGS'
4464 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4465 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4466 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4467 <
4468 < ac_ext=c
4469 < ac_cpp='$CPP $CPPFLAGS'
4470 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4471 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4472 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4473 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4474 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4475 < # On Suns, sometimes $CPP names a directory.
4476 < if test -n "$CPP" && test -d "$CPP"; then
4477 <  CPP=
4478 < fi
4479 < if test -z "$CPP"; then
4480 <  if test "${ac_cv_prog_CPP+set}" = set; then
10334 > ac_ext=cc
10335 > ac_cpp='$CXXCPP $CPPFLAGS'
10336 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341 > if test -z "$CXXCPP"; then
10342 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10343    echo $ECHO_N "(cached) $ECHO_C" >&6
10344   else
10345 <      # Double quotes because CPP needs to be expanded
10346 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
10345 >      # Double quotes because CXXCPP needs to be expanded
10346 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10347      do
10348        ac_preproc_ok=false
10349 < for ac_c_preproc_warn_flag in '' yes
10349 > for ac_cxx_preproc_warn_flag in '' yes
10350   do
10351    # Use a header file that comes with gcc, so configuring glibc
10352    # with a fresh cross-compiler works.
# Line 4514 | Line 10376 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10376    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377    (exit $ac_status); } >/dev/null; then
10378    if test -s conftest.err; then
10379 <    ac_cpp_err=$ac_c_preproc_warn_flag
10380 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10379 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10380 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10381    else
10382      ac_cpp_err=
10383    fi
# Line 4552 | Line 10414 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10414    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10415    (exit $ac_status); } >/dev/null; then
10416    if test -s conftest.err; then
10417 <    ac_cpp_err=$ac_c_preproc_warn_flag
10418 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10417 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10418 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10419    else
10420      ac_cpp_err=
10421    fi
# Line 4581 | Line 10443 | fi
10443   fi
10444  
10445      done
10446 <    ac_cv_prog_CPP=$CPP
10446 >    ac_cv_prog_CXXCPP=$CXXCPP
10447  
10448   fi
10449 <  CPP=$ac_cv_prog_CPP
10449 >  CXXCPP=$ac_cv_prog_CXXCPP
10450   else
10451 <  ac_cv_prog_CPP=$CPP
10451 >  ac_cv_prog_CXXCPP=$CXXCPP
10452   fi
10453 < echo "$as_me:$LINENO: result: $CPP" >&5
10454 < echo "${ECHO_T}$CPP" >&6
10453 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10454 > echo "${ECHO_T}$CXXCPP" >&6
10455   ac_preproc_ok=false
10456 < for ac_c_preproc_warn_flag in '' yes
10456 > for ac_cxx_preproc_warn_flag in '' yes
10457   do
10458    # Use a header file that comes with gcc, so configuring glibc
10459    # with a fresh cross-compiler works.
# Line 4621 | Line 10483 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10484    (exit $ac_status); } >/dev/null; then
10485    if test -s conftest.err; then
10486 <    ac_cpp_err=$ac_c_preproc_warn_flag
10487 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10486 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10487 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10488 >  else
10489 >    ac_cpp_err=
10490 >  fi
10491 > else
10492 >  ac_cpp_err=yes
10493 > fi
10494 > if test -z "$ac_cpp_err"; then
10495 >  :
10496 > else
10497 >  echo "$as_me: failed program was:" >&5
10498 > sed 's/^/| /' conftest.$ac_ext >&5
10499 >
10500 >  # Broken: fails on valid input.
10501 > continue
10502 > fi
10503 > rm -f conftest.err conftest.$ac_ext
10504 >
10505 >  # OK, works on sane cases.  Now check whether non-existent headers
10506 >  # can be detected and how.
10507 >  cat >conftest.$ac_ext <<_ACEOF
10508 > /* confdefs.h.  */
10509 > _ACEOF
10510 > cat confdefs.h >>conftest.$ac_ext
10511 > cat >>conftest.$ac_ext <<_ACEOF
10512 > /* end confdefs.h.  */
10513 > #include <ac_nonexistent.h>
10514 > _ACEOF
10515 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10516 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10517 >  ac_status=$?
10518 >  grep -v '^ *+' conftest.er1 >conftest.err
10519 >  rm -f conftest.er1
10520 >  cat conftest.err >&5
10521 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10522 >  (exit $ac_status); } >/dev/null; then
10523 >  if test -s conftest.err; then
10524 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10525 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10526 >  else
10527 >    ac_cpp_err=
10528 >  fi
10529 > else
10530 >  ac_cpp_err=yes
10531 > fi
10532 > if test -z "$ac_cpp_err"; then
10533 >  # Broken: success on invalid input.
10534 > continue
10535 > else
10536 >  echo "$as_me: failed program was:" >&5
10537 > sed 's/^/| /' conftest.$ac_ext >&5
10538 >
10539 >  # Passes both tests.
10540 > ac_preproc_ok=:
10541 > break
10542 > fi
10543 > rm -f conftest.err conftest.$ac_ext
10544 >
10545 > done
10546 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10547 > rm -f conftest.err conftest.$ac_ext
10548 > if $ac_preproc_ok; then
10549 >  :
10550 > else
10551 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10552 > See \`config.log' for more details." >&5
10553 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10554 > See \`config.log' for more details." >&2;}
10555 >   { (exit 1); exit 1; }; }
10556 > fi
10557 >
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 >  if test "${ac_cv_header_iostream+set}" = set; then
10658 >  echo "$as_me:$LINENO: checking for iostream" >&5
10659 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660 > if test "${ac_cv_header_iostream+set}" = set; then
10661 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10662 > fi
10663 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665 > else
10666 >  # Is the header compilable?
10667 > echo "$as_me:$LINENO: checking iostream usability" >&5
10668 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669 > cat >conftest.$ac_ext <<_ACEOF
10670 > /* confdefs.h.  */
10671 > _ACEOF
10672 > cat confdefs.h >>conftest.$ac_ext
10673 > cat >>conftest.$ac_ext <<_ACEOF
10674 > /* end confdefs.h.  */
10675 > $ac_includes_default
10676 > #include <iostream>
10677 > _ACEOF
10678 > rm -f conftest.$ac_objext
10679 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10680 >  (eval $ac_compile) 2>conftest.er1
10681 >  ac_status=$?
10682 >  grep -v '^ *+' conftest.er1 >conftest.err
10683 >  rm -f conftest.er1
10684 >  cat conftest.err >&5
10685 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10686 >  (exit $ac_status); } &&
10687 >         { ac_try='test -z "$ac_cxx_werror_flag"
10688 >                         || test ! -s conftest.err'
10689 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10690 >  (eval $ac_try) 2>&5
10691 >  ac_status=$?
10692 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10693 >  (exit $ac_status); }; } &&
10694 >         { ac_try='test -s conftest.$ac_objext'
10695 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10696 >  (eval $ac_try) 2>&5
10697 >  ac_status=$?
10698 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10699 >  (exit $ac_status); }; }; then
10700 >  ac_header_compiler=yes
10701 > else
10702 >  echo "$as_me: failed program was:" >&5
10703 > sed 's/^/| /' conftest.$ac_ext >&5
10704 >
10705 > ac_header_compiler=no
10706 > fi
10707 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10708 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10709 > echo "${ECHO_T}$ac_header_compiler" >&6
10710 >
10711 > # Is the header present?
10712 > echo "$as_me:$LINENO: checking iostream presence" >&5
10713 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714 > cat >conftest.$ac_ext <<_ACEOF
10715 > /* confdefs.h.  */
10716 > _ACEOF
10717 > cat confdefs.h >>conftest.$ac_ext
10718 > cat >>conftest.$ac_ext <<_ACEOF
10719 > /* end confdefs.h.  */
10720 > #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
10724 >  ac_status=$?
10725 >  grep -v '^ *+' conftest.er1 >conftest.err
10726 >  rm -f conftest.er1
10727 >  cat conftest.err >&5
10728 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10729 >  (exit $ac_status); } >/dev/null; then
10730 >  if test -s conftest.err; then
10731 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10732 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10733    else
10734 <    ac_cpp_err=
10735 <  fi
10734 >    ac_cpp_err=
10735 >  fi
10736 > else
10737 >  ac_cpp_err=yes
10738 > fi
10739 > if test -z "$ac_cpp_err"; then
10740 >  ac_header_preproc=yes
10741 > else
10742 >  echo "$as_me: failed program was:" >&5
10743 > sed 's/^/| /' conftest.$ac_ext >&5
10744 >
10745 >  ac_header_preproc=no
10746 > fi
10747 > rm -f conftest.err conftest.$ac_ext
10748 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10749 > echo "${ECHO_T}$ac_header_preproc" >&6
10750 >
10751 > # So?  What about this header?
10752 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753 >  yes:no: )
10754 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758 >    ac_header_preproc=yes
10759 >    ;;
10760 >  no:yes:* )
10761 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773 >    (
10774 >      cat <<\_ASBOX
10775 > ## ------------------------------ ##
10776 > ## Report this to gezelter@nd.edu ##
10777 > ## ------------------------------ ##
10778 > _ASBOX
10779 >    ) |
10780 >      sed "s/^/$as_me: WARNING:     /" >&2
10781 >    ;;
10782 > esac
10783 > echo "$as_me:$LINENO: checking for iostream" >&5
10784 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785 > if test "${ac_cv_header_iostream+set}" = set; then
10786 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10787 > else
10788 >  ac_cv_header_iostream=$ac_header_preproc
10789 > fi
10790 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792 >
10793 > fi
10794 > if test $ac_cv_header_iostream = yes; then
10795 >
10796 >
10797 > cat >>confdefs.h <<\_ACEOF
10798 > #define HAVE_IOSTREAM 1
10799 > _ACEOF
10800 >
10801 >
10802 > else
10803 >
10804 >
10805 > for ac_header in iostream.h
10806 > do
10807 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10809 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10810 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10811 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10812 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10813 > fi
10814 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10815 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10816 > else
10817 >  # Is the header compilable?
10818 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10819 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10820 > cat >conftest.$ac_ext <<_ACEOF
10821 > /* confdefs.h.  */
10822 > _ACEOF
10823 > cat confdefs.h >>conftest.$ac_ext
10824 > cat >>conftest.$ac_ext <<_ACEOF
10825 > /* end confdefs.h.  */
10826 > $ac_includes_default
10827 > #include <$ac_header>
10828 > _ACEOF
10829 > rm -f conftest.$ac_objext
10830 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831 >  (eval $ac_compile) 2>conftest.er1
10832 >  ac_status=$?
10833 >  grep -v '^ *+' conftest.er1 >conftest.err
10834 >  rm -f conftest.er1
10835 >  cat conftest.err >&5
10836 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837 >  (exit $ac_status); } &&
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
10842 >  ac_status=$?
10843 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10844 >  (exit $ac_status); }; } &&
10845 >         { ac_try='test -s conftest.$ac_objext'
10846 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10847 >  (eval $ac_try) 2>&5
10848 >  ac_status=$?
10849 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10850 >  (exit $ac_status); }; }; then
10851 >  ac_header_compiler=yes
10852   else
4630 –  ac_cpp_err=yes
4631 – fi
4632 – if test -z "$ac_cpp_err"; then
4633 –  :
4634 – else
10853    echo "$as_me: failed program was:" >&5
10854   sed 's/^/| /' conftest.$ac_ext >&5
10855  
10856 <  # Broken: fails on valid input.
4639 < continue
10856 > ac_header_compiler=no
10857   fi
10858 < rm -f conftest.err conftest.$ac_ext
10858 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10859 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10860 > echo "${ECHO_T}$ac_header_compiler" >&6
10861  
10862 <  # OK, works on sane cases.  Now check whether non-existent headers
10863 <  # can be detected and how.
10864 <  cat >conftest.$ac_ext <<_ACEOF
10862 > # Is the header present?
10863 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10864 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10865 > cat >conftest.$ac_ext <<_ACEOF
10866   /* confdefs.h.  */
10867   _ACEOF
10868   cat confdefs.h >>conftest.$ac_ext
10869   cat >>conftest.$ac_ext <<_ACEOF
10870   /* end confdefs.h.  */
10871 < #include <ac_nonexistent.h>
10871 > #include <$ac_header>
10872   _ACEOF
10873   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10874    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4659 | 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 4668 | Line 10888 | if test -z "$ac_cpp_err"; then
10888    ac_cpp_err=yes
10889   fi
10890   if test -z "$ac_cpp_err"; then
10891 <  # Broken: success on invalid input.
4672 < continue
10891 >  ac_header_preproc=yes
10892   else
10893    echo "$as_me: failed program was:" >&5
10894   sed 's/^/| /' conftest.$ac_ext >&5
10895  
10896 <  # Passes both tests.
4678 < ac_preproc_ok=:
4679 < break
10896 >  ac_header_preproc=no
10897   fi
10898   rm -f conftest.err conftest.$ac_ext
10899 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10900 + echo "${ECHO_T}$ac_header_preproc" >&6
10901  
10902 < done
10903 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10904 < rm -f conftest.err conftest.$ac_ext
10905 < if $ac_preproc_ok; then
10906 <  :
10902 > # So?  What about this header?
10903 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904 >  yes:no: )
10905 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10907 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10908 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10909 >    ac_header_preproc=yes
10910 >    ;;
10911 >  no:yes:* )
10912 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10913 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10914 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10915 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10916 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10917 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10918 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10919 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10920 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10921 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10922 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10923 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10924 >    (
10925 >      cat <<\_ASBOX
10926 > ## ------------------------------ ##
10927 > ## Report this to gezelter@nd.edu ##
10928 > ## ------------------------------ ##
10929 > _ASBOX
10930 >    ) |
10931 >      sed "s/^/$as_me: WARNING:     /" >&2
10932 >    ;;
10933 > esac
10934 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10935 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10936 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10937 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10938   else
10939 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4690 < See \`config.log' for more details." >&5
4691 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4692 < See \`config.log' for more details." >&2;}
4693 <   { (exit 1); exit 1; }; }
10939 >  eval "$as_ac_Header=\$ac_header_preproc"
10940   fi
10941 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10942 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10943  
10944 < ac_ext=c
10945 < ac_cpp='$CPP $CPPFLAGS'
10946 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10947 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10948 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10944 > fi
10945 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10946 >  cat >>confdefs.h <<_ACEOF
10947 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10948 > _ACEOF
10949  
10950 + fi
10951  
10952 < echo "$as_me:$LINENO: checking for egrep" >&5
10953 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
10954 < if test "${ac_cv_prog_egrep+set}" = set; then
4706 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4707 < else
4708 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4709 <    then ac_cv_prog_egrep='grep -E'
4710 <    else ac_cv_prog_egrep='egrep'
4711 <    fi
10952 > done
10953 >
10954 >
10955   fi
4713 – echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4714 – echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4715 – EGREP=$ac_cv_prog_egrep
10956  
10957  
10958 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10959 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10960 < if test "${ac_cv_header_stdc+set}" = set; then
10958 >
10959 >
10960 >  if test "${ac_cv_header_iomanip+set}" = set; then
10961 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10962 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963 > if test "${ac_cv_header_iomanip+set}" = set; then
10964    echo $ECHO_N "(cached) $ECHO_C" >&6
10965 + fi
10966 + echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967 + echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968   else
10969 <  cat >conftest.$ac_ext <<_ACEOF
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 < #include <stdlib.h>
10979 < #include <stdarg.h>
4731 < #include <string.h>
4732 < #include <float.h>
4733 <
4734 < int
4735 < main ()
4736 < {
4737 <
4738 <  ;
4739 <  return 0;
4740 < }
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
# Line 4748 | Line 10987 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10987    cat conftest.err >&5
10988    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989    (exit $ac_status); } &&
10990 <         { ac_try='test -z "$ac_c_werror_flag"
10990 >         { ac_try='test -z "$ac_cxx_werror_flag"
10991                           || test ! -s conftest.err'
10992    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10993    (eval $ac_try) 2>&5
# Line 4761 | Line 11000 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11000    ac_status=$?
11001    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002    (exit $ac_status); }; }; then
11003 <  ac_cv_header_stdc=yes
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_cv_header_stdc=no
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 < if test $ac_cv_header_stdc = yes; then
11015 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
11016 <  cat >conftest.$ac_ext <<_ACEOF
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 <string.h>
4782 <
11023 > #include <iomanip>
11024   _ACEOF
11025 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11026 <  $EGREP "memchr" >/dev/null 2>&1; then
11027 <  :
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_cv_header_stdc=no
11040 >  ac_cpp_err=yes
11041   fi
11042 < rm -f conftest*
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 < if test $ac_cv_header_stdc = yes; then
11055 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
11056 <  cat >conftest.$ac_ext <<_ACEOF
11057 < /* confdefs.h.  */
11058 < _ACEOF
11059 < cat confdefs.h >>conftest.$ac_ext
11060 < cat >>conftest.$ac_ext <<_ACEOF
11061 < /* end confdefs.h.  */
11062 < #include <stdlib.h>
11063 <
11064 < _ACEOF
11065 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11066 <  $EGREP "free" >/dev/null 2>&1; then
11067 <  :
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_stdc=no
11091 >  ac_cv_header_iomanip=$ac_header_preproc
11092   fi
11093 < rm -f conftest*
11093 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095  
11096   fi
11097 <
4815 < if test $ac_cv_header_stdc = yes; then
4816 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4817 <  if test "$cross_compiling" = yes; then
4818 <  :
4819 < else
4820 <  cat >conftest.$ac_ext <<_ACEOF
4821 < /* confdefs.h.  */
4822 < _ACEOF
4823 < cat confdefs.h >>conftest.$ac_ext
4824 < cat >>conftest.$ac_ext <<_ACEOF
4825 < /* end confdefs.h.  */
4826 < #include <ctype.h>
4827 < #if ((' ' & 0x0FF) == 0x020)
4828 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4829 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4830 < #else
4831 < # define ISLOWER(c) \
4832 <                   (('a' <= (c) && (c) <= 'i') \
4833 <                     || ('j' <= (c) && (c) <= 'r') \
4834 <                     || ('s' <= (c) && (c) <= 'z'))
4835 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4836 < #endif
11097 > if test $ac_cv_header_iomanip = yes; then
11098  
4838 – #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4839 – int
4840 – main ()
4841 – {
4842 –  int i;
4843 –  for (i = 0; i < 256; i++)
4844 –    if (XOR (islower (i), ISLOWER (i))
4845 –        || toupper (i) != TOUPPER (i))
4846 –      exit(2);
4847 –  exit (0);
4848 – }
4849 – _ACEOF
4850 – rm -f conftest$ac_exeext
4851 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4852 –  (eval $ac_link) 2>&5
4853 –  ac_status=$?
4854 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4855 –  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4856 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4857 –  (eval $ac_try) 2>&5
4858 –  ac_status=$?
4859 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4860 –  (exit $ac_status); }; }; then
4861 –  :
4862 – else
4863 –  echo "$as_me: program exited with status $ac_status" >&5
4864 – echo "$as_me: failed program was:" >&5
4865 – sed 's/^/| /' conftest.$ac_ext >&5
11099  
4867 – ( exit $ac_status )
4868 – ac_cv_header_stdc=no
4869 – fi
4870 – rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4871 – fi
4872 – fi
4873 – fi
4874 – echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4875 – echo "${ECHO_T}$ac_cv_header_stdc" >&6
4876 – if test $ac_cv_header_stdc = yes; then
4877 –
11100   cat >>confdefs.h <<\_ACEOF
11101 < #define STDC_HEADERS 1
11101 > #define HAVE_IOMANIP 1
11102   _ACEOF
11103  
4882 – fi
11104  
11105 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
11105 > else
11106  
11107  
11108 <
4888 <
4889 <
4890 <
4891 <
4892 <
4893 <
4894 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4895 <                  inttypes.h stdint.h unistd.h
11108 > for ac_header in iomanip.h
11109   do
11110   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111 < echo "$as_me:$LINENO: checking for $ac_header" >&5
11111 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11112 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11113   echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11114   if eval "test \"\${$as_ac_Header+set}\" = set"; then
11115    echo $ECHO_N "(cached) $ECHO_C" >&6
11116 + fi
11117 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11118 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11119   else
11120 <  cat >conftest.$ac_ext <<_ACEOF
11120 >  # Is the header compilable?
11121 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11122 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11123 > cat >conftest.$ac_ext <<_ACEOF
11124   /* confdefs.h.  */
11125   _ACEOF
11126   cat confdefs.h >>conftest.$ac_ext
11127   cat >>conftest.$ac_ext <<_ACEOF
11128   /* end confdefs.h.  */
11129   $ac_includes_default
4910 –
11130   #include <$ac_header>
11131   _ACEOF
11132   rm -f conftest.$ac_objext
# Line 4919 | 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 4932 | Line 11151 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11151    ac_status=$?
11152    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11153    (exit $ac_status); }; }; then
11154 <  eval "$as_ac_Header=yes"
11154 >  ac_header_compiler=yes
11155   else
11156    echo "$as_me: failed program was:" >&5
11157   sed 's/^/| /' conftest.$ac_ext >&5
11158  
11159 < eval "$as_ac_Header=no"
11159 > ac_header_compiler=no
11160   fi
11161   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11162 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11163 + echo "${ECHO_T}$ac_header_compiler" >&6
11164 +
11165 + # Is the header present?
11166 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
11167 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11168 + cat >conftest.$ac_ext <<_ACEOF
11169 + /* confdefs.h.  */
11170 + _ACEOF
11171 + cat confdefs.h >>conftest.$ac_ext
11172 + cat >>conftest.$ac_ext <<_ACEOF
11173 + /* end confdefs.h.  */
11174 + #include <$ac_header>
11175 + _ACEOF
11176 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11177 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11178 +  ac_status=$?
11179 +  grep -v '^ *+' conftest.er1 >conftest.err
11180 +  rm -f conftest.er1
11181 +  cat conftest.err >&5
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_cxx_preproc_warn_flag
11186 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187 +  else
11188 +    ac_cpp_err=
11189 +  fi
11190 + else
11191 +  ac_cpp_err=yes
11192   fi
11193 + if test -z "$ac_cpp_err"; then
11194 +  ac_header_preproc=yes
11195 + else
11196 +  echo "$as_me: failed program was:" >&5
11197 + sed 's/^/| /' conftest.$ac_ext >&5
11198 +
11199 +  ac_header_preproc=no
11200 + fi
11201 + rm -f conftest.err conftest.$ac_ext
11202 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11203 + echo "${ECHO_T}$ac_header_preproc" >&6
11204 +
11205 + # So?  What about this header?
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;}
11210 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11211 + echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11212 +    ac_header_preproc=yes
11213 +    ;;
11214 +  no:yes:* )
11215 +    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11216 + echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11217 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11218 + echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11219 +    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11220 + echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11221 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11222 + echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11223 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11224 + echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11225 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11226 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11227 +    (
11228 +      cat <<\_ASBOX
11229 + ## ------------------------------ ##
11230 + ## Report this to gezelter@nd.edu ##
11231 + ## ------------------------------ ##
11232 + _ASBOX
11233 +    ) |
11234 +      sed "s/^/$as_me: WARNING:     /" >&2
11235 +    ;;
11236 + esac
11237 + echo "$as_me:$LINENO: checking for $ac_header" >&5
11238 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11239 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
11240 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11241 + else
11242 +  eval "$as_ac_Header=\$ac_header_preproc"
11243 + fi
11244   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11245   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11246 +
11247 + fi
11248   if test `eval echo '${'$as_ac_Header'}'` = yes; then
11249    cat >>confdefs.h <<_ACEOF
11250   #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
# Line 4953 | Line 11255 | done
11255   done
11256  
11257  
11258 + fi
11259  
11260  
11261  
11262  
11263 <
4961 <
4962 <
4963 <
4964 <
4965 < for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
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 4995 | 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 5039 | 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 5060 | Line 11358 | echo "${ECHO_T}$ac_header_preproc" >&6
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 5114 | Line 11412 | done
11412  
11413  
11414  
11415 <
11416 <
11417 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
5120 < do
5121 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5122 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5123 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5124 < 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.  */
5133 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5134 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5135 – #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.
5139 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5140 <    <limits.h> exists even on freestanding compilers.  */
5141 <
5142 < #ifdef __STDC__
5143 < # 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
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
11452 > #endif
11453 > int
11454 > main ()
11455 > {
11456 > std::cout<<"Hello World"<<std::endl;return 0;
11457 >  ;
11458 >  return 0;
11459 > }
11460 > _ACEOF
11461 > rm -f conftest.$ac_objext
11462 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11463 >  (eval $ac_compile) 2>conftest.er1
11464 >  ac_status=$?
11465 >  grep -v '^ *+' conftest.er1 >conftest.err
11466 >  rm -f conftest.er1
11467 >  cat conftest.err >&5
11468 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469 >  (exit $ac_status); } &&
11470 >         { ac_try='test -z "$ac_cxx_werror_flag"
11471 >                         || test ! -s conftest.err'
11472 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473 >  (eval $ac_try) 2>&5
11474 >  ac_status=$?
11475 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11476 >  (exit $ac_status); }; } &&
11477 >         { ac_try='test -s conftest.$ac_objext'
11478 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11479 >  (eval $ac_try) 2>&5
11480 >  ac_status=$?
11481 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482 >  (exit $ac_status); }; }; then
11483 >  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  
11488 < /* Override any gcc2 internal prototype to avoid an error.  */
11489 < #ifdef __cplusplus
11490 < extern "C"
11491 < {
11492 < #endif
11493 < /* We use char because int might match the return type of a gcc2
11494 <   builtin and then its argument prototype would still apply.  */
11495 < char $ac_func ();
11496 < /* The GNU C library defines this for functions which it implements
11497 <    to always fail with ENOSYS.  Some functions are actually named
11498 <    something starting with __ and the normal name is an alias.  */
11499 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5162 < choke me
11488 > fi
11489 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11490 >        cat >conftest.$ac_ext <<_ACEOF
11491 > /* confdefs.h.  */
11492 > _ACEOF
11493 > cat confdefs.h >>conftest.$ac_ext
11494 > cat >>conftest.$ac_ext <<_ACEOF
11495 > /* end confdefs.h.  */
11496 >
11497 > #define __USE_STD_IOSTREAM 1
11498 > #ifdef HAVE_IOSTREAM
11499 > #include <iostream>
11500   #else
11501 < char (*f) () = $ac_func;
11501 > #include <iostream.h>
11502   #endif
5166 – #ifdef __cplusplus
5167 – }
5168 – #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 < return f != $ac_func;
11515 > std::cout<<"Hello World"<<std::endl;return 0;
11516    ;
11517    return 0;
11518   }
11519   _ACEOF
11520 < rm -f conftest.$ac_objext conftest$ac_exeext
11521 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11522 <  (eval $ac_link) 2>conftest.er1
11520 > rm -f conftest.$ac_objext
11521 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11522 >  (eval $ac_compile) 2>conftest.er1
11523    ac_status=$?
11524    grep -v '^ *+' conftest.er1 >conftest.err
11525    rm -f conftest.er1
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
11533    ac_status=$?
11534    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11535    (exit $ac_status); }; } &&
11536 <         { ac_try='test -s conftest$ac_exeext'
11536 >         { ac_try='test -s conftest.$ac_objext'
11537    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11538    (eval $ac_try) 2>&5
11539    ac_status=$?
11540    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541    (exit $ac_status); }; }; then
11542 <  eval "$as_ac_var=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  
5205 – eval "$as_ac_var=no"
11547   fi
11548 < rm -f conftest.err conftest.$ac_objext \
11549 <      conftest$ac_exeext conftest.$ac_ext
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: `eval echo '${'$as_ac_var'}'`" >&5
11559 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11560 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11561 <  cat >>confdefs.h <<_ACEOF
11562 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11558 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11559 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11560 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11561 >
11562 > cat >>confdefs.h <<\_ACEOF
11563 > #define HAVE_STD_IOSTREAM 1
11564   _ACEOF
11565  
11566 < fi
11567 < done
11566 >  fi
11567 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568  
11569 < # special check for _system_configuration because AIX <4.3.2 do not
11570 < # contain the `physmem' member.
11571 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11572 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
11573 < cat >conftest.$ac_ext <<_ACEOF
11569 > cat >>confdefs.h <<\_ACEOF
11570 > #define __USE_STD_IOSTREAM 1
11571 > _ACEOF
11572 >
11573 >  fi
11574 >
11575 >
11576 >
11577 >
11578 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11582 > else
11583 >
11584 >      ac_cv_cxx_have_std_stl=no
11585 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11586 >
11587 >
11588 >        ac_ext=cc
11589 > ac_cpp='$CXXCPP $CPPFLAGS'
11590 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593 >
11594 >        cat >conftest.$ac_ext <<_ACEOF
11595   /* confdefs.h.  */
11596   _ACEOF
11597   cat confdefs.h >>conftest.$ac_ext
11598   cat >>conftest.$ac_ext <<_ACEOF
11599   /* end confdefs.h.  */
11600 < #include <sys/systemcfg.h>
11600 > #include <list>
11601 >
11602 > #ifdef FC_DUMMY_MAIN
11603 > #ifndef FC_DUMMY_MAIN_EQ_F77
11604 > #  ifdef __cplusplus
11605 >     extern "C"
11606 > #  endif
11607 >   int FC_DUMMY_MAIN() { return 1; }
11608 > #endif
11609 > #endif
11610   int
11611   main ()
11612   {
11613 < double x = _system_configuration.physmem;
11613 > std::list<int> foo;return 0;
11614    ;
11615    return 0;
11616   }
# Line 5245 | 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 5258 | 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 <  echo "$as_me:$LINENO: result: yes" >&5
11641 < echo "${ECHO_T}yes" >&6
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  
11645 + fi
11646 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647 +        ac_ext=cc
11648 + ac_cpp='$CXXCPP $CPPFLAGS'
11649 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652 +
11653 +      fi
11654 +
11655 + fi
11656 + echo "$as_me:$LINENO: result: $ac_cv_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__SYSTEM_CONFIGURATION 1
11661 > #define HAVE_STD_STL 1
11662   _ACEOF
11663  
11664 +  fi
11665 +
11666 +
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 +
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 + int fd=0;ofstream s;s.attach(fd);
11711 +  ;
11712 +  return 0;
11713 + }
11714 + _ACEOF
11715 + rm -f conftest.$ac_objext
11716 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11717 +  (eval $ac_compile) 2>conftest.er1
11718 +  ac_status=$?
11719 +  grep -v '^ *+' conftest.er1 >conftest.err
11720 +  rm -f conftest.er1
11721 +  cat conftest.err >&5
11722 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723 +  (exit $ac_status); } &&
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
11728 +  ac_status=$?
11729 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11730 +  (exit $ac_status); }; } &&
11731 +         { ac_try='test -s conftest.$ac_objext'
11732 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11733 +  (eval $ac_try) 2>&5
11734 +  ac_status=$?
11735 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736 +  (exit $ac_status); }; }; then
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  
5272 – echo "$as_me:$LINENO: result: no" >&5
5273 – echo "${ECHO_T}no" >&6
11742   fi
11743   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744 +    ac_ext=cc
11745 + ac_cpp='$CXXCPP $CPPFLAGS'
11746 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749  
5277 –  # clean out junk possibly left behind by a previous configuration
5278 –  rm -f src/getopt.h
5279 –  # Check for getopt_long support
11750  
11751 < for ac_header in getopt.h
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 > 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 >
11770 >    ac_cv_cxx_have_fstream_open=no
11771 >    ac_cv_cxx_fstream_open_prot=no
11772 >
11773 >
11774 >    ac_ext=cc
11775 > ac_cpp='$CXXCPP $CPPFLAGS'
11776 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779 >
11780 >    # Try with 2 parameters
11781 >    cat >conftest.$ac_ext <<_ACEOF
11782 > /* confdefs.h.  */
11783 > _ACEOF
11784 > cat confdefs.h >>conftest.$ac_ext
11785 > cat >>conftest.$ac_ext <<_ACEOF
11786 > /* end confdefs.h.  */
11787 >
11788 > #ifdef HAVE_IOSTREAM
11789 > #include <fstream>
11790 > #else
11791 > #include <fstream.h>
11792 > #endif
11793 > #ifdef HAVE_STD_IOSTREAM
11794 > using namespace std;
11795 > #endif
11796 >
11797 > #ifdef FC_DUMMY_MAIN
11798 > #ifndef FC_DUMMY_MAIN_EQ_F77
11799 > #  ifdef __cplusplus
11800 >     extern "C"
11801 > #  endif
11802 >   int FC_DUMMY_MAIN() { return 1; }
11803 > #endif
11804 > #endif
11805 > int
11806 > main ()
11807 > {
11808 > 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
11815 >  (eval $ac_compile) 2>conftest.er1
11816 >  ac_status=$?
11817 >  grep -v '^ *+' conftest.er1 >conftest.err
11818 >  rm -f conftest.er1
11819 >  cat conftest.err >&5
11820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821 >  (exit $ac_status); } &&
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
11826 >  ac_status=$?
11827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11828 >  (exit $ac_status); }; } &&
11829 >         { ac_try='test -s conftest.$ac_objext'
11830 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11831 >  (eval $ac_try) 2>&5
11832 >  ac_status=$?
11833 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834 >  (exit $ac_status); }; }; then
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 >    # Try with mode parameter
11843 >    cat >conftest.$ac_ext <<_ACEOF
11844 > /* confdefs.h.  */
11845 > _ACEOF
11846 > cat confdefs.h >>conftest.$ac_ext
11847 > cat >>conftest.$ac_ext <<_ACEOF
11848 > /* end confdefs.h.  */
11849 >
11850 > #ifdef HAVE_IOSTREAM
11851 > #include <fstream>
11852 > #else
11853 > #include <fstream.h>
11854 > #endif
11855 > #ifdef HAVE_STD_IOSTREAM
11856 > using namespace std;
11857 > #endif
11858 >
11859 > #ifdef FC_DUMMY_MAIN
11860 > #ifndef FC_DUMMY_MAIN_EQ_F77
11861 > #  ifdef __cplusplus
11862 >     extern "C"
11863 > #  endif
11864 >   int FC_DUMMY_MAIN() { return 1; }
11865 > #endif
11866 > #endif
11867 > int
11868 > main ()
11869 > {
11870 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871 >  ;
11872 >  return 0;
11873 > }
11874 > _ACEOF
11875 > rm -f conftest.$ac_objext
11876 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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_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_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 >  ac_cv_cxx_fstream_open_prot=yes
11898 > else
11899 >  echo "$as_me: failed program was:" >&5
11900 > sed 's/^/| /' conftest.$ac_ext >&5
11901 >
11902 > fi
11903 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904 >    ac_ext=cc
11905 > ac_cpp='$CXXCPP $CPPFLAGS'
11906 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909 >
11910 >
11911 > fi
11912 > echo "$as_me:$LINENO: result: $ac_cv_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 >  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 >  fi
11928 >
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 5311 | 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 5355 | 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 5376 | Line 12030 | echo "${ECHO_T}$ac_header_preproc" >&6
12030   echo "${ECHO_T}$ac_header_preproc" >&6
12031  
12032   # So?  What about this header?
12033 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12033 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12034    yes:no: )
12035      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12036   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 5427 | 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
5435 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5436 < 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
12098   /* confdefs.h.  */
12099 < _ACEOF
12100 < cat confdefs.h >>conftest.$ac_ext
12101 < cat >>conftest.$ac_ext <<_ACEOF
12102 < /* end confdefs.h.  */
5445 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5446 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5447 < #define $ac_func innocuous_$ac_func
5448 <
5449 < /* System header to define __stub macros and hopefully few prototypes,
5450 <    which can conflict with char $ac_func (); below.
5451 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5452 <    <limits.h> exists even on freestanding compilers.  */
12099 > _ACEOF
12100 > cat confdefs.h >>conftest.$ac_ext
12101 > cat >>conftest.$ac_ext <<_ACEOF
12102 > /* end confdefs.h.  */
12103  
12104 < #ifdef __STDC__
12105 < # include <limits.h>
12106 < #else
12107 < # include <assert.h>
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
5459 –
5460 – #undef $ac_func
5461 –
5462 – /* Override any gcc2 internal prototype to avoid an error.  */
5463 – #ifdef __cplusplus
5464 – extern "C"
5465 – {
12111   #endif
5467 – /* We use char because int might match the return type of a gcc2
5468 –   builtin and then its argument prototype would still apply.  */
5469 – char $ac_func ();
5470 – /* The GNU C library defines this for functions which it implements
5471 –    to always fail with ENOSYS.  Some functions are actually named
5472 –    something starting with __ and the normal name is an alias.  */
5473 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5474 – choke me
5475 – #else
5476 – char (*f) () = $ac_func;
5477 – #endif
5478 – #ifdef __cplusplus
5479 – }
5480 – #endif
5481 –
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  
5517 – eval "$as_ac_var=no"
5518 – fi
5519 – rm -f conftest.err conftest.$ac_objext \
5520 –      conftest$ac_exeext conftest.$ac_ext
5521 – fi
5522 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5523 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5524 – if test `eval echo '${'$as_ac_var'}'` = yes; then
5525 –  cat >>confdefs.h <<_ACEOF
5526 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5527 – _ACEOF
5528 –
5529 – else
5530 –  # FreeBSD has a gnugetopt library for this
5531 –    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5532 – echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5533 – if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5534 –  echo $ECHO_N "(cached) $ECHO_C" >&6
5535 – else
5536 –  ac_check_lib_save_LIBS=$LIBS
5537 – LIBS="-lgnugetopt  $LIBS"
12147   cat >conftest.$ac_ext <<_ACEOF
12148   /* confdefs.h.  */
12149   _ACEOF
# Line 5542 | 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
5550 <   builtin and then its argument prototype would still apply.  */
5551 < 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 \
5590 <      conftest$ac_exeext conftest.$ac_ext
5591 < 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
5601 <  # use the GNU replacement
5602 <      case $LIBOBJS in
5603 <    "getopt.$ac_objext"   | \
5604 <  *" getopt.$ac_objext"   | \
5605 <    "getopt.$ac_objext "* | \
5606 <  *" getopt.$ac_objext "* ) ;;
5607 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5608 < esac
12211 > elif test $ac_cv_cpp_func = no; then
12212  
12213 <      case $LIBOBJS in
12214 <    "getopt1.$ac_objext"   | \
12215 <  *" getopt1.$ac_objext"   | \
5613 <    "getopt1.$ac_objext "* | \
5614 <  *" getopt1.$ac_objext "* ) ;;
5615 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5616 < esac
12213 > cat >>confdefs.h <<\_ACEOF
12214 > #define __func__ ""
12215 > _ACEOF
12216  
5618 –                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5619 –
12217   fi
12218  
5622 – fi
5623 – done
12219  
12220  
12221  
12222 +
12223   case $debug in
12224    1)
12225       ;;
# Line 5632 | 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 5642 | 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 5680 | 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 5710 | 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 5723 | Line 12435 | if test "$ac_test_CFLAGS" != "set"; then
12435      # -malign-double for x86 systems
12436  
12437  
12438 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12439 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12438 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12439 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12440   if test "${ac_align_double+set}" = set; then
12441    echo $ECHO_N "(cached) $ECHO_C" >&6
12442   else
12443    echo 'void f(){}' > conftest.c
12444 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12444 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12445          ac_align_double=yes
12446   else
12447          ac_align_double=no
# Line 5750 | Line 12462 | fi
12462      # -fstrict-aliasing for gcc-2.95+
12463  
12464  
12465 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12466 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12465 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12466 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12467   if test "${ac_fstrict_aliasing+set}" = set; then
12468    echo $ECHO_N "(cached) $ECHO_C" >&6
12469   else
12470    echo 'void f(){}' > conftest.c
12471 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12471 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12472          ac_fstrict_aliasing=yes
12473   else
12474          ac_fstrict_aliasing=no
# Line 5781 | Line 12493 | fi
12493                    case "${host_cpu}" in
12494            i586*)
12495  
12496 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12497 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12496 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12497 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12498   if test "${ac_cpu_pentium+set}" = set; then
12499    echo $ECHO_N "(cached) $ECHO_C" >&6
12500   else
12501    echo 'void f(){}' > conftest.c
12502 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12502 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12503          ac_cpu_pentium=yes
12504   else
12505          ac_cpu_pentium=no
# Line 5804 | Line 12516 | else
12516          :
12517  
12518  
12519 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12520 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12519 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12520 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12521   if test "${ac_pentium+set}" = set; then
12522    echo $ECHO_N "(cached) $ECHO_C" >&6
12523   else
12524    echo 'void f(){}' > conftest.c
12525 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12525 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12526          ac_pentium=yes
12527   else
12528          ac_pentium=no
# Line 5833 | Line 12545 | fi
12545                    ;;
12546            i686*)
12547  
12548 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12549 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12548 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12549 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12550   if test "${ac_cpu_pentiumpro+set}" = set; then
12551    echo $ECHO_N "(cached) $ECHO_C" >&6
12552   else
12553    echo 'void f(){}' > conftest.c
12554 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12554 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12555          ac_cpu_pentiumpro=yes
12556   else
12557          ac_cpu_pentiumpro=no
# Line 5856 | Line 12568 | else
12568          :
12569  
12570  
12571 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12572 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12571 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12572 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12573   if test "${ac_pentiumpro+set}" = set; then
12574    echo $ECHO_N "(cached) $ECHO_C" >&6
12575   else
12576    echo 'void f(){}' > conftest.c
12577 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12577 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12578          ac_pentiumpro=yes
12579   else
12580          ac_pentiumpro=no
# Line 5889 | Line 12601 | fi
12601                  if test -n "$is60x"; then
12602  
12603  
12604 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12605 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12604 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12605 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12606   if test "${ac_m_cpu_60x+set}" = set; then
12607    echo $ECHO_N "(cached) $ECHO_C" >&6
12608   else
12609    echo 'void f(){}' > conftest.c
12610 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12610 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12611          ac_m_cpu_60x=yes
12612   else
12613          ac_m_cpu_60x=no
# Line 5947 | Line 12659 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12659          :
12660  
12661  
12662 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12663 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12662 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12663 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12664   if test "${ac_m_cpu_750+set}" = set; then
12665    echo $ECHO_N "(cached) $ECHO_C" >&6
12666   else
12667    echo 'void f(){}' > conftest.c
12668 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12668 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12669          ac_m_cpu_750=yes
12670   else
12671          ac_m_cpu_750=no
# Line 5980 | Line 12692 | fi
12692                  if test -z "$CPU_FLAGS"; then
12693  
12694  
12695 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12696 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12695 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12696 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12697   if test "${ac_m_cpu_powerpc+set}" = set; then
12698    echo $ECHO_N "(cached) $ECHO_C" >&6
12699   else
12700    echo 'void f(){}' > conftest.c
12701 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12701 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12702          ac_m_cpu_powerpc=yes
12703   else
12704          ac_m_cpu_powerpc=no
# Line 6008 | Line 12720 | fi
12720                  if test -z "$CPU_FLAGS"; then
12721  
12722  
12723 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12724 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12723 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12724 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12725   if test "${ac_m_powerpc+set}" = set; then
12726    echo $ECHO_N "(cached) $ECHO_C" >&6
12727   else
12728    echo 'void f(){}' > conftest.c
12729 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12729 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12730          ac_m_powerpc=yes
12731   else
12732          ac_m_powerpc=no
# Line 6053 | Line 12765 | fi
12765  
12766  
12767  
12768 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12769 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12768 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12769 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12770   if test "${ac_guessed_cflags+set}" = set; then
12771    echo $ECHO_N "(cached) $ECHO_C" >&6
12772   else
12773    echo 'void f(){}' > conftest.c
12774 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12774 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12775          ac_guessed_cflags=yes
12776   else
12777          ac_guessed_cflags=no
# Line 6103 | 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 6141 | 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 6162 | 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 6175 | Line 12892 | if test "$ac_test_CXXFLAGS" != "set"; then
12892      # -malign-double for x86 systems
12893  
12894  
12895 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12896 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12895 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12896 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12897   if test "${ac_align_double+set}" = set; then
12898    echo $ECHO_N "(cached) $ECHO_C" >&6
12899   else
12900    echo 'void f(){}' > conftest.cpp
12901 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12901 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12902          ac_align_double=yes
12903   else
12904          ac_align_double=no
# Line 6202 | Line 12919 | fi
12919      # -fstrict-aliasing for gcc-2.95+
12920  
12921  
12922 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12923 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12922 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12923 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12924   if test "${ac_fstrict_aliasing+set}" = set; then
12925    echo $ECHO_N "(cached) $ECHO_C" >&6
12926   else
12927    echo 'void f(){}' > conftest.cpp
12928 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12928 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12929          ac_fstrict_aliasing=yes
12930   else
12931          ac_fstrict_aliasing=no
# Line 6233 | Line 12950 | fi
12950                    case "${host_cpu}" in
12951            i586*)
12952  
12953 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12954 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12953 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12954 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12955   if test "${ac_cpu_pentium+set}" = set; then
12956    echo $ECHO_N "(cached) $ECHO_C" >&6
12957   else
12958    echo 'void f(){}' > conftest.cpp
12959 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12959 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12960          ac_cpu_pentium=yes
12961   else
12962          ac_cpu_pentium=no
# Line 6256 | Line 12973 | else
12973          :
12974  
12975  
12976 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12977 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12976 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12977 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12978   if test "${ac_pentium+set}" = set; then
12979    echo $ECHO_N "(cached) $ECHO_C" >&6
12980   else
12981    echo 'void f(){}' > conftest.cpp
12982 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12982 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12983          ac_pentium=yes
12984   else
12985          ac_pentium=no
# Line 6285 | Line 13002 | fi
13002                    ;;
13003            i686*)
13004  
13005 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13006 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13005 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13006 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13007   if test "${ac_cpu_pentiumpro+set}" = set; then
13008    echo $ECHO_N "(cached) $ECHO_C" >&6
13009   else
13010    echo 'void f(){}' > conftest.cpp
13011 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13011 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13012          ac_cpu_pentiumpro=yes
13013   else
13014          ac_cpu_pentiumpro=no
# Line 6308 | Line 13025 | else
13025          :
13026  
13027  
13028 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13029 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13028 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13029 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13030   if test "${ac_pentiumpro+set}" = set; then
13031    echo $ECHO_N "(cached) $ECHO_C" >&6
13032   else
13033    echo 'void f(){}' > conftest.cpp
13034 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13034 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13035          ac_pentiumpro=yes
13036   else
13037          ac_pentiumpro=no
# Line 6341 | Line 13058 | fi
13058                  if test -n "$is60x"; then
13059  
13060  
13061 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13062 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13061 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063   if test "${ac_m_cpu_60x+set}" = set; then
13064    echo $ECHO_N "(cached) $ECHO_C" >&6
13065   else
13066    echo 'void f(){}' > conftest.cpp
13067 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13067 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068          ac_m_cpu_60x=yes
13069   else
13070          ac_m_cpu_60x=no
13071 < fi
13072 < rm -f conftest*
6356 <
6357 < fi
6358 < echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
6359 < echo "${ECHO_T}$ac_m_cpu_60x" >&6
6360 < if test "$ac_m_cpu_60x" = yes; then
6361 <        :
6362 <        CPU_FLAGS=-mcpu=$cputype
6363 < else
6364 <        :
6365 <
6366 < fi
6367 <
6368 <                elif test "$cputype" = 750; then
6369 <
6370 <
6371 < echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
6372 < echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
6373 < if test "${ac_cv_prog_gxx_2_95+set}" = set; then
6374 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6375 < else
6376 <
6377 < cat > conftest.cpp <<EOF
6378 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
6379 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
6380 <     yes;
6381 < #  endif
6382 < #endif
6383 < EOF
6384 < if { ac_try='${CXX-c++} -E conftest.cpp'
6385 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6386 <  (eval $ac_try) 2>&5
6387 <  ac_status=$?
6388 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6389 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
6390 <  ac_cv_prog_gxx_2_95=yes
6391 < else
6392 <  ac_cv_prog_gxx_2_95=no
6393 < fi
6394 <
6395 < fi
6396 < echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
6397 < echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
6398 < if test "$ac_cv_prog_gxx_2_95" = yes; then
6399 <        :
6400 <
6401 <
6402 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
6403 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
6404 < if test "${ac_m_cpu_750+set}" = set; then
6405 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6406 < else
6407 <  echo 'void f(){}' > conftest.cpp
6408 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
6409 <        ac_m_cpu_750=yes
6410 < else
6411 <        ac_m_cpu_750=no
6412 < fi
6413 < rm -f conftest*
6414 <
6415 < fi
6416 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
6417 < echo "${ECHO_T}$ac_m_cpu_750" >&6
6418 < if test "$ac_m_cpu_750" = yes; then
6419 <        :
6420 <        CPU_FLAGS=-mcpu=750
6421 < else
6422 <        :
6423 <
6424 < fi
6425 <
6426 < else
6427 <        :
6428 <
6429 < fi
6430 <
6431 <                fi
6432 <                if test -z "$CPU_FLAGS"; then
6433 <
6434 <
6435 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
6436 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
6437 < if test "${ac_m_cpu_powerpc+set}" = set; then
6438 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6439 < else
6440 <  echo 'void f(){}' > conftest.cpp
6441 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
6442 <        ac_m_cpu_powerpc=yes
6443 < else
6444 <        ac_m_cpu_powerpc=no
6445 < fi
6446 < rm -f conftest*
6447 <
6448 < fi
6449 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
6450 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
6451 < if test "$ac_m_cpu_powerpc" = yes; then
6452 <        :
6453 <        CPU_FLAGS=-mcpu=powerpc
6454 < else
6455 <        :
6456 <
6457 < fi
6458 <
6459 <                fi
6460 <                if test -z "$CPU_FLAGS"; then
6461 <
6462 <
6463 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
6464 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
6465 < if test "${ac_m_powerpc+set}" = set; then
6466 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6467 < else
6468 <  echo 'void f(){}' > conftest.cpp
6469 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
6470 <        ac_m_powerpc=yes
6471 < else
6472 <        ac_m_powerpc=no
6473 < fi
6474 < rm -f conftest*
6475 <
6476 < fi
6477 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
6478 < echo "${ECHO_T}$ac_m_powerpc" >&6
6479 < if test "$ac_m_powerpc" = yes; then
6480 <        :
6481 <        CPU_FLAGS=-mpowerpc
6482 < else
6483 <        :
6484 <
6485 < fi
6486 <
6487 <                fi
6488 <          esac
6489 <  fi
6490 <
6491 <  if test -n "$CPU_FLAGS"; then
6492 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6493 <  fi
6494 <
6495 <  if test -z "$CXXFLAGS"; then
6496 <        echo ""
6497 <        echo "**********************************************************"
6498 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6499 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6500 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6501 <        echo "**********************************************************"
6502 <        echo ""
6503 <        CXXFLAGS="-O3"
6504 <  fi
6505 <
6506 <
6507 <
6508 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6509 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6510 < if test "${ac_guessed_cxxflags+set}" = set; then
6511 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6512 < else
6513 <  echo 'void f(){}' > conftest.cpp
6514 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6515 <        ac_guessed_cxxflags=yes
6516 < else
6517 <        ac_guessed_cxxflags=no
6518 < fi
6519 < rm -f conftest*
6520 <
6521 < fi
6522 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6523 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6524 < if test "$ac_guessed_cxxflags" = yes; then
6525 <        :
6526 <
6527 < else
6528 <        :
6529 <
6530 <        echo ""
6531 <        echo "**********************************************************"
6532 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6533 <        echo "* your compiler.                                         *"
6534 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6535 <        echo "**********************************************************"
6536 <        echo ""
6537 <        CXXFLAGS=""
6538 <
6539 < fi
6540 <
6541 <
6542 < fi
6543 <
6544 <
6545 <
6546 <
6547 <
6548 < # Try to determine "good" native compiler flags if none specified on command
6549 < # line
6550 <
6551 < if test x"$F90FLAGS" = x ; then
6552 <  F90FLAGS=""
6553 <  case "${host_cpu}-${host_os}" in
6554 <
6555 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6556 <                    F90FLAGS="-O"
6557 <                fi;;
6558 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6559 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6560 <                fi;;
6561 <   powerpc*-aix*)
6562 <        if test "$F90" = f90 -o "$F90" = xlf90; then
6563 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6564 <                echo "*******************************************************"
6565 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6566 <                echo "*  recommended that you use                           *"
6567 <                echo "*                                                     *"
6568 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6569 <                echo "*                                 ^^^                 *"
6570 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6571 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6572 <                echo "*******************************************************"
6573 <        fi;;
6574 <   *darwin*)
6575 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6576 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6577 <        fi;;
6578 <  esac
6579 <
6580 <  if test -n "$CPU_FLAGS"; then
6581 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6582 <  fi
6583 <
6584 <  if test -z "$F90FLAGS"; then
6585 <        echo ""
6586 <        echo "**********************************************************"
6587 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6588 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6589 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6590 <        echo "**********************************************************"
6591 <        echo ""
6592 <        F90FLAGS="-O3"
6593 <  fi
6594 <
6595 <
6596 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6597 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6598 < if test "${ac_guessed_f90flags+set}" = set; then
6599 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6600 < else
6601 <
6602 <
6603 <
6604 < ac_ext=f90
6605 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6606 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6607 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6608 <
6609 < echo 'program main' > conftest.$ac_ext
6610 < echo 'end program main' >> conftest.$ac_ext
6611 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6612 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6613 <  (eval $ac_compile) 2>&5
6614 <  ac_status=$?
6615 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6616 <  (exit $ac_status); }; then
6617 <        ac_guessed_f90flags=yes
6618 < else
6619 <        ac_guessed_f90flags=no
6620 < fi
6621 < rm -f conftest*
6622 < ac_ext=c
6623 < ac_cpp='$CPP $CPPFLAGS'
6624 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6625 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6626 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6627 <
6628 <
6629 < fi
6630 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6631 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
6632 < if test "$ac_guessed_f90flags" = yes; then
6633 <        :
6634 <
6635 < else
6636 <        :
6637 <
6638 <        echo ""
6639 <        echo "**********************************************************"
6640 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6641 <        echo "* your compiler.                                         *"
6642 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6643 <        echo "**********************************************************"
6644 <        echo ""
6645 <        F90FLAGS=""
6646 <
6647 < fi
6648 <
6649 <
6650 < fi
6651 <
6652 <     ;;
6653 < esac
6654 <
6655 < # Find a good install program.  We prefer a C program (faster),
6656 < # so one script is as good as another.  But avoid the broken or
6657 < # incompatible versions:
6658 < # SysV /etc/install, /usr/sbin/install
6659 < # SunOS /usr/etc/install
6660 < # IRIX /sbin/install
6661 < # AIX /bin/install
6662 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6663 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6664 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6665 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6666 < # OS/2's system install, which has a completely different semantic
6667 < # ./install, which can be erroneously created by make from ./install.sh.
6668 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6669 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6670 < if test -z "$INSTALL"; then
6671 < if test "${ac_cv_path_install+set}" = set; then
6672 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6673 < else
6674 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6675 < for as_dir in $PATH
6676 < do
6677 <  IFS=$as_save_IFS
6678 <  test -z "$as_dir" && as_dir=.
6679 <  # Account for people who put trailing slashes in PATH elements.
6680 < case $as_dir/ in
6681 <  ./ | .// | /cC/* | \
6682 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6683 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6684 <  /usr/ucb/* ) ;;
6685 <  *)
6686 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6687 <    # Don't use installbsd from OSF since it installs stuff as root
6688 <    # by default.
6689 <    for ac_prog in ginstall scoinst install; do
6690 <      for ac_exec_ext in '' $ac_executable_extensions; do
6691 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6692 <          if test $ac_prog = install &&
6693 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6694 <            # AIX install.  It has an incompatible calling convention.
6695 <            :
6696 <          elif test $ac_prog = install &&
6697 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6698 <            # program-specific install script used by HP pwplus--don't use.
6699 <            :
6700 <          else
6701 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6702 <            break 3
6703 <          fi
6704 <        fi
6705 <      done
6706 <    done
6707 <    ;;
6708 < esac
6709 < done
6710 <
6711 <
6712 < fi
6713 <  if test "${ac_cv_path_install+set}" = set; then
6714 <    INSTALL=$ac_cv_path_install
6715 <  else
6716 <    # As a last resort, use the slow shell script.  We don't cache a
6717 <    # path for INSTALL within a source directory, because that will
6718 <    # break other packages using the cache if that directory is
6719 <    # removed, or if the path is relative.
6720 <    INSTALL=$ac_install_sh
6721 <  fi
6722 < fi
6723 < echo "$as_me:$LINENO: result: $INSTALL" >&5
6724 < echo "${ECHO_T}$INSTALL" >&6
6725 <
6726 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6727 < # It thinks the first close brace ends the variable substitution.
6728 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6729 <
6730 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6731 <
6732 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6733 <
6734 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
6735 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6736 < LN_S=$as_ln_s
6737 < if test "$LN_S" = "ln -s"; then
6738 <  echo "$as_me:$LINENO: result: yes" >&5
6739 < echo "${ECHO_T}yes" >&6
6740 < else
6741 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6742 < echo "${ECHO_T}no, using $LN_S" >&6
6743 < fi
6744 <
6745 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6746 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6747 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6748 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6749 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6750 < else
6751 <  cat >conftest.make <<\_ACEOF
6752 < all:
6753 <        @echo 'ac_maketemp="$(MAKE)"'
6754 < _ACEOF
6755 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6756 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6757 < if test -n "$ac_maketemp"; then
6758 <  eval ac_cv_prog_make_${ac_make}_set=yes
6759 < else
6760 <  eval ac_cv_prog_make_${ac_make}_set=no
6761 < fi
6762 < rm -f conftest.make
6763 < fi
6764 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6765 <  echo "$as_me:$LINENO: result: yes" >&5
6766 < echo "${ECHO_T}yes" >&6
6767 <  SET_MAKE=
6768 < else
6769 <  echo "$as_me:$LINENO: result: no" >&5
6770 < echo "${ECHO_T}no" >&6
6771 <  SET_MAKE="MAKE=${MAKE-make}"
6772 < fi
6773 <
6774 < if test -n "$ac_tool_prefix"; then
6775 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6776 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6777 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6778 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6779 < if test "${ac_cv_prog_RANLIB+set}" = set; then
6780 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6781 < else
6782 <  if test -n "$RANLIB"; then
6783 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6784 < else
6785 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6786 < for as_dir in $PATH
6787 < do
6788 <  IFS=$as_save_IFS
6789 <  test -z "$as_dir" && as_dir=.
6790 <  for ac_exec_ext in '' $ac_executable_extensions; do
6791 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6792 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6793 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6794 <    break 2
6795 <  fi
6796 < done
6797 < done
6798 <
6799 < fi
6800 < fi
6801 < RANLIB=$ac_cv_prog_RANLIB
6802 < if test -n "$RANLIB"; then
6803 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6804 < echo "${ECHO_T}$RANLIB" >&6
6805 < else
6806 <  echo "$as_me:$LINENO: result: no" >&5
6807 < echo "${ECHO_T}no" >&6
6808 < fi
6809 <
6810 < fi
6811 < if test -z "$ac_cv_prog_RANLIB"; then
6812 <  ac_ct_RANLIB=$RANLIB
6813 <  # Extract the first word of "ranlib", so it can be a program name with args.
6814 < set dummy ranlib; ac_word=$2
6815 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6816 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6817 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6818 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6819 < else
6820 <  if test -n "$ac_ct_RANLIB"; then
6821 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6822 < else
6823 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6824 < for as_dir in $PATH
6825 < do
6826 <  IFS=$as_save_IFS
6827 <  test -z "$as_dir" && as_dir=.
6828 <  for ac_exec_ext in '' $ac_executable_extensions; do
6829 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6830 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6831 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6832 <    break 2
6833 <  fi
6834 < done
6835 < done
6836 <
6837 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6838 < fi
6839 < fi
6840 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6841 < if test -n "$ac_ct_RANLIB"; then
6842 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6843 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6844 < else
6845 <  echo "$as_me:$LINENO: result: no" >&5
6846 < echo "${ECHO_T}no" >&6
6847 < fi
6848 <
6849 <  RANLIB=$ac_ct_RANLIB
6850 < else
6851 <  RANLIB="$ac_cv_prog_RANLIB"
6852 < fi
6853 <
6854 < for ac_prog in 'bison -y' byacc
6855 < do
6856 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6857 < set dummy $ac_prog; ac_word=$2
6858 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6859 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6860 < if test "${ac_cv_prog_YACC+set}" = set; then
6861 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6862 < else
6863 <  if test -n "$YACC"; then
6864 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6865 < else
6866 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6867 < for as_dir in $PATH
6868 < do
6869 <  IFS=$as_save_IFS
6870 <  test -z "$as_dir" && as_dir=.
6871 <  for ac_exec_ext in '' $ac_executable_extensions; do
6872 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6873 <    ac_cv_prog_YACC="$ac_prog"
6874 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6875 <    break 2
6876 <  fi
6877 < done
6878 < done
6879 <
6880 < fi
6881 < fi
6882 < YACC=$ac_cv_prog_YACC
6883 < if test -n "$YACC"; then
6884 <  echo "$as_me:$LINENO: result: $YACC" >&5
6885 < echo "${ECHO_T}$YACC" >&6
6886 < else
6887 <  echo "$as_me:$LINENO: result: no" >&5
6888 < echo "${ECHO_T}no" >&6
6889 < fi
6890 <
6891 <  test -n "$YACC" && break
6892 < done
6893 < test -n "$YACC" || YACC="yacc"
6894 <
6895 < for ac_prog in flex lex
6896 < do
6897 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6898 < set dummy $ac_prog; ac_word=$2
6899 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6900 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6901 < if test "${ac_cv_prog_LEX+set}" = set; then
6902 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6903 < else
6904 <  if test -n "$LEX"; then
6905 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6906 < else
6907 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6908 < for as_dir in $PATH
6909 < do
6910 <  IFS=$as_save_IFS
6911 <  test -z "$as_dir" && as_dir=.
6912 <  for ac_exec_ext in '' $ac_executable_extensions; do
6913 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6914 <    ac_cv_prog_LEX="$ac_prog"
6915 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6916 <    break 2
6917 <  fi
6918 < done
6919 < done
6920 <
6921 < fi
6922 < fi
6923 < LEX=$ac_cv_prog_LEX
6924 < if test -n "$LEX"; then
6925 <  echo "$as_me:$LINENO: result: $LEX" >&5
6926 < echo "${ECHO_T}$LEX" >&6
6927 < else
6928 <  echo "$as_me:$LINENO: result: no" >&5
6929 < echo "${ECHO_T}no" >&6
6930 < fi
6931 <
6932 <  test -n "$LEX" && break
6933 < done
6934 < test -n "$LEX" || LEX=":"
6935 <
6936 < if test -z "$LEXLIB"
6937 < then
6938 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6939 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6940 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6941 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6942 < else
6943 <  ac_check_lib_save_LIBS=$LIBS
6944 < LIBS="-lfl  $LIBS"
6945 < cat >conftest.$ac_ext <<_ACEOF
6946 < /* confdefs.h.  */
6947 < _ACEOF
6948 < cat confdefs.h >>conftest.$ac_ext
6949 < cat >>conftest.$ac_ext <<_ACEOF
6950 < /* end confdefs.h.  */
6951 <
6952 < /* Override any gcc2 internal prototype to avoid an error.  */
6953 < #ifdef __cplusplus
6954 < extern "C"
6955 < #endif
6956 < /* We use char because int might match the return type of a gcc2
6957 <   builtin and then its argument prototype would still apply.  */
6958 < char yywrap ();
6959 < int
6960 < main ()
6961 < {
6962 < yywrap ();
6963 <  ;
6964 <  return 0;
6965 < }
6966 < _ACEOF
6967 < rm -f conftest.$ac_objext conftest$ac_exeext
6968 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6969 <  (eval $ac_link) 2>conftest.er1
6970 <  ac_status=$?
6971 <  grep -v '^ *+' conftest.er1 >conftest.err
6972 <  rm -f conftest.er1
6973 <  cat conftest.err >&5
6974 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6975 <  (exit $ac_status); } &&
6976 <         { ac_try='test -z "$ac_c_werror_flag"
6977 <                         || test ! -s conftest.err'
6978 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6979 <  (eval $ac_try) 2>&5
6980 <  ac_status=$?
6981 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6982 <  (exit $ac_status); }; } &&
6983 <         { ac_try='test -s conftest$ac_exeext'
6984 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6985 <  (eval $ac_try) 2>&5
6986 <  ac_status=$?
6987 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6988 <  (exit $ac_status); }; }; then
6989 <  ac_cv_lib_fl_yywrap=yes
6990 < else
6991 <  echo "$as_me: failed program was:" >&5
6992 < sed 's/^/| /' conftest.$ac_ext >&5
13071 > fi
13072 > rm -f conftest*
13073  
6994 – ac_cv_lib_fl_yywrap=no
13074   fi
13075 < rm -f conftest.err conftest.$ac_objext \
13076 <      conftest$ac_exeext conftest.$ac_ext
13077 < LIBS=$ac_check_lib_save_LIBS
13078 < fi
13079 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
7001 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
7002 < if test $ac_cv_lib_fl_yywrap = yes; then
7003 <  LEXLIB="-lfl"
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: checking for yywrap in -ll" >&5
13082 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
13083 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
13081 >        :
13082 >
13083 > fi
13084 >
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
7010 –  ac_check_lib_save_LIBS=$LIBS
7011 – LIBS="-ll  $LIBS"
7012 – cat >conftest.$ac_ext <<_ACEOF
7013 – /* confdefs.h.  */
7014 – _ACEOF
7015 – cat confdefs.h >>conftest.$ac_ext
7016 – cat >>conftest.$ac_ext <<_ACEOF
7017 – /* end confdefs.h.  */
13093  
13094 < /* Override any gcc2 internal prototype to avoid an error.  */
13095 < #ifdef __cplusplus
13096 < extern "C"
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 < /* We use char because int might match the return type of a gcc2
13101 <   builtin and then its argument prototype would still apply.  */
7025 < char yywrap ();
7026 < int
7027 < main ()
7028 < {
7029 < yywrap ();
7030 <  ;
7031 <  return 0;
7032 < }
7033 < _ACEOF
7034 < rm -f conftest.$ac_objext conftest$ac_exeext
7035 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7036 <  (eval $ac_link) 2>conftest.er1
7037 <  ac_status=$?
7038 <  grep -v '^ *+' conftest.er1 >conftest.err
7039 <  rm -f conftest.er1
7040 <  cat conftest.err >&5
7041 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7042 <  (exit $ac_status); } &&
7043 <         { ac_try='test -z "$ac_c_werror_flag"
7044 <                         || test ! -s conftest.err'
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); }; } &&
13107 <         { ac_try='test -s conftest$ac_exeext'
7051 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7052 <  (eval $ac_try) 2>&5
7053 <  ac_status=$?
7054 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7055 <  (exit $ac_status); }; }; then
7056 <  ac_cv_lib_l_yywrap=yes
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: failed program was:" >&5
7059 < sed 's/^/| /' conftest.$ac_ext >&5
7060 <
7061 < ac_cv_lib_l_yywrap=no
13109 >  ac_cv_prog_gxx_2_95=no
13110   fi
7063 – rm -f conftest.err conftest.$ac_objext \
7064 –      conftest$ac_exeext conftest.$ac_ext
7065 – LIBS=$ac_check_lib_save_LIBS
7066 – fi
7067 – echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
7068 – echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
7069 – if test $ac_cv_lib_l_yywrap = yes; then
7070 –  LEXLIB="-ll"
7071 – fi
13111  
13112   fi
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  
7075 – fi
13118  
13119 < if test "x$LEX" != "x:"; then
13120 <  echo "$as_me:$LINENO: checking lex output file root" >&5
13121 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
7080 < if test "${ac_cv_prog_lex_root+set}" = set; then
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 <  # The minimal lex program is just a single line: %%.  But some broken lexes
13125 < # (Solaris, I think it was) want two %% lines, so accommodate them.
13126 < cat >conftest.l <<_ACEOF
7086 < %%
7087 < %%
7088 < _ACEOF
7089 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
7090 <  (eval $LEX conftest.l) 2>&5
7091 <  ac_status=$?
7092 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7093 <  (exit $ac_status); }
7094 < if test -f lex.yy.c; then
7095 <  ac_cv_prog_lex_root=lex.yy
7096 < elif test -f lexyy.c; then
7097 <  ac_cv_prog_lex_root=lexyy
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 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7100 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7101 <   { (exit 1); exit 1; }; }
13128 >        ac_m_cpu_750=no
13129   fi
13130 < fi
7104 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7105 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7106 < rm -f conftest.l
7107 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13130 > rm -f conftest*
13131  
13132 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
13133 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
13134 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
13135 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13132 > fi
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 <  # POSIX says lex can declare yytext either as a pointer or an array; the
7115 < # default is implementation-dependent. Figure out which it is, since
7116 < # not all implementations provide the %pointer and %array declarations.
7117 < ac_cv_prog_lex_yytext_pointer=no
7118 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
7119 < ac_save_LIBS=$LIBS
7120 < LIBS="$LIBS $LEXLIB"
7121 < cat >conftest.$ac_ext <<_ACEOF
7122 < `cat $LEX_OUTPUT_ROOT.c`
7123 < _ACEOF
7124 < rm -f conftest.$ac_objext conftest$ac_exeext
7125 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7126 <  (eval $ac_link) 2>conftest.er1
7127 <  ac_status=$?
7128 <  grep -v '^ *+' conftest.er1 >conftest.err
7129 <  rm -f conftest.er1
7130 <  cat conftest.err >&5
7131 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7132 <  (exit $ac_status); } &&
7133 <         { ac_try='test -z "$ac_c_werror_flag"
7134 <                         || test ! -s conftest.err'
7135 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7136 <  (eval $ac_try) 2>&5
7137 <  ac_status=$?
7138 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7139 <  (exit $ac_status); }; } &&
7140 <         { ac_try='test -s conftest$ac_exeext'
7141 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7142 <  (eval $ac_try) 2>&5
7143 <  ac_status=$?
7144 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7145 <  (exit $ac_status); }; }; then
7146 <  ac_cv_prog_lex_yytext_pointer=yes
7147 < else
7148 <  echo "$as_me: failed program was:" >&5
7149 < sed 's/^/| /' conftest.$ac_ext >&5
13139 >        :
13140  
13141   fi
7152 – rm -f conftest.err conftest.$ac_objext \
7153 –      conftest$ac_exeext conftest.$ac_ext
7154 – LIBS=$ac_save_LIBS
7155 – rm -f "${LEX_OUTPUT_ROOT}.c"
13142  
13143 < fi
13144 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
7159 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
7160 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
13143 > else
13144 >        :
13145  
7162 – cat >>confdefs.h <<\_ACEOF
7163 – #define YYTEXT_POINTER 1
7164 – _ACEOF
7165 –
13146   fi
13147  
13148 < fi
13148 >                fi
13149 >                if test -z "$CPU_FLAGS"; then
13150  
13151 <   # Extract the first word of "perl", so it can be a program name with args.
13152 < set dummy perl; ac_word=$2
13153 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13154 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7174 < if test "${ac_cv_path_PERLINTERP+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 <  case $PERLINTERP in
13158 <  [\\/]* | ?:[\\/]*)
13159 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
13160 <  ;;
13161 <  *)
7182 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7183 < for as_dir in $PATH
7184 < do
7185 <  IFS=$as_save_IFS
7186 <  test -z "$as_dir" && as_dir=.
7187 <  for ac_exec_ext in '' $ac_executable_extensions; do
7188 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7189 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
7190 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7191 <    break 2
7192 <  fi
7193 < done
7194 < done
7195 <
7196 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
7197 <  ;;
7198 < esac
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 >        ac_m_cpu_powerpc=no
13162   fi
13163 < PERLINTERP=$ac_cv_path_PERLINTERP
13163 > rm -f conftest*
13164  
13165 < if test -n "$PERLINTERP"; then
13166 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
13167 < echo "${ECHO_T}$PERLINTERP" >&6
13165 > fi
13166 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13167 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
13168 > if test "$ac_m_cpu_powerpc" = yes; then
13169 >        :
13170 >        CPU_FLAGS=-mcpu=powerpc
13171   else
13172 <  echo "$as_me:$LINENO: result: no" >&5
13173 < echo "${ECHO_T}no" >&6
13172 >        :
13173 >
13174   fi
13175  
13176 <   ac_cv_path_perlinterp="$PERLINTERP"
13177 <   _sHpB='#!'
13176 >                fi
13177 >                if test -z "$CPU_FLAGS"; then
13178  
13179  
13180 < # Check whether --with-perl-shebang or --without-perl-shebang was given.
13181 < if test "${with_perl_shebang+set}" = set; then
13182 <  withval="$with_perl_shebang"
7217 <  opt_perl_shebang="$withval"
7218 < else
7219 <                opt_perl_shebang="not_set"
7220 < fi;
7221 <   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
7222 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
7223 < if test "${ax_cv_opt_perl_shebang+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 <   case "$opt_perl_shebang" in
13186 <                      not_set  ) ax_cv_opt_perl_shebang=''
13187 <                               ;;
13188 <                         *     )
13189 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
7231 <                    esac
7232 <
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 >        ac_m_powerpc=no
13190   fi
13191 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
7235 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
7236 <   if test "A$ax_cv_opt_perl_shebang" != "A"
7237 <     then
7238 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
7239 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
7240 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
7241 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
13191 > rm -f conftest*
13192  
13193 < # Automatic detection of sharpbang formula starts here
13194 <     else
13195 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
13196 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
13197 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
13198 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
7249 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
7250 <  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 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
7253 <        if test "x$_somian_kspb_perl" == x
7254 <          then _somian_ksbp_warn_empty='durnit'
7255 <          else
7256 <          case "A$_somian_kspb_perl" in
7257 <                 A#!*perl* )
7258 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
7259 <                        ;;
7260 <                     A*    )  _somian_ksbp_warn_defau='trouble'
7261 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
7262 <          esac
7263 <        fi
13200 >        :
13201  
13202   fi
7266 – echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
7267 – echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
7268 – # The above prints Checking ... result message to user.
7269 –   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
13203  
13204 <    if test A${_somian_ksbp_warn_empty+set} == Aset
13205 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
7273 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
7274 <    fi
7275 < # Inform user after printing result value
7276 <    if test A${_somian_ksbp_warn_defau+set} == Aset
7277 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
7278 < echo "$as_me: Maybe Not good -" >&6;}
7279 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
7280 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
7281 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
7282 < echo "$as_me: OK Good result - " >&6;}
7283 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
7284 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
7285 <    fi
13204 >                fi
13205 >          esac
13206    fi
13207  
13208 < # Extract the first word of "ar", so it can be a program name with args.
13209 < set dummy ar; ac_word=$2
7290 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7291 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7292 < if test "${ac_cv_prog_AR+set}" = set; then
7293 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7294 < else
7295 <  if test -n "$AR"; then
7296 <  ac_cv_prog_AR="$AR" # Let the user override the test.
7297 < else
7298 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7299 < for as_dir in $PATH
7300 < do
7301 <  IFS=$as_save_IFS
7302 <  test -z "$as_dir" && as_dir=.
7303 <  for ac_exec_ext in '' $ac_executable_extensions; do
7304 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7305 <    ac_cv_prog_AR="ar"
7306 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7307 <    break 2
13208 >  if test -n "$CPU_FLAGS"; then
13209 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13210    fi
7309 – done
7310 – done
13211  
13212 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13213 < fi
13214 < fi
13215 < AR=$ac_cv_prog_AR
13216 < if test -n "$AR"; then
13217 <  echo "$as_me:$LINENO: result: $AR" >&5
13218 < echo "${ECHO_T}$AR" >&6
13219 < else
13220 <  echo "$as_me:$LINENO: result: no" >&5
13221 < echo "${ECHO_T}no" >&6
7322 < 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  
7324 – if test "$AR" = "NONE"; then
7325 –  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
7326 – echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7327 –   { (exit 1); exit 1; }; }
7328 –  cat >confcache <<\_ACEOF
7329 – # This file is a shell script that caches the results of configure
7330 – # tests run on this system so they can be shared between configure
7331 – # scripts and configure runs, see configure's option --config-cache.
7332 – # It is not useful on other systems.  If it contains results you don't
7333 – # want to keep, you may remove or edit it.
7334 – #
7335 – # config.status only pays attention to the cache file if you give it
7336 – # the --recheck option to rerun configure.
7337 – #
7338 – # `ac_cv_env_foo' variables (set or unset) will be overridden when
7339 – # loading this file, other *unset* `ac_cv_foo' will be assigned the
7340 – # following values.
13223  
7342 – _ACEOF
13224  
13225 < # The following way of writing the cache mishandles newlines in values,
13226 < # but we know of no workaround that is simple, portable, and efficient.
13227 < # So, don't put newlines in cache variables' values.
13228 < # Ultrix sh set writes to stderr and can't be redirected directly,
13229 < # and sets the high bit in the cache file unless we assign to the vars.
13230 < {
13231 <  (set) 2>&1 |
13232 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
13233 <    *ac_space=\ *)
13234 <      # `set' does not quote correctly, so add quotes (double-quote
7354 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7355 <      sed -n \
7356 <        "s/'/'\\\\''/g;
7357 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7358 <      ;;
7359 <    *)
7360 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
7361 <      sed -n \
7362 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7363 <      ;;
7364 <    esac;
7365 < } |
7366 <  sed '
7367 <     t clear
7368 <     : clear
7369 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7370 <     t end
7371 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7372 <     : end' >>confcache
7373 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
7374 <  if test -w $cache_file; then
7375 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7376 <    cat confcache >$cache_file
7377 <  else
7378 <    echo "not updating unwritable cache $cache_file"
7379 <  fi
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 >  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 >        ac_guessed_cxxflags=no
13235   fi
13236 < rm -f confcache
13237 <  exit 1
13236 > rm -f conftest*
13237 >
13238   fi
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  
7385 – # Extract the first word of "ps", so it can be a program name with args.
7386 – set dummy ps; ac_word=$2
7387 – echo "$as_me:$LINENO: checking for $ac_word" >&5
7388 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7389 – if test "${ac_cv_path_PS+set}" = set; then
7390 –  echo $ECHO_N "(cached) $ECHO_C" >&6
13244   else
13245 <  case $PS in
7393 <  [\\/]* | ?:[\\/]*)
7394 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
7395 <  ;;
7396 <  *)
7397 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7398 < for as_dir in $PATH
7399 < do
7400 <  IFS=$as_save_IFS
7401 <  test -z "$as_dir" && as_dir=.
7402 <  for ac_exec_ext in '' $ac_executable_extensions; do
7403 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7404 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7405 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7406 <    break 2
7407 <  fi
7408 < done
7409 < done
13245 >        :
13246  
13247 <  ;;
13248 < esac
13249 < fi
13250 < PS=$ac_cv_path_PS
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  
7416 – if test -n "$PS"; then
7417 –  echo "$as_me:$LINENO: result: $PS" >&5
7418 – echo "${ECHO_T}$PS" >&6
7419 – else
7420 –  echo "$as_me:$LINENO: result: no" >&5
7421 – echo "${ECHO_T}no" >&6
13256   fi
13257  
7424 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
7425 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
7426 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
7427 –  echo $ECHO_N "(cached) $ECHO_C" >&6
7428 – else
13258  
7430 –        if $PS ax -o rss > /dev/null 2>&1; then
7431 –                ac_cv_prog_ps_ax=yes
7432 –        else
7433 –                ac_cv_prog_ps_ax=no
7434 –        fi
7435 –        if $PS -ef -o rss > /dev/null 2>&1; then
7436 –                ac_cv_prog_ps_ef=yes
7437 –        else
7438 –                ac_cv_prog_ps_ef=no
7439 –        fi
7440 –        if test "$ac_cv_prog_ps_ax" = yes; then
7441 –                ac_cv_prog_ps_syntax=BSD
7442 –        else
7443 –                if test "$ac_cv_prog_ps_ef" = yes; then
7444 –                        ac_cv_prog_ps_syntax=POSIX
7445 –                else
7446 –                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7447 – echo "$as_me: error: Could not determine ps syntax" >&2;}
7448 –   { (exit 1); exit 1; }; }
7449 –                fi
7450 –        fi
7451 –
13259   fi
7453 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7454 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
13260  
13261 +     ;;
13262 + esac
13263  
7457 – cat >>confdefs.h <<_ACEOF
7458 – #define PSCOMMAND $PS
7459 – _ACEOF
13264  
13265 <
13266 < if test "$ac_cv_prog_ps_syntax" = BSD; then
7463 <  cat >>confdefs.h <<\_ACEOF
7464 < #define PSTYPE_IS_BSD 1
13265 > cat >>confdefs.h <<\_ACEOF
13266 > #define OBAPI
13267   _ACEOF
13268  
7467 – else
7468 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
7469 –       cat >>confdefs.h <<\_ACEOF
7470 – #define PSTYPE_IS_POSIX 1
7471 – _ACEOF
13269  
7473 –   else
7474 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
7475 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
7476 –   { (exit 1); exit 1; }; }
7477 –   fi
7478 – fi
13270  
13271  
13272   # Check whether --with-mpi or --without-mpi was given.
# Line 7533 | Line 13324 | rm -f conftest*
13324   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13325   have_mpif_h=0
13326   rm -f conftest*
13327 < cat >conftest.f90 <<EOF
13327 > cat >conftest.$ac_ext <<EOF
13328   program main
13329     include 'mpif.h'
13330   end
13331   EOF
13332 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13332 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13333          echo "$as_me:$LINENO: result: yes" >&5
13334   echo "${ECHO_T}yes" >&6
13335          MPI_F90_INC="$MPI_INC_DIR"
# Line 7592 | Line 13383 | char MPI_Init ();
13383   /* We use char because int might match the return type of a gcc2
13384     builtin and then its argument prototype would still apply.  */
13385   char MPI_Init ();
13386 + #ifdef FC_DUMMY_MAIN
13387 + #ifndef FC_DUMMY_MAIN_EQ_F77
13388 + #  ifdef __cplusplus
13389 +     extern "C"
13390 + #  endif
13391 +   int FC_DUMMY_MAIN() { return 1; }
13392 + #endif
13393 + #endif
13394   int
13395   main ()
13396   {
# Line 7662 | Line 13461 | char MPI_Init ();
13461   /* We use char because int might match the return type of a gcc2
13462     builtin and then its argument prototype would still apply.  */
13463   char MPI_Init ();
13464 + #ifdef FC_DUMMY_MAIN
13465 + #ifndef FC_DUMMY_MAIN_EQ_F77
13466 + #  ifdef __cplusplus
13467 +     extern "C"
13468 + #  endif
13469 +   int FC_DUMMY_MAIN() { return 1; }
13470 + #endif
13471 + #endif
13472   int
13473   main ()
13474   {
# Line 7733 | Line 13540 | char MPI_Init ();
13540   /* We use char because int might match the return type of a gcc2
13541     builtin and then its argument prototype would still apply.  */
13542   char MPI_Init ();
13543 + #ifdef FC_DUMMY_MAIN
13544 + #ifndef FC_DUMMY_MAIN_EQ_F77
13545 + #  ifdef __cplusplus
13546 +     extern "C"
13547 + #  endif
13548 +   int FC_DUMMY_MAIN() { return 1; }
13549 + #endif
13550 + #endif
13551   int
13552   main ()
13553   {
# Line 7804 | Line 13619 | char MPI_Init ();
13619   /* We use char because int might match the return type of a gcc2
13620     builtin and then its argument prototype would still apply.  */
13621   char MPI_Init ();
13622 + #ifdef FC_DUMMY_MAIN
13623 + #ifndef FC_DUMMY_MAIN_EQ_F77
13624 + #  ifdef __cplusplus
13625 +     extern "C"
13626 + #  endif
13627 +   int FC_DUMMY_MAIN() { return 1; }
13628 + #endif
13629 + #endif
13630   int
13631   main ()
13632   {
# Line 7848 | 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 7876 | Line 13699 | char MPI_Init ();
13699   /* We use char because int might match the return type of a gcc2
13700     builtin and then its argument prototype would still apply.  */
13701   char MPI_Init ();
13702 + #ifdef FC_DUMMY_MAIN
13703 + #ifndef FC_DUMMY_MAIN_EQ_F77
13704 + #  ifdef __cplusplus
13705 +     extern "C"
13706 + #  endif
13707 +   int FC_DUMMY_MAIN() { return 1; }
13708 + #endif
13709 + #endif
13710   int
13711   main ()
13712   {
# Line 8058 | Line 13889 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13889  
13890      save_CXXFLAGS="$CXXFLAGS"
13891      CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13892 <
8062 < ac_ext=cc
8063 < ac_cpp='$CXXCPP $CPPFLAGS'
8064 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8065 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8066 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8067 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
8068 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
8069 < if test -z "$CXXCPP"; then
8070 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
8071 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8072 < else
8073 <      # Double quotes because CXXCPP needs to be expanded
8074 <    for CXXCPP in "$CXX -E" "/lib/cpp"
8075 <    do
8076 <      ac_preproc_ok=false
8077 < for ac_cxx_preproc_warn_flag in '' yes
8078 < do
8079 <  # Use a header file that comes with gcc, so configuring glibc
8080 <  # with a fresh cross-compiler works.
8081 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8082 <  # <limits.h> exists even on freestanding compilers.
8083 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8084 <  # not just through cpp. "Syntax error" is here to catch this case.
8085 <  cat >conftest.$ac_ext <<_ACEOF
8086 < /* confdefs.h.  */
8087 < _ACEOF
8088 < cat confdefs.h >>conftest.$ac_ext
8089 < cat >>conftest.$ac_ext <<_ACEOF
8090 < /* end confdefs.h.  */
8091 < #ifdef __STDC__
8092 < # include <limits.h>
8093 < #else
8094 < # include <assert.h>
8095 < #endif
8096 <                     Syntax error
8097 < _ACEOF
8098 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8099 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8100 <  ac_status=$?
8101 <  grep -v '^ *+' conftest.er1 >conftest.err
8102 <  rm -f conftest.er1
8103 <  cat conftest.err >&5
8104 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8105 <  (exit $ac_status); } >/dev/null; then
8106 <  if test -s conftest.err; then
8107 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8108 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8109 <  else
8110 <    ac_cpp_err=
8111 <  fi
8112 < else
8113 <  ac_cpp_err=yes
8114 < fi
8115 < if test -z "$ac_cpp_err"; then
8116 <  :
8117 < else
8118 <  echo "$as_me: failed program was:" >&5
8119 < sed 's/^/| /' conftest.$ac_ext >&5
8120 <
8121 <  # Broken: fails on valid input.
8122 < continue
8123 < fi
8124 < rm -f conftest.err conftest.$ac_ext
8125 <
8126 <  # OK, works on sane cases.  Now check whether non-existent headers
8127 <  # can be detected and how.
8128 <  cat >conftest.$ac_ext <<_ACEOF
8129 < /* confdefs.h.  */
8130 < _ACEOF
8131 < cat confdefs.h >>conftest.$ac_ext
8132 < cat >>conftest.$ac_ext <<_ACEOF
8133 < /* end confdefs.h.  */
8134 < #include <ac_nonexistent.h>
8135 < _ACEOF
8136 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8137 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8138 <  ac_status=$?
8139 <  grep -v '^ *+' conftest.er1 >conftest.err
8140 <  rm -f conftest.er1
8141 <  cat conftest.err >&5
8142 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8143 <  (exit $ac_status); } >/dev/null; then
8144 <  if test -s conftest.err; then
8145 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8146 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8147 <  else
8148 <    ac_cpp_err=
8149 <  fi
8150 < else
8151 <  ac_cpp_err=yes
8152 < fi
8153 < if test -z "$ac_cpp_err"; then
8154 <  # Broken: success on invalid input.
8155 < continue
8156 < else
8157 <  echo "$as_me: failed program was:" >&5
8158 < sed 's/^/| /' conftest.$ac_ext >&5
8159 <
8160 <  # Passes both tests.
8161 < ac_preproc_ok=:
8162 < break
8163 < fi
8164 < rm -f conftest.err conftest.$ac_ext
8165 <
8166 < done
8167 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8168 < rm -f conftest.err conftest.$ac_ext
8169 < if $ac_preproc_ok; then
8170 <  break
8171 < fi
8172 <
8173 <    done
8174 <    ac_cv_prog_CXXCPP=$CXXCPP
8175 <
8176 < fi
8177 <  CXXCPP=$ac_cv_prog_CXXCPP
8178 < else
8179 <  ac_cv_prog_CXXCPP=$CXXCPP
8180 < fi
8181 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
8182 < echo "${ECHO_T}$CXXCPP" >&6
8183 < ac_preproc_ok=false
8184 < for ac_cxx_preproc_warn_flag in '' yes
8185 < do
8186 <  # Use a header file that comes with gcc, so configuring glibc
8187 <  # with a fresh cross-compiler works.
8188 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8189 <  # <limits.h> exists even on freestanding compilers.
8190 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8191 <  # not just through cpp. "Syntax error" is here to catch this case.
8192 <  cat >conftest.$ac_ext <<_ACEOF
8193 < /* confdefs.h.  */
8194 < _ACEOF
8195 < cat confdefs.h >>conftest.$ac_ext
8196 < cat >>conftest.$ac_ext <<_ACEOF
8197 < /* end confdefs.h.  */
8198 < #ifdef __STDC__
8199 < # include <limits.h>
8200 < #else
8201 < # include <assert.h>
8202 < #endif
8203 <                     Syntax error
8204 < _ACEOF
8205 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8206 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8207 <  ac_status=$?
8208 <  grep -v '^ *+' conftest.er1 >conftest.err
8209 <  rm -f conftest.er1
8210 <  cat conftest.err >&5
8211 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8212 <  (exit $ac_status); } >/dev/null; then
8213 <  if test -s conftest.err; then
8214 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8215 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8216 <  else
8217 <    ac_cpp_err=
8218 <  fi
8219 < else
8220 <  ac_cpp_err=yes
8221 < fi
8222 < if test -z "$ac_cpp_err"; then
8223 <  :
8224 < else
8225 <  echo "$as_me: failed program was:" >&5
8226 < sed 's/^/| /' conftest.$ac_ext >&5
8227 <
8228 <  # Broken: fails on valid input.
8229 < continue
8230 < fi
8231 < rm -f conftest.err conftest.$ac_ext
8232 <
8233 <  # OK, works on sane cases.  Now check whether non-existent headers
8234 <  # can be detected and how.
8235 <  cat >conftest.$ac_ext <<_ACEOF
8236 < /* confdefs.h.  */
8237 < _ACEOF
8238 < cat confdefs.h >>conftest.$ac_ext
8239 < cat >>conftest.$ac_ext <<_ACEOF
8240 < /* end confdefs.h.  */
8241 < #include <ac_nonexistent.h>
8242 < _ACEOF
8243 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8244 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8245 <  ac_status=$?
8246 <  grep -v '^ *+' conftest.er1 >conftest.err
8247 <  rm -f conftest.er1
8248 <  cat conftest.err >&5
8249 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8250 <  (exit $ac_status); } >/dev/null; then
8251 <  if test -s conftest.err; then
8252 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8253 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8254 <  else
8255 <    ac_cpp_err=
8256 <  fi
8257 < else
8258 <  ac_cpp_err=yes
8259 < fi
8260 < if test -z "$ac_cpp_err"; then
8261 <  # Broken: success on invalid input.
8262 < continue
8263 < else
8264 <  echo "$as_me: failed program was:" >&5
8265 < sed 's/^/| /' conftest.$ac_ext >&5
8266 <
8267 <  # Passes both tests.
8268 < ac_preproc_ok=:
8269 < break
8270 < fi
8271 < rm -f conftest.err conftest.$ac_ext
8272 <
8273 < done
8274 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8275 < rm -f conftest.err conftest.$ac_ext
8276 < if $ac_preproc_ok; then
8277 <  :
8278 < else
8279 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8280 < See \`config.log' for more details." >&5
8281 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8282 < See \`config.log' for more details." >&2;}
8283 <   { (exit 1); exit 1; }; }
8284 < fi
8285 <
8286 < ac_ext=cc
8287 < ac_cpp='$CXXCPP $CPPFLAGS'
8288 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8289 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8290 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8291 <
8292 <
8293 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13892 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13893    echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13894   echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13895   if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
# Line 8526 | Line 14125 | cat >>conftest.$ac_ext <<_ACEOF
14125   cat >>conftest.$ac_ext <<_ACEOF
14126   /* end confdefs.h.  */
14127   #include <CGAL/Cartesian.h>
14128 + #ifdef FC_DUMMY_MAIN
14129 + #ifndef FC_DUMMY_MAIN_EQ_F77
14130 + #  ifdef __cplusplus
14131 +     extern "C"
14132 + #  endif
14133 +   int FC_DUMMY_MAIN() { return 1; }
14134 + #endif
14135 + #endif
14136   int
14137   main ()
14138   {
# Line 8766 | Line 14373 | fi
14373   else
14374          enable_dot=yes
14375   fi
8769 –
8770 –
8771 –
8772 –
8773 –
8774 –
8775 –
8776 – OBJEXT=".$OBJEXT"
8777 –
8778 – OOPSE=oopse
8779 –
8780 – if test "x${prefix}" = "xNONE"
8781 – then
8782 –  OOPSE_HOME=${ac_default_prefix}/oopse
8783 – else
8784 –  OOPSE_HOME=${prefix}/oopse
8785 – fi
8786 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
8787 – if test "${enable_oopse_home+set}" = set; then
8788 –  enableval="$enable_oopse_home"
8789 –  OOPSE_HOME="${enableval}"
8790 – fi;
8791 –
8792 – case "x$INSTALL" in
8793 –   x/*) ;;
8794 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
8795 – esac
8796 –
8797 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
8798 –
8799 – CFLAGS=${CFLAGS-""}
8800 – CXXFLAGS=${CXXFLAGS-""}
8801 – CPPFLAGS=${CPPFLAGS-""}
8802 – FFLAGS=${FFLAGS-""}
8803 – F90FLAGS=${F90FLAGS-""}
8804 – LDFLAGS=${LDFLAGS-""}
8805 – DEBUG=${DEBUG-"-g"}
8806 –
8807 – case $debug in
8808 –  1)
8809 –     FFLAGS="$DEBUG $FFLAGS"
8810 –     F90FLAGS="$DEBUG $F90FLAGS"
8811 –     ;;
8812 –  *)
8813 –     ;;
8814 – esac
14376  
14377  
14378  
# Line 8830 | Line 14391 | esac
14391  
14392  
14393  
8833 –          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 9197 | Line 14757 | cat >&5 <<_CSEOF
14757   } >&5
14758   cat >&5 <<_CSEOF
14759  
14760 < This file was extended by OOPSE $as_me 2.0, which was
14760 > This file was extended by OOPSE $as_me 3.0, which was
14761   generated by GNU Autoconf 2.59.  Invocation command line was
14762  
14763    CONFIG_FILES    = $CONFIG_FILES
# Line 9260 | Line 14820 | ac_cs_version="\\
14820  
14821   cat >>$CONFIG_STATUS <<_ACEOF
14822   ac_cs_version="\\
14823 < OOPSE config.status 2.0
14823 > OOPSE config.status 3.0
14824   configured by $0, generated by GNU Autoconf 2.59,
14825    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14826  
# Line 9454 | Line 15014 | s,@LIBS@,$LIBS,;t t
15014   s,@ECHO_N@,$ECHO_N,;t t
15015   s,@ECHO_T@,$ECHO_T,;t t
15016   s,@LIBS@,$LIBS,;t t
9457 – s,@PROGNAME@,$PROGNAME,;t t
9458 – 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 9464 | Line 15022 | s,@host_os@,$host_os,;t t
15022   s,@host_cpu@,$host_cpu,;t t
15023   s,@host_vendor@,$host_vendor,;t t
15024   s,@host_os@,$host_os,;t t
15025 < s,@CC@,$CC,;t t
15026 < s,@CFLAGS@,$CFLAGS,;t t
15025 > s,@PROGNAME@,$PROGNAME,;t t
15026 > s,@debug@,$debug,;t t
15027 > s,@CXX@,$CXX,;t t
15028 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15029   s,@LDFLAGS@,$LDFLAGS,;t t
15030   s,@CPPFLAGS@,$CPPFLAGS,;t t
15031 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15031 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032   s,@EXEEXT@,$EXEEXT,;t t
15033   s,@OBJEXT@,$OBJEXT,;t t
15034 < s,@CXX@,$CXX,;t t
15035 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15036 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
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
9480 < s,@F90FLAGS@,$F90FLAGS,;t t
9481 < s,@ac_ct_F90@,$ac_ct_F90,;t t
9482 < s,@PREPFLAG@,$PREPFLAG,;t t
9483 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
9484 < s,@F90LIBS@,$F90LIBS,;t t
9485 < s,@F90_FUNC@,$F90_FUNC,;t t
9486 < s,@F90_FUNC_@,$F90_FUNC_,;t t
9487 < s,@MOD@,$MOD,;t t
9488 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
9489 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
9490 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
9491 < 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
9494 – s,@LIBOBJS@,$LIBOBJS,;t t
9495 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
9496 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
9497 – 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
9502 – s,@YACC@,$YACC,;t t
9503 – s,@LEX@,$LEX,;t t
9504 – s,@LEXLIB@,$LEXLIB,;t t
9505 – 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
15071   s,@MPI_LIB@,$MPI_LIB,;t t
15072   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15073   s,@USE_MPI@,$USE_MPI,;t t
9516 – s,@CXXCPP@,$CXXCPP,;t t
15074   s,@USE_CGAL@,$USE_CGAL,;t t
15075   s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
15076   s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
# Line 9532 | Line 15089 | s,@SUBDIRS@,$SUBDIRS,;t t
15089   s,@OOPSE@,$OOPSE,;t t
15090   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15091   s,@SUBDIRS@,$SUBDIRS,;t t
9535 – s,@FFLAGS@,$FFLAGS,;t t
15092   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093   CEOF
15094  

Diff Legend

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