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 819 by tim, Fri Dec 16 21:52:50 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 CPP EGREP OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CXXCPP LIBOBJS __func__ INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 < ac_env_CC_set=${CC+set}
757 < ac_env_CC_value=$CC
758 < ac_cv_env_CC_set=${CC+set}
759 < ac_cv_env_CC_value=$CC
760 < ac_env_CFLAGS_set=${CFLAGS+set}
761 < ac_env_CFLAGS_value=$CFLAGS
762 < ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 < ac_cv_env_CFLAGS_value=$CFLAGS
756 > ac_env_CXX_set=${CXX+set}
757 > ac_env_CXX_value=$CXX
758 > ac_cv_env_CXX_set=${CXX+set}
759 > ac_cv_env_CXX_value=$CXX
760 > ac_env_CXXFLAGS_set=${CXXFLAGS+set}
761 > ac_env_CXXFLAGS_value=$CXXFLAGS
762 > ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763 > ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764   ac_env_LDFLAGS_set=${LDFLAGS+set}
765   ac_env_LDFLAGS_value=$LDFLAGS
766   ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
# Line 769 | Line 769 | ac_cv_env_CPPFLAGS_value=$CPPFLAGS
769   ac_env_CPPFLAGS_value=$CPPFLAGS
770   ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771   ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 < ac_env_CXX_set=${CXX+set}
773 < ac_env_CXX_value=$CXX
774 < ac_cv_env_CXX_set=${CXX+set}
775 < ac_cv_env_CXX_value=$CXX
776 < ac_env_CXXFLAGS_set=${CXXFLAGS+set}
777 < ac_env_CXXFLAGS_value=$CXXFLAGS
778 < ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
779 < ac_cv_env_CXXFLAGS_value=$CXXFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 – ac_env_F90_set=${F90+set}
785 – ac_env_F90_value=$F90
786 – ac_cv_env_F90_set=${F90+set}
787 – ac_cv_env_F90_value=$F90
788 – ac_env_F90FLAGS_set=${F90FLAGS+set}
789 – ac_env_F90FLAGS_value=$F90FLAGS
790 – ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 – ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877 –  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884    --with-zlib=DIR root directory path of zlib installation defaults to
885                      /usr/local or /usr if not found in /usr/local
886    --without-zlib to disable zlib usage completely
887 <  --with-perl-shebang     override what perl thinks is the way for the kernel
886 <                          to start it (seldom needed)
887 >  --without-fftw          if you turn this off you cannot compute undulation spectra
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889    --with-cgal-makefile=FILE  CGAL makefile that should be used
890  
891   Some influential environment variables:
892 <  CC          C compiler command
893 <  CFLAGS      C compiler flags
892 >  CXX         C++ compiler command
893 >  CXXFLAGS    C++ compiler flags
894    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895                nonstandard directory <lib dir>
896    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897                headers in a nonstandard directory <include dir>
898 <  CXX         C++ compiler command
899 <  CXXFLAGS    C++ compiler flags
898 >  CC          C compiler command
899 >  CFLAGS      C compiler flags
900 >  FC          Fortran compiler command
901 >  FCFLAGS     Fortran compiler flags
902    CPP         C preprocessor
900 –  F90         Fortran 90 compiler command
901 –  F90FLAGS    Fortran 90 compiler flags
903    CXXCPP      C++ preprocessor
904  
905   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1001 | if $ac_init_version; then
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1004 > OOPSE configure 3.0
1005   generated by GNU Autoconf 2.59
1006  
1007   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1015 | running configure, to aid debugging if configure makes
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1018 > It was created by OOPSE $as_me 3.0, which was
1019   generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
# Line 1376 | Line 1377 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1378  
1379  
1380 < # This file is part of Autoconf.                       -*- Autoconf -*-
1380 < # Programming languages support.
1381 < # Copyright 2000, 2001
1382 < # Free Software Foundation, Inc.
1383 < #
1384 < # This program is free software; you can redistribute it and/or modify
1385 < # it under the terms of the GNU General Public License as published by
1386 < # the Free Software Foundation; either version 2, or (at your option)
1387 < # any later version.
1388 < #
1389 < # This program is distributed in the hope that it will be useful,
1390 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 < # GNU General Public License for more details.
1393 < #
1394 < # You should have received a copy of the GNU General Public License
1395 < # along with this program; if not, write to the Free Software
1396 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 < # 02111-1307, USA.
1398 < #
1399 < # As a special exception, the Free Software Foundation gives unlimited
1400 < # permission to copy, distribute and modify the configure scripts that
1401 < # are the output of Autoconf.  You need not follow the terms of the GNU
1402 < # General Public License when using or distributing such scripts, even
1403 < # though portions of the text of Autoconf appear in them.  The GNU
1404 < # General Public License (GPL) does govern all other use of the material
1405 < # that constitutes the Autoconf program.
1406 < #
1407 < # Certain portions of the Autoconf source text are designed to be copied
1408 < # (in certain cases, depending on the input) into the output of
1409 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 < # source text consists of comments plus executable code that decides which
1411 < # of the data portions to output in any given case.  We call these
1412 < # comments and executable code the "non-data" portions.  Autoconf never
1413 < # copies any of the non-data portions into its output.
1414 < #
1415 < # This special exception to the GPL applies to versions of Autoconf
1416 < # released by the Free Software Foundation.  When you make and
1417 < # distribute a modified version of Autoconf, you may extend this special
1418 < # exception to the GPL to apply to your modified version as well, *unless*
1419 < # your modified version has the potential to copy into its output some
1420 < # of the text that was the non-data portion of the version that you started
1421 < # with.  (In other words, unless your change moves or copies text from
1422 < # the non-data portions to the data portions.)  If your modification has
1423 < # such potential, you must delete any notice of this special exception
1424 < # to the GPL from your modified version.
1425 < #
1426 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 < # many others).
1428 <
1429 <
1430 < # Table of Contents:
1431 < #
1432 < # 1. Language selection
1433 < #    and routines to produce programs in a given language.
1434 < #  a. Fortran 77 (to be moved from aclang.m4)
1435 < #  b. Fortran 90
1436 < #  c. Fortran 95
1437 < #
1438 < # 2. Producing programs in a given language.
1439 < #  a. Fortran 77 (to be moved from aclang.m4)
1440 < #  b. Fortran 90
1441 < #  c. Fortran 95
1442 < #
1443 < # 3. Looking for a compiler
1444 < #    And possibly the associated preprocessor.
1445 < #  a. Fortran 77 (to be moved from aclang.m4)
1446 < #  b. Fortran 90
1447 < #  c. Fortran 95
1448 < #
1449 < # 4. Compilers' characteristics.
1450 < #  a. Fortran 77 (to be moved from aclang.m4)
1451 < #  b. Fortran 90
1452 < #  c. Fortran 95
1453 <
1454 < # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 < # ---------------------------------------------------------------------------
1456 < #
1457 < # Processing the elements of a list is tedious in shell programming,
1458 < # as lists tend to be implemented as space delimited strings.
1459 < #
1460 < # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 < # if ELEMENT is a member of LIST, otherwise it executes
1462 < # ACTION-IF-NOT-FOUND.
1463 < # _AC_LIST_MEMBER_IF
1464 <
1465 <
1466 <
1467 < # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 < # -------------------------------------------------
1469 < #
1470 < # Specifying options to the compiler (whether it be the C, C++ or
1471 < # Fortran 77 compiler) that are meant for the linker is compiler
1472 < # dependent.  This macro lets you give options to the compiler that
1473 < # are meant for the linker in a portable, compiler-independent way.
1474 < #
1475 < # This macro take two arguments, a list of linker options that the
1476 < # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 < # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 < # appended to the shell variable in a compiler-dependent way.
1479 < #
1480 < # For example, if the selected language is C, then this:
1481 < #
1482 < #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 < #
1484 < # will expand into this if the selected C compiler is gcc:
1485 < #
1486 < #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 < #
1488 < # otherwise, it will expand into this:
1489 < #
1490 < #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 < #
1492 < # You are encouraged to add support for compilers that this macro
1493 < # doesn't currently support.
1494 < # FIXME: Get rid of this macro.
1495 < # _AC_LINKER_OPTION
1496 <
1497 <
1498 <
1499 < ## ----------------------- ##
1500 < ## 1. Language selection.  ##
1501 < ## ----------------------- ##
1502 <
1503 < # ----------------------------- #
1504 < # 1b. The Fortran 90 language.  #
1505 < # ----------------------------- #
1506 <
1507 < # AC_LANG(Fortran 90)
1508 < # -------------------
1509 <
1510 <
1511 <
1512 < # _AC_LANG_ABBREV(Fortran 90)
1513 < # ---------------------------
1514 <
1515 <
1516 <
1517 < # ----------------------------- #
1518 < # 1c. The Fortran 95 language.  #
1519 < # ----------------------------- #
1520 <
1521 < # AC_LANG(Fortran 95)
1522 < # -------------------
1523 <
1524 <
1525 <
1526 < # _AC_LANG_ABBREV(Fortran 95)
1527 < # ---------------------------
1528 <
1529 <
1530 <
1531 < ## ---------------------- ##
1532 < ## 2.Producing programs.  ##
1533 < ## ---------------------- ##
1534 <
1535 < # ------------------------ #
1536 < # 2b. Fortran 90 sources.  #
1537 < # ------------------------ #
1538 <
1539 < # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 < # --------------------------------
1541 <
1542 <
1543 <
1544 < # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 < # -----------------------------------------------
1546 <
1547 <
1548 < # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 < # --------------------------------------------
1550 <
1551 <
1552 <
1553 < # ------------------------ #
1554 < # 2c. Fortran 95 sources.  #
1555 < # ------------------------ #
1556 <
1557 < # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 < # --------------------------------
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1382  
1561 – # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 – # -----------------------------------------------
1383  
1384  
1565 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 – # --------------------------------------------
1385  
1386  
1387  
1570 – ## -------------------------------------------- ##
1571 – ## 3. Looking for Compilers and Preprocessors.  ##
1572 – ## -------------------------------------------- ##
1388  
1574 – # ----------------------------- #
1575 – # 3b. The Fortran 90 compiler.  #
1576 – # ----------------------------- #
1389  
1390  
1579 – # AC_LANG_PREPROC(Fortran 90)
1580 – # ---------------------------
1581 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1391  
1392  
1393  
1585 – # AC_LANG_COMPILER(Fortran 90)
1586 – # ----------------------------
1587 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 – # AC_REQUIRE'able.
1394  
1395  
1396  
1592 – # AC_PROG_F90([COMPILERS...])
1593 – # ---------------------------
1594 – # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 – # for.
1596 – #
1597 – # Compilers are ordered by
1598 – #  1. F90, F95
1599 – #  2. Good/tested native compilers, bad/untested native compilers
1600 – #
1601 – # pgf90 is the Portland Group F90 compilers.
1602 – # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1603 – # lf95 is the Lahey-Fujitsu compiler.
1604 – # epcf90 is the "Edinburgh Portable Compiler" F90.
1605 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1606 – # AC_PROG_F90
1397  
1398  
1609 – # ----------------------------- #
1610 – # 3c. The Fortran 95 compiler.  #
1611 – # ----------------------------- #
1399  
1400  
1614 – # AC_LANG_PREPROC(Fortran 95)
1615 – # ---------------------------
1616 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1401  
1402  
1403  
1620 – # AC_LANG_COMPILER(Fortran 95)
1621 – # ----------------------------
1622 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 – # AC_REQUIRE'able.
1404  
1405  
1406  
1627 – # AC_PROG_F95([COMPILERS...])
1628 – # ---------------------------
1629 – # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 – # for.
1631 – #
1632 – # Compilers are ordered by
1633 – #  1. Good/tested native compilers, bad/untested native compilers
1634 – #
1635 – # xlf95 is the IBM (AIX) F95 compiler.
1636 – # lf95 is the Lahey-Fujitsu compiler.
1637 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1638 – # AC_PROG_F95
1407  
1408  
1641 – ## ------------------------------- ##
1642 – ## 4. Compilers' characteristics.  ##
1643 – ## ------------------------------- ##
1409  
1410  
1646 – # ---------------------------------------- #
1647 – # 4b. Fortan 90 compiler characteristics.  #
1648 – # ---------------------------------------- #
1411  
1412  
1651 – # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1652 – # -------------------------------------------------
1653 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1654 – # (which default value, $ac_cv_prog_f90_v, is computed by
1655 – # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1656 – # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1657 – # so that any link flags that are echoed by the compiler appear as
1658 – # space-separated items.
1659 – # _AC_PROG_F90_V_OUTPUT
1413  
1414  
1662 – # _AC_PROG_F90_V
1663 – # --------------
1664 – #
1665 – # Determine the flag that causes the Fortran 90 compiler to print
1666 – # information of library and object files (normally -v)
1667 – # Needed for AC_F90_LIBRARY_FLAGS
1668 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1669 – # _AC_PROG_F90_V
1415  
1416  
1417 < # AC_F90_LIBRARY_LDFLAGS
1418 < # ----------------------
1419 < #
1420 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1421 < # intrinsic and run-time libraries that are required to successfully
1422 < # link a Fortran 90 program or shared library.  The output variable
1423 < # F90LIBS is set to these flags.
1679 < #
1680 < # This macro is intended to be used in those situations when it is
1681 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 < # program or shared library.
1683 < #
1684 < # For example, if object files from a C++ and Fortran 90 compiler must
1685 < # be linked together, then the C++ compiler/linker must be used for
1686 < # linking (since special C++-ish things need to happen at link time
1687 < # like calling global constructors, instantiating templates, enabling
1688 < # exception support, etc.).
1689 < #
1690 < # However, the Fortran 90 intrinsic and run-time libraries must be
1691 < # linked in as well, but the C++ compiler/linker doesn't know how to
1692 < # add these Fortran 90 libraries.  Hence, the macro
1693 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 < # libraries.
1695 < #
1696 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 < # AC_F90_LIBRARY_LDFLAGS
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  
1425  
1700 – # _AC_F90_NAME_MANGLING
1701 – # ---------------------
1702 – # Test for the name mangling scheme used by the Fortran 90 compiler.
1703 – #
1704 – # Sets ac_cv_f90_mangling. The value contains three fields, separated
1705 – # by commas:
1706 – #
1707 – # lower case / upper case:
1708 – #    case translation of the Fortan 90 symbols
1709 – # underscore / no underscore:
1710 – #    whether the compiler appends "_" to symbol names
1711 – # extra underscore / no extra underscore:
1712 – #    whether the compiler appends an extra "_" to symbol names already
1713 – #    containing at least one underscore
1714 – #
1715 – # _AC_F90_NAME_MANGLING
1426  
1717 – # The replacement is empty.
1427  
1428  
1429  
1721 – # AC_F90_WRAPPERS
1722 – # ---------------
1723 – # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1724 – # properly mangle the names of C identifiers, and C identifiers with
1725 – # underscores, respectively, so that they match the name mangling
1726 – # scheme used by the Fortran 90 compiler.
1727 – # AC_F90_WRAPPERS
1430  
1431  
1730 – # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1731 – # ------------------------------------
1732 – # For a Fortran subroutine of given NAME, define a shell variable
1733 – # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1734 – # argument is not supplied, it defaults to NAME.
1735 – # AC_F90_FUNC
1432  
1433  
1738 – # ---------------------------------------- #
1739 – # 4c. Fortan 95 compiler characteristics.  #
1740 – # ---------------------------------------- #
1434  
1435  
1743 – # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1744 – # -------------------------------------------------
1745 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1746 – # (which default value, $ac_cv_prog_f95_v, is computed by
1747 – # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1748 – # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1749 – # so that any link flags that are echoed by the compiler appear as
1750 – # space-separated items.
1751 – # _AC_PROG_F95_V_OUTPUT
1752 –
1753 –
1754 – # _AC_PROG_F95_V
1755 – # --------------
1436   #
1757 – # Determine the flag that causes the Fortran 95 compiler to print
1758 – # information of library and object files (normally -v)
1759 – # Needed for AC_F95_LIBRARY_FLAGS
1760 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 – # _AC_PROG_F95_V
1762 –
1763 –
1764 – # AC_F95_LIBRARY_LDFLAGS
1765 – # ----------------------
1437   #
1767 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 – # intrinsic and run-time libraries that are required to successfully
1769 – # link a Fortran 95 program or shared library.  The output variable
1770 – # F95LIBS is set to these flags.
1438   #
1772 – # This macro is intended to be used in those situations when it is
1773 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 – # program or shared library.
1775 – #
1776 – # For example, if object files from a C++ and Fortran 95 compiler must
1777 – # be linked together, then the C++ compiler/linker must be used for
1778 – # linking (since special C++-ish things need to happen at link time
1779 – # like calling global constructors, instantiating templates, enabling
1780 – # exception support, etc.).
1781 – #
1782 – # However, the Fortran 95 intrinsic and run-time libraries must be
1783 – # linked in as well, but the C++ compiler/linker doesn't know how to
1784 – # add these Fortran 95 libraries.  Hence, the macro
1785 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 – # libraries.
1787 – #
1788 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 – # AC_F95_LIBRARY_LDFLAGS
1439  
1440  
1792 – # _AC_F95_NAME_MANGLING
1793 – # ---------------------
1794 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 – #
1796 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 – # by commas:
1798 – #
1799 – # lower case / upper case:
1800 – #    case translation of the Fortan 95 symbols
1801 – # underscore / no underscore:
1802 – #    whether the compiler appends "_" to symbol names
1803 – # extra underscore / no extra underscore:
1804 – #    whether the compiler appends an extra "_" to symbol names already
1805 – #    containing at least one underscore
1806 – #
1807 – # _AC_F95_NAME_MANGLING
1808 –
1809 – # The replacement is empty.
1810 –
1811 –
1812 –
1813 – # AC_F95_WRAPPERS
1814 – # ---------------
1815 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816 – # properly mangle the names of C identifiers, and C identifiers with
1817 – # underscores, respectively, so that they match the name mangling
1818 – # scheme used by the Fortran 95 compiler.
1819 – # AC_F95_WRAPPERS
1820 –
1821 –
1822 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823 – # ------------------------------------
1824 – # For a Fortran subroutine of given NAME, define a shell variable
1825 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826 – # argument is not supplied, it defaults to NAME.
1827 – # AC_F95_FUNC
1828 –
1441   # AC_F90_MODULE_NAMES
1442   # -------------------
1443   #
# Line 1868 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480  
1481  
1482  
1871 –
1872 –
1873 –
1874 –
1875 –
1876 –
1877 –
1878 –
1879 –
1880 –
1881 –
1882 –
1883 –
1884 –
1885 –
1886 –
1887 –
1888 – #
1889 – #
1890 – #
1891 –
1892 –
1893 –
1894 –
1895 –
1896 –
1897 –
1898 –
1899 –
1900 –
1901 –
1902 –
1903 –
1904 –
1905 –
1906 –
1907 –
1908 –
1909 –
1910 –
1911 –
1912 –
1913 –
1914 –
1915 –
1916 –
1917 –
1918 –
1919 –
1920 –
1921 –
1922 –
1923 –
1924 –
1925 –
1926 –
1927 –
1928 –
1929 –
1930 –
1931 –
1932 –
1933 – # set program name
1934 – PROGNAME="oopse"
1935 –
1936 –
1937 – # there are two ways to do debugging.  One with the --enable-debug flag
1938 – # and one using the DEBUG environment variable
1939 –
1940 – debug=0
1941 – # Check whether --enable-debug or --disable-debug was given.
1942 – if test "${enable_debug+set}" = set; then
1943 –  enableval="$enable_debug"
1944 –  debug=1
1945 – fi;
1946 – if test "${DEBUG}"; then
1947 –
1948 – cat >>confdefs.h <<\_ACEOF
1949 – #define debug 1
1950 – _ACEOF
1951 –
1952 –  msg="$msg, debug mode"
1953 – fi
1954 –
1955 –
1483   # who am i
1484   # Make sure we can run config.sub.
1485   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 2011 | 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 pathcc 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 2036 | 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 2045 | 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 pathcc 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 2078 | 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 2087 | 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  
2106 – test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2107 – See \`config.log' for more details." >&5
2108 – echo "$as_me: error: no acceptable C compiler found in \$PATH
2109 – See \`config.log' for more details." >&2;}
2110 –   { (exit 1); exit 1; }; }
2111 –
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 2149 | 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 2193 | 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 2206 | 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 2222 | 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 2330 | 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 2362 | 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 2383 | 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 2421 | 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 2434 | 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
2464 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2465 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2466 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2467 < else
2468 <  ac_cv_prog_cc_stdc=no
2469 < ac_save_CC=$CC
2470 < cat >conftest.$ac_ext <<_ACEOF
2471 < /* confdefs.h.  */
2472 < _ACEOF
2473 < cat confdefs.h >>conftest.$ac_ext
2474 < cat >>conftest.$ac_ext <<_ACEOF
2475 < /* end confdefs.h.  */
2476 < #include <stdarg.h>
2477 < #include <stdio.h>
2478 < #include <sys/types.h>
2479 < #include <sys/stat.h>
2480 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2481 < struct buf { int x; };
2482 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2483 < static char *e (p, i)
2484 <     char **p;
2485 <     int i;
2486 < {
2487 <  return p[i];
2488 < }
2489 < static char *f (char * (*g) (char **, int), char **p, ...)
2490 < {
2491 <  char *s;
2492 <  va_list v;
2493 <  va_start (v,p);
2494 <  s = g (p, va_arg (v,int));
2495 <  va_end (v);
2496 <  return s;
2497 < }
2498 <
2499 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2500 <   function prototypes and stuff, but not '\xHH' hex character constants.
2501 <   These don't provoke an error unfortunately, instead are silently treated
2502 <   as 'x'.  The following induces an error, until -std1 is added to get
2503 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2504 <   array size at least.  It's necessary to write '\x00'==0 to get something
2505 <   that's true only with -std1.  */
2506 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2507 <
2508 < int test (int i, double x);
2509 < struct s1 {int (*f) (int a);};
2510 < struct s2 {int (*f) (double a);};
2511 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2512 < int argc;
2513 < char **argv;
2514 < int
2515 < main ()
2516 < {
2517 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2518 <  ;
2519 <  return 0;
2520 < }
2521 < _ACEOF
2522 < # Don't try gcc -ansi; that turns off useful extensions and
2523 < # breaks some systems' header files.
2524 < # AIX                   -qlanglvl=ansi
2525 < # Ultrix and OSF/1      -std1
2526 < # HP-UX 10.20 and later -Ae
2527 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2528 < # SVR4                  -Xc -D__EXTENSIONS__
2529 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2530 < do
2531 <  CC="$ac_save_CC $ac_arg"
2532 <  rm -f conftest.$ac_objext
2533 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2534 <  (eval $ac_compile) 2>conftest.er1
2535 <  ac_status=$?
2536 <  grep -v '^ *+' conftest.er1 >conftest.err
2537 <  rm -f conftest.er1
2538 <  cat conftest.err >&5
2539 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2540 <  (exit $ac_status); } &&
2541 <         { ac_try='test -z "$ac_c_werror_flag"
2542 <                         || test ! -s conftest.err'
2543 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2544 <  (eval $ac_try) 2>&5
2545 <  ac_status=$?
2546 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547 <  (exit $ac_status); }; } &&
2548 <         { ac_try='test -s conftest.$ac_objext'
2549 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2550 <  (eval $ac_try) 2>&5
2551 <  ac_status=$?
2552 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2553 <  (exit $ac_status); }; }; then
2554 <  ac_cv_prog_cc_stdc=$ac_arg
2555 < break
2556 < else
2557 <  echo "$as_me: failed program was:" >&5
2558 < sed 's/^/| /' conftest.$ac_ext >&5
2559 <
2560 < fi
2561 < rm -f conftest.err conftest.$ac_objext
2562 < done
2563 < rm -f conftest.$ac_ext conftest.$ac_objext
2564 < CC=$ac_save_CC
2565 <
2566 < fi
2567 <
2568 < case "x$ac_cv_prog_cc_stdc" in
2569 <  x|xno)
2570 <    echo "$as_me:$LINENO: result: none needed" >&5
2571 < echo "${ECHO_T}none needed" >&6 ;;
2572 <  *)
2573 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2574 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2575 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2576 < esac
2577 <
2578 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2579 < # in C++ we need to declare it.  In case someone uses the same compiler
2580 < # for both compiling C and C++ we need to have the C++ compiler decide
2581 < # the declaration of exit, since it's the most demanding environment.
2582 < cat >conftest.$ac_ext <<_ACEOF
2583 < #ifndef __cplusplus
2584 <  choke me
2585 < #endif
2586 < _ACEOF
2587 < rm -f conftest.$ac_objext
2588 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2589 <  (eval $ac_compile) 2>conftest.er1
2590 <  ac_status=$?
2591 <  grep -v '^ *+' conftest.er1 >conftest.err
2592 <  rm -f conftest.er1
2593 <  cat conftest.err >&5
2594 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2595 <  (exit $ac_status); } &&
2596 <         { ac_try='test -z "$ac_c_werror_flag"
2597 <                         || test ! -s conftest.err'
2598 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2599 <  (eval $ac_try) 2>&5
2600 <  ac_status=$?
2601 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2602 <  (exit $ac_status); }; } &&
2603 <         { ac_try='test -s conftest.$ac_objext'
2604 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2605 <  (eval $ac_try) 2>&5
2606 <  ac_status=$?
2607 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2608 <  (exit $ac_status); }; }; then
2609 <  for ac_declaration in \
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 2639 | 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 2684 | 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 2712 | Line 2130 | fi
2130    echo '#endif'             >>confdefs.h
2131   fi
2132  
2133 < else
2134 <  echo "$as_me: failed program was:" >&5
2135 < sed 's/^/| /' conftest.$ac_ext >&5
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  
2719 – fi
2720 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
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
2726 –
2727 –
2728 – ac_ext=cc
2729 – ac_cpp='$CXXCPP $CPPFLAGS'
2730 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2731 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2732 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2144   if test -n "$ac_tool_prefix"; then
2145 <  for ac_prog in $CCC pathCC 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 2750 | 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 2759 | 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 pathCC 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 2792 | 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 2801 | 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
2815 – 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 2838 | 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 2870 | 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 2891 | 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 2929 | 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 2942 | 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 \
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 > #include <stdarg.h>
2401 > #include <stdio.h>
2402 > #include <sys/types.h>
2403 > #include <sys/stat.h>
2404 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2405 > struct buf { int x; };
2406 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2407 > static char *e (p, i)
2408 >     char **p;
2409 >     int i;
2410 > {
2411 >  return p[i];
2412 > }
2413 > static char *f (char * (*g) (char **, int), char **p, ...)
2414 > {
2415 >  char *s;
2416 >  va_list v;
2417 >  va_start (v,p);
2418 >  s = g (p, va_arg (v,int));
2419 >  va_end (v);
2420 >  return s;
2421 > }
2422 >
2423 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2424 >   function prototypes and stuff, but not '\xHH' hex character constants.
2425 >   These don't provoke an error unfortunately, instead are silently treated
2426 >   as 'x'.  The following induces an error, until -std1 is added to get
2427 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2428 >   array size at least.  It's necessary to write '\x00'==0 to get something
2429 >   that's true only with -std1.  */
2430 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2431 >
2432 > int test (int i, double x);
2433 > struct s1 {int (*f) (int a);};
2434 > struct s2 {int (*f) (double a);};
2435 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2436 > int argc;
2437 > char **argv;
2438 > int
2439 > main ()
2440 > {
2441 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2442 >  ;
2443 >  return 0;
2444 > }
2445 > _ACEOF
2446 > # Don't try gcc -ansi; that turns off useful extensions and
2447 > # breaks some systems' header files.
2448 > # AIX                   -qlanglvl=ansi
2449 > # Ultrix and OSF/1      -std1
2450 > # HP-UX 10.20 and later -Ae
2451 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2452 > # SVR4                  -Xc -D__EXTENSIONS__
2453 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2454 > do
2455 >  CC="$ac_save_CC $ac_arg"
2456 >  rm -f conftest.$ac_objext
2457 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2458 >  (eval $ac_compile) 2>conftest.er1
2459 >  ac_status=$?
2460 >  grep -v '^ *+' conftest.er1 >conftest.err
2461 >  rm -f conftest.er1
2462 >  cat conftest.err >&5
2463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2464 >  (exit $ac_status); } &&
2465 >         { ac_try='test -z "$ac_c_werror_flag"
2466 >                         || test ! -s conftest.err'
2467 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468 >  (eval $ac_try) 2>&5
2469 >  ac_status=$?
2470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471 >  (exit $ac_status); }; } &&
2472 >         { ac_try='test -s conftest.$ac_objext'
2473 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474 >  (eval $ac_try) 2>&5
2475 >  ac_status=$?
2476 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477 >  (exit $ac_status); }; }; then
2478 >  ac_cv_prog_cc_stdc=$ac_arg
2479 > break
2480 > else
2481 >  echo "$as_me: failed program was:" >&5
2482 > sed 's/^/| /' conftest.$ac_ext >&5
2483 >
2484 > fi
2485 > rm -f conftest.err conftest.$ac_objext
2486 > done
2487 > rm -f conftest.$ac_ext conftest.$ac_objext
2488 > CC=$ac_save_CC
2489 >
2490 > fi
2491 >
2492 > case "x$ac_cv_prog_cc_stdc" in
2493 >  x|xno)
2494 >    echo "$as_me:$LINENO: result: none needed" >&5
2495 > echo "${ECHO_T}none needed" >&6 ;;
2496 >  *)
2497 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2500 > esac
2501 >
2502 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2503 > # in C++ we need to declare it.  In case someone uses the same compiler
2504 > # for both compiling C and C++ we need to have the C++ compiler decide
2505 > # the declaration of exit, since it's the most demanding environment.
2506 > cat >conftest.$ac_ext <<_ACEOF
2507 > #ifndef __cplusplus
2508 >  choke me
2509 > #endif
2510 > _ACEOF
2511 > rm -f conftest.$ac_objext
2512 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513 >  (eval $ac_compile) 2>conftest.er1
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;' \
# Line 3001 | Line 2563 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2563    cat conftest.err >&5
2564    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565    (exit $ac_status); } &&
2566 <         { ac_try='test -z "$ac_cxx_werror_flag"
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 3046 | 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 3074 | 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 + 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 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_FC+set}" = set; then
2663 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2664 + else
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
2670 + do
2671 +  IFS=$as_save_IFS
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_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
2679 + done
2680 + done
2681  
2682 + fi
2683 + fi
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 "$FC" && break
2694 +  done
2695 + fi
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_FC+set}" = set; then
2705 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2706 + else
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
2712 + do
2713 +  IFS=$as_save_IFS
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_FC="$ac_prog"
2718 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719 +    break 2
2720 +  fi
2721 + done
2722 + done
2723 +
2724 + fi
2725 + fi
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_FC" && break
2736 + done
2737 +
2738 +  FC=$ac_ct_FC
2739 + fi
2740 +
2741 +
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=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 +      program main
2774 + #ifndef __GNUC__
2775 +       choke me
2776 + #endif
2777 +
2778 +      end
2779 + _ACEOF
2780 + rm -f conftest.$ac_objext
2781 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2782 +  (eval $ac_compile) 2>conftest.er1
2783 +  ac_status=$?
2784 +  grep -v '^ *+' conftest.er1 >conftest.err
2785 +  rm -f conftest.er1
2786 +  cat conftest.err >&5
2787 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788 +  (exit $ac_status); } &&
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
2793 +  ac_status=$?
2794 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2795 +  (exit $ac_status); }; } &&
2796 +         { ac_try='test -s conftest.$ac_objext'
2797 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2798 +  (eval $ac_try) 2>&5
2799 +  ac_status=$?
2800 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2801 +  (exit $ac_status); }; }; then
2802 +  ac_compiler_gnu=yes
2803 + else
2804 +  echo "$as_me: failed program was:" >&5
2805 + sed 's/^/| /' conftest.$ac_ext >&5
2806 +
2807 + ac_compiler_gnu=no
2808 + fi
2809 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810 + ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811 +
2812 + fi
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 + 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 +      end
2829 + _ACEOF
2830 + rm -f conftest.$ac_objext
2831 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2832 +  (eval $ac_compile) 2>conftest.er1
2833 +  ac_status=$?
2834 +  grep -v '^ *+' conftest.er1 >conftest.err
2835 +  rm -f conftest.er1
2836 +  cat conftest.err >&5
2837 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838 +  (exit $ac_status); } &&
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
2843 +  ac_status=$?
2844 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2845 +  (exit $ac_status); }; } &&
2846 +         { ac_try='test -s conftest.$ac_objext'
2847 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2848 +  (eval $ac_try) 2>&5
2849 +  ac_status=$?
2850 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851 +  (exit $ac_status); }; }; then
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 + ac_cv_prog_fc_g=no
2858 + fi
2859 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860 +
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.
# Line 3315 | Line 3117 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
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  
3318 –
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
# Line 3331 | Line 3132 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132   EGREP=$ac_cv_prog_egrep
3133  
3134  
3135 <
3136 < OOPSE_TEMPLATE_FLAGS=""
3137 < if test $ac_cv_cxx_compiler_gnu = no; then
3138 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3139 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3339 <  echo 'void f(){}' > conftest.cc
3340 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3341 <    echo "$as_me:$LINENO: result: yes" >&5
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 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3142 <  else
3143 <    echo "$as_me:$LINENO: result: no" >&5
3144 < echo "${ECHO_T}no" >&6
3145 <  fi
3146 <  rm -f conftest*
3147 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3148 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3149 <  echo 'void f(){}' > conftest.cc
3150 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3151 <    echo "$as_me:$LINENO: result: yes" >&5
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 > 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 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3169 <  else
3170 <    echo "$as_me:$LINENO: result: no" >&5
3168 >  SET_MAKE=
3169 > else
3170 >  echo "$as_me:$LINENO: result: no" >&5
3171 > echo "${ECHO_T}no" >&6
3172 >  SET_MAKE="MAKE=${MAKE-make}"
3173 > fi
3174 >
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 >
3200 > fi
3201 > 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:$LINENO: result: no" >&5
3208   echo "${ECHO_T}no" >&6
3209 + fi
3210 +
3211 + fi
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 -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 <  rm -f conftest*
3236 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3237 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3238 <  echo 'void f(){}' > conftest.cc
3239 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3240 <    echo "$as_me:$LINENO: result: yes" >&5
3241 < echo "${ECHO_T}yes" >&6
3242 <    OOPSE_TEMPLATE_FLAGS="-pto"
3243 <  else
3244 <    echo "$as_me:$LINENO: result: no" >&5
3235 > done
3236 > done
3237 >
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 +  RANLIB=$ac_ct_RANLIB
3251 + else
3252 +  RANLIB="$ac_cv_prog_RANLIB"
3253 + fi
3254 +
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 <  rm -f conftest*
3280 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3374 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3375 <  echo 'void f(){}' > conftest.cc
3376 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3377 <    echo "$as_me:$LINENO: result: yes" >&5
3378 < echo "${ECHO_T}yes" >&6
3279 > done
3280 > done
3281  
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 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3289 <  else
3290 <    echo "$as_me:$LINENO: result: no" >&5
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_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 < ac_ext=f90
3454 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3455 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3456 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3457 < if test -n "$ac_tool_prefix"; then
3458 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3459 <  do
3398 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3399 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
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_F90+set}" = set; then
3462 > if test "${ac_cv_prog_AR+set}" = set; then
3463    echo $ECHO_N "(cached) $ECHO_C" >&6
3464   else
3465 <  if test -n "$F90"; then
3466 <  ac_cv_prog_F90="$F90" # Let the user override the test.
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
# Line 3412 | Line 3472 | do
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_F90="$ac_tool_prefix$ac_prog"
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 < F90=$ac_cv_prog_F90
3486 < if test -n "$F90"; then
3487 <  echo "$as_me:$LINENO: result: $F90" >&5
3488 < echo "${ECHO_T}$F90" >&6
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 <    test -n "$F90" && break
3495 <  done
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 < if test -z "$F90"; then
3552 <  ac_ct_F90=$F90
3553 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3554 < do
3555 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3441 < set dummy $ac_prog; ac_word=$2
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_prog_ac_ct_F90+set}" = set; then
3558 > if test "${ac_cv_path_PS+set}" = set; then
3559    echo $ECHO_N "(cached) $ECHO_C" >&6
3560   else
3561 <  if test -n "$ac_ct_F90"; then
3562 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3563 < else
3564 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
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_prog_ac_ct_F90="$ac_prog"
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 < fi
3584 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3585 < if test -n "$ac_ct_F90"; then
3586 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3587 < echo "${ECHO_T}$ac_ct_F90" >&6
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 <  test -n "$ac_ct_F90" && break
3594 < done
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 <  F90=$ac_ct_F90
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 we don't use `.F90' as extension, the preprocessor is not run on the
3630 < # input file.
3631 < ac_save_ext=$ac_ext
3632 < ac_ext=F90
3633 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3634 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3488 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3489 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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 <  cat >conftest.$ac_ext <<_ACEOF
3636 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637  
3638 < program main
3638 > cat >>confdefs.h <<\_ACEOF
3639 > #define PSTYPE_IS_POSIX 1
3640 > _ACEOF
3641  
3642 < #ifndef __GNUC__
3643 <       choke me
3644 < #endif
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 < end program main
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
# Line 3508 | Line 3677 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3677    cat conftest.err >&5
3678    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679    (exit $ac_status); } &&
3680 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3521 | Line 3690 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3690    ac_status=$?
3691    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692    (exit $ac_status); }; }; then
3693 <  ac_compiler_gnu=yes
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  
3529 – ac_compiler_gnu=no
3698   fi
3699   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
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_f90_compiler_gnu" >&5
3706 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3707 < ac_ext=$ac_save_ext
3708 < G95=`test $ac_compiler_gnu = yes && echo yes`
3709 < ac_ext=c
3710 < ac_cpp='$CPP $CPPFLAGS'
3711 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3712 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3713 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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  
# Line 3553 | Line 3732 | if test "$ac_test_PREPFLAG" != "set"; then
3732    PREPFLAG=""
3733    case "${host_cpu}-${host_os}" in
3734  
3735 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3735 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736                      PREPFLAG="-fpp1 "
3737                  fi;;
3738 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
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 "$F90" = f90 -o "$F90" = xlf90; then
3742 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743                  PREPFLAG="-qsuffix=cpp=F90 "
3744          fi;;
3745    esac
# Line 3575 | Line 3754 | echo $ECHO_N "checking to make sure F90 preprocessor f
3754   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755  
3756  
3757 <  ac_ext=f90
3758 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3759 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3760 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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_F90FLAGS=$F90FLAGS
3764 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765  
3766    if test "$PREPFLAG"; then
3767 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3767 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3768   fi
3769  
3770      cat >conftest.$ac_ext <<_ACEOF
3771  
3772  
3773 < program main
3595 <
3773 > program conftest
3774    integer :: i
3775    i = 1
3776 + end program conftest
3777  
3599 –
3600 – end program main
3601 –
3778   _ACEOF
3779   rm -f conftest.$ac_objext
3780   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3609 | Line 3785 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785    cat conftest.err >&5
3786    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787    (exit $ac_status); } &&
3788 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3631 | Line 3807 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3807   fi
3808   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809  
3810 <  F90FLAGS=$ac_save_F90FLAGS
3810 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811    ac_ext=$ac_save_ext
3812 <  ac_ext=c
3813 < ac_cpp='$CPP $CPPFLAGS'
3814 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3815 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3640 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3641 <
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
# Line 3664 | Line 3840 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3840    PREPDEFFLAG=""
3841    case "${host_cpu}-${host_os}" in
3842  
3843 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3843 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844                      PREPDEFFLAG=" "
3845                  fi;;
3846 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3846 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847                      PREPDEFFLAG="-WF,"
3848                  fi;;
3849    *darwin*)
3850 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3850 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851                  PREPDEFFLAG="-WF,"
3852          fi;;
3853    esac
# Line 3686 | Line 3862 | echo $ECHO_N "checking to make sure F90 preprocessor d
3862   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863  
3864  
3865 <  ac_ext=f90
3866 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3867 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3868 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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_F90FLAGS=$F90FLAGS
3872 >  ac_save_FCFLAGS=$FCFLAGS
3873  
3874    if test "$PREPDEFFLAG"; then
3875 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3875 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876   fi
3877  
3878      cat >conftest.$ac_ext <<_ACEOF
3879  
3880  
3881 < program main
3706 <
3881 > program conftest
3882    integer :: i
3883   #ifdef TEST
3884    i = 1
3885   #else
3886    choke me
3887   #endif
3888 + end program conftest
3889  
3714 –
3715 – end program main
3716 –
3890   _ACEOF
3891   rm -f conftest.$ac_objext
3892   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3724 | Line 3897 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3897    cat conftest.err >&5
3898    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899    (exit $ac_status); } &&
3900 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3746 | Line 3919 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3919   fi
3920   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921  
3922 <  F90FLAGS=$ac_save_F90FLAGS
3922 >  FCFLAGS=$ac_save_FCFLAGS
3923    ac_ext=$ac_save_ext
3924 <  ac_ext=c
3925 < ac_cpp='$CPP $CPPFLAGS'
3926 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3927 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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  
3758 –
3930    if test "$prepdefflagworks" = 1; then
3931      echo "$as_me:$LINENO: result: yes" >&5
3932   echo "${ECHO_T}yes" >&6
# Line 3769 | Line 3940 | fi
3940    fi
3941   fi
3942  
3943 < ac_ext=f90
3944 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3945 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3946 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3947 <
3948 <
3949 <
3779 < ac_ext=f90
3780 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3781 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3782 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3783 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3784 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3785 < if test "${ac_cv_prog_f90_v+set}" = set; then
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 < cat >conftest.$ac_ext <<_ACEOF
3790 <
3791 < program main
3792 <
3793 <
3794 < end program main
3795 <
3955 >      end
3956   _ACEOF
3957   rm -f conftest.$ac_objext
3958   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3803 | Line 3963 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3963    cat conftest.err >&5
3964    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965    (exit $ac_status); } &&
3966 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3816 | Line 3976 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3976    ac_status=$?
3977    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978    (exit $ac_status); }; }; then
3979 <  ac_cv_prog_f90_v=
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 <  ac_ext=f90
3983 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3824 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3825 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3982 >  cat >conftest.$ac_ext <<_ACEOF
3983 >      program main
3984  
3985 < cat >conftest.$ac_ext <<_ACEOF
3828 <
3829 < program main
3830 <
3831 <
3832 < end program main
3833 <
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 90 compiler in order to get
3990 < # "verbose" output that we can then parse for the Fortran 90 linker
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_F90FLAGS=$F90FLAGS
3993 < F90FLAGS="$F90FLAGS $ac_verb"
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 < (eval echo $as_me:3843: \"$ac_link\") >&5
3844 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3845 < echo "$ac_f90_v_output" >&5
3846 < F90FLAGS=$ac_save_F90FLAGS
3999 > rm -f conftest*
4000  
4001 < rm -f conftest.*
4002 < ac_ext=f90
4003 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4004 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4005 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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 < # If we are using xlf then replace all the commas with spaces.
4009 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4010 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4011 < fi
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 < # If we are using Cray Fortran then delete quotes.
4014 < # Use "\"" instead of '"' for font-lock-mode.
4015 < # FIXME: a more general fix for quoted arguments with spaces?
4016 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4017 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4018 < fi
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_f90_v_output; do
4027 >  for ac_arg in $ac_fc_v_output; do
4028       case $ac_arg in
4029          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030 <          ac_cv_prog_f90_v=$ac_verb
4030 >          ac_cv_prog_fc_v=$ac_verb
4031            break 2 ;;
4032       esac
4033    done
4034   done
4035 < if test -z "$ac_cv_prog_f90_v"; then
4036 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4037 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
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
# Line 3885 | Line 4046 | fi
4046   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047  
4048   fi
4049 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4050 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4051 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4052 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4053 < if test "${ac_cv_flibs+set}" = set; then
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$F90LIBS" != "x"; then
4057 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4056 >  if test "x$FCLIBS" != "x"; then
4057 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058   else
4059  
3899 – ac_ext=f90
3900 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3901 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3902 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3903 –
4060   cat >conftest.$ac_ext <<_ACEOF
4061 +      program main
4062  
4063 < program main
3907 <
3908 <
3909 < end program main
3910 <
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 90 compiler in order to get
4068 < # "verbose" output that we can then parse for the Fortran 90 linker
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_F90FLAGS=$F90FLAGS
4071 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
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 < (eval echo $as_me:3920: \"$ac_link\") >&5
3921 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3922 < echo "$ac_f90_v_output" >&5
3923 < F90FLAGS=$ac_save_F90FLAGS
4077 > rm -f conftest*
4078  
4079 < rm -f conftest.*
4080 < ac_ext=f90
4081 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4082 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4083 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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 < # If we are using xlf then replace all the commas with spaces.
4087 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4088 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4089 < fi
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 < # If we are using Cray Fortran then delete quotes.
4092 < # Use "\"" instead of '"' for font-lock-mode.
4093 < # FIXME: a more general fix for quoted arguments with spaces?
4094 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3940 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3941 < fi
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 < ac_cv_f90libs=
4096 >  # If we are using Cray Fortran then delete quotes.
4097 >  # Use "\"" instead of '"' for font-lock-mode.
4098 >  # FIXME: a more general fix for quoted arguments with spaces?
4099 >  *cft90*)
4100 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101 > esac
4102  
4103 +
4104 +
4105 + ac_cv_fc_libs=
4106 +
4107   # Save positional arguments (if any)
4108   ac_save_positional="$@"
4109  
4110 < set X $ac_f90_v_output
4110 > set X $ac_fc_v_output
4111   while test $# != 1; do
4112    shift
4113    ac_arg=$1
4114    case $ac_arg in
4115          [\\/]*.a | ?:[\\/]*.a)
4116              ac_exists=false
4117 <  for ac_i in $ac_cv_f90libs; do
4117 >  for ac_i in $ac_cv_fc_libs; do
4118      if test x"$ac_arg" = x"$ac_i"; then
4119        ac_exists=true
4120        break
# Line 3962 | Line 4124 | else
4124    if test x"$ac_exists" = xtrue; then
4125    :
4126   else
4127 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4127 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4128   fi
4129  
4130            ;;
4131          -bI:*)
4132              ac_exists=false
4133 <  for ac_i in $ac_cv_f90libs; do
4133 >  for ac_i in $ac_cv_fc_libs; do
4134      if test x"$ac_arg" = x"$ac_i"; then
4135        ac_exists=true
4136        break
# Line 3980 | Line 4142 | else
4142   else
4143    if test "$ac_compiler_gnu" = yes; then
4144    for ac_link_opt in $ac_arg; do
4145 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4145 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146    done
4147   else
4148 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4148 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149   fi
4150   fi
4151  
4152            ;;
4153            # Ignore these flags.
4154 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4154 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155            ;;
4156          -lkernel32)
4157 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4157 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4158            ;;
4159          -[LRuY])
4160            # These flags, when seen by themselves, take an argument.
4161            # We remove the space between option and argument and re-iterate
4162            # unless we find an empty arg or a new option (starting with -)
4163            case $2 in
4164 <             "" | -*);;
4165 <             *)
4164 >             "" | -*);;
4165 >             *)
4166                  ac_arg="$ac_arg$2"
4005 –
4167                  shift; shift
4168                  set X $ac_arg "$@"
4169                  ;;
# Line 4011 | Line 4172 | fi
4172          -YP,*)
4173            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4174                ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_j" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 4022 | Line 4183 | else
4183    :
4184   else
4185    ac_arg="$ac_arg $ac_j"
4186 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4186 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4187   fi
4188  
4189            done
4190            ;;
4191          -[lLR]*)
4192              ac_exists=false
4193 <  for ac_i in $ac_cv_f90libs; do
4193 >  for ac_i in $ac_cv_fc_libs; do
4194      if test x"$ac_arg" = x"$ac_i"; then
4195        ac_exists=true
4196        break
# Line 4039 | Line 4200 | else
4200    if test x"$ac_exists" = xtrue; then
4201    :
4202   else
4203 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4203 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204   fi
4205  
4206            ;;
# Line 4054 | Line 4215 | case `(uname -sr) 2>/dev/null` in
4215   # must begin with a "/").
4216   case `(uname -sr) 2>/dev/null` in
4217     "SunOS 5"*)
4218 <      ac_ld_run_path=`echo $ac_f90_v_output |
4218 >      ac_ld_run_path=`echo $ac_fc_v_output |
4219                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4220        test "x$ac_ld_run_path" != x &&
4060 –
4221          if test "$ac_compiler_gnu" = yes; then
4222    for ac_link_opt in $ac_ld_run_path; do
4223 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4223 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224    done
4225   else
4226 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4226 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227   fi
4228        ;;
4229   esac
4230 < fi # test "x$F90LIBS" = "x"
4230 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231  
4232   fi
4233 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4234 < echo "${ECHO_T}$ac_cv_flibs" >&6
4235 < F90LIBS="$ac_cv_f90libs"
4233 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4234 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4235 > FCLIBS="$ac_cv_fc_libs"
4236  
4077 – ac_ext=f90
4078 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4079 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4080 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4237  
4238 + ac_ext=${FC_SRCEXT-f}
4239 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4240 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4241 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4242  
4243 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4244 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4245 < if test "${ac_cv_f90_mangling+set}" = set; then
4243 >
4244 > ac_ext=${FC_SRCEXT-f}
4245 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4246 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4247 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4248 >
4249 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4250 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4251 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4252    echo $ECHO_N "(cached) $ECHO_C" >&6
4253   else
4254 <  ac_ext=f90
4255 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4256 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4257 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4258 < cat >conftest.$ac_ext <<_ACEOF
4259 < subroutine foobar()
4260 < return
4261 < end
4262 < subroutine foo_bar()
4263 < return
4264 < end
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
# Line 4106 | Line 4440 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4440    cat conftest.err >&5
4441    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442    (exit $ac_status); } &&
4443 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 4119 | Line 4453 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4453    ac_status=$?
4454    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455    (exit $ac_status); }; }; then
4456 <  mv conftest.$ac_objext cf90_test.$ac_objext
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
4129 –
4130 –  ac_save_LIBS=$LIBS
4131 –  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4132 –
4466    ac_success=no
4467    for ac_foobar in foobar FOOBAR; do
4468      for ac_underscore in "" "_"; do
# Line 4148 | Line 4481 | char $ac_func ();
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   {
# Line 4188 | Line 4529 | 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 <           ;;
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 <
4208 <        cat >conftest.$ac_ext <<_ACEOF
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
# Line 4219 | Line 4568 | char $ac_func ();
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   {
# Line 4258 | Line 4615 | rm -f conftest.err conftest.$ac_objext \
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_f90_mangling="$ac_case case"
4624 >        ac_cv_fc_mangling="$ac_case case"
4625          if test -z "$ac_underscore"; then
4626 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4626 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627          else
4628 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4268 <
4628 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629          fi
4630          if test -z "$ac_extra"; then
4631 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4631 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632          else
4633 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4633 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634          fi
4635        else
4636 <        ac_cv_f90_mangling="unknown"
4636 >        ac_cv_fc_mangling="unknown"
4637        fi
4638    else
4639 <     ac_cv_f90_mangling="unknown"
4280 <
4639 >     ac_cv_fc_mangling="unknown"
4640    fi
4641  
4642    LIBS=$ac_save_LIBS
4643 <  ac_ext=f90
4285 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4286 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4287 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4288 <  rm -f cf90_test* conftest*
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
4295 – ac_ext=f90
4296 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4297 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4298 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4655  
4656   fi
4657 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4658 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
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 < case $ac_cv_f90_mangling in
4670 >
4671 > case $ac_cv_fc_mangling in
4672    "lower case, no underscore, no extra underscore")
4673            cat >>confdefs.h <<\_ACEOF
4674 < #define F90_FUNC(name,NAME) name
4674 > #define FC_FUNC(name,NAME) name
4675   _ACEOF
4676  
4677            cat >>confdefs.h <<\_ACEOF
4678 < #define F90_FUNC_(name,NAME) name
4678 > #define FC_FUNC_(name,NAME) name
4679   _ACEOF
4680   ;;
4681    "lower case, no underscore, extra underscore")
4682            cat >>confdefs.h <<\_ACEOF
4683 < #define F90_FUNC(name,NAME) name
4683 > #define FC_FUNC(name,NAME) name
4684   _ACEOF
4685  
4686            cat >>confdefs.h <<\_ACEOF
4687 < #define F90_FUNC_(name,NAME) name ## _
4687 > #define FC_FUNC_(name,NAME) name ## _
4688   _ACEOF
4689   ;;
4690    "lower case, underscore, no extra underscore")
4691            cat >>confdefs.h <<\_ACEOF
4692 < #define F90_FUNC(name,NAME) name ## _
4692 > #define FC_FUNC(name,NAME) name ## _
4693   _ACEOF
4694  
4695            cat >>confdefs.h <<\_ACEOF
4696 < #define F90_FUNC_(name,NAME) name ## _
4696 > #define FC_FUNC_(name,NAME) name ## _
4697   _ACEOF
4698   ;;
4699    "lower case, underscore, extra underscore")
4700            cat >>confdefs.h <<\_ACEOF
4701 < #define F90_FUNC(name,NAME) name ## _
4701 > #define FC_FUNC(name,NAME) name ## _
4702   _ACEOF
4703  
4704            cat >>confdefs.h <<\_ACEOF
4705 < #define F90_FUNC_(name,NAME) name ## __
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 F90_FUNC(name,NAME) NAME
4710 > #define FC_FUNC(name,NAME) NAME
4711   _ACEOF
4712  
4713            cat >>confdefs.h <<\_ACEOF
4714 < #define F90_FUNC_(name,NAME) NAME
4714 > #define FC_FUNC_(name,NAME) NAME
4715   _ACEOF
4716   ;;
4717    "upper case, no underscore, extra underscore")
4718            cat >>confdefs.h <<\_ACEOF
4719 < #define F90_FUNC(name,NAME) NAME
4719 > #define FC_FUNC(name,NAME) NAME
4720   _ACEOF
4721  
4722            cat >>confdefs.h <<\_ACEOF
4723 < #define F90_FUNC_(name,NAME) NAME ## _
4723 > #define FC_FUNC_(name,NAME) NAME ## _
4724   _ACEOF
4725   ;;
4726    "upper case, underscore, no extra underscore")
4727            cat >>confdefs.h <<\_ACEOF
4728 < #define F90_FUNC(name,NAME) NAME ## _
4728 > #define FC_FUNC(name,NAME) NAME ## _
4729   _ACEOF
4730  
4731            cat >>confdefs.h <<\_ACEOF
4732 < #define F90_FUNC_(name,NAME) NAME ## _
4732 > #define FC_FUNC_(name,NAME) NAME ## _
4733   _ACEOF
4734   ;;
4735    "upper case, underscore, extra underscore")
4736            cat >>confdefs.h <<\_ACEOF
4737 < #define F90_FUNC(name,NAME) NAME ## _
4737 > #define FC_FUNC(name,NAME) NAME ## _
4738   _ACEOF
4739  
4740            cat >>confdefs.h <<\_ACEOF
4741 < #define F90_FUNC_(name,NAME) NAME ## __
4741 > #define FC_FUNC_(name,NAME) NAME ## __
4742   _ACEOF
4743   ;;
4744    *)
4745 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4746 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
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.f90 <<EOF
5064 > cat >conftest.$ac_ext <<EOF
5065          module conftest
5066          integer n
5067          parameter (n=1)
# Line 4400 | Line 5070 | modcase="lower"
5070   # SGI and absoft compilers generates module name in upper case!
5071   testname="conftest"
5072   modcase="lower"
5073 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5074 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
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.f | grep -v CONFTEST.o`
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"
# Line 4445 | Line 5115 | rm -f work*
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.f90 <<EOF
5118 > cat >conftest.$ac_ext <<EOF
5119          module conftest
5120          integer n
5121          parameter (n=1)
# Line 4453 | Line 5123 | testname="conftest"
5123   EOF
5124   # SGI and absoft compilers generates module name in upper case!
5125   testname="conftest"
5126 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5127 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
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"
# Line 4463 | Line 5133 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5133     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134     cp $testname.$MOD conf
5135     rm -f conftest* CONFTEST*
5136 <   cat >conftest1.f90 <<EOF
5136 >   cat >conftest1.$ac_ext <<EOF
5137          program main
5138          use conftest
5139          print *, n
# Line 4471 | Line 5141 | EOF
5141   EOF
5142     F90_WORK_FILES_ARG=""
5143     F90MODINCSPEC=""
5144 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
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 $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
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 $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
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
# Line 4490 | Line 5160 | echo "${ECHO_T}-p" >&6
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 $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
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
# Line 4520 | Line 5190 | else
5190   if test "${ac_cv_f90_module_names+set}" = set; then
5191    echo $ECHO_N "(cached) $ECHO_C" >&6
5192   else
5193 <  ac_ext=f90
5194 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5195 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5196 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
# Line 4541 | Line 5211 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5211    cat conftest.err >&5
5212    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213    (exit $ac_status); } &&
5214 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 4657 | Line 5327 | rm -rf conftest
5327   cd ..
5328   # cleanup
5329   rm -rf conftest
5330 < ac_ext=f90
5331 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5332 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5333 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
# Line 4749 | Line 5419 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5419   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420  
5421  
5422 < ac_ext=cc
5423 < ac_cpp='$CXXCPP $CPPFLAGS'
5424 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
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 < ac_ext=cc
5430 < ac_cpp='$CXXCPP $CPPFLAGS'
5431 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5432 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4763 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4764 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
4765 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
4766 < if test -z "$CXXCPP"; then
4767 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
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 <      # Double quotes because CXXCPP needs to be expanded
5436 <    for CXXCPP in "$CXX -E" "/lib/cpp"
5437 <    do
4773 <      ac_preproc_ok=false
4774 < for ac_cxx_preproc_warn_flag in '' yes
4775 < do
4776 <  # Use a header file that comes with gcc, so configuring glibc
4777 <  # with a fresh cross-compiler works.
4778 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4779 <  # <limits.h> exists even on freestanding compilers.
4780 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4781 <  # not just through cpp. "Syntax error" is here to catch this case.
4782 <  cat >conftest.$ac_ext <<_ACEOF
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 < #ifdef __STDC__
5444 < # include <limits.h>
5445 < #else
5446 < # include <assert.h>
5443 >
5444 > /* Override any gcc2 internal prototype to avoid an error.  */
5445 > #ifdef __cplusplus
5446 > extern "C"
5447   #endif
5448 <                     Syntax error
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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5468 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
5476 <  if test -s conftest.err; then
5477 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5478 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5479 <  else
4807 <    ac_cpp_err=
4808 <  fi
4809 < else
4810 <  ac_cpp_err=yes
4811 < fi
4812 < if test -z "$ac_cpp_err"; then
4813 <  :
4814 < else
4815 <  echo "$as_me: failed program was:" >&5
4816 < sed 's/^/| /' conftest.$ac_ext >&5
4817 <
4818 <  # Broken: fails on valid input.
4819 < continue
4820 < fi
4821 < rm -f conftest.err conftest.$ac_ext
4822 <
4823 <  # OK, works on sane cases.  Now check whether non-existent headers
4824 <  # can be detected and how.
4825 <  cat >conftest.$ac_ext <<_ACEOF
4826 < /* confdefs.h.  */
4827 < _ACEOF
4828 < cat confdefs.h >>conftest.$ac_ext
4829 < cat >>conftest.$ac_ext <<_ACEOF
4830 < /* end confdefs.h.  */
4831 < #include <ac_nonexistent.h>
4832 < _ACEOF
4833 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4834 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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=$?
4836 –  grep -v '^ *+' conftest.er1 >conftest.err
4837 –  rm -f conftest.er1
4838 –  cat conftest.err >&5
5481    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5482 <  (exit $ac_status); } >/dev/null; then
5483 <  if test -s conftest.err; then
5484 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5485 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5486 <  else
5487 <    ac_cpp_err=
5488 <  fi
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
4848 –  ac_cpp_err=yes
4849 – fi
4850 – if test -z "$ac_cpp_err"; then
4851 –  # Broken: success on invalid input.
4852 – continue
4853 – else
5491    echo "$as_me: failed program was:" >&5
5492   sed 's/^/| /' conftest.$ac_ext >&5
5493  
5494 <  # Passes both tests.
4858 < ac_preproc_ok=:
4859 < break
5494 > ac_cv_lib_m_asin=no
5495   fi
5496 < rm -f conftest.err conftest.$ac_ext
5497 <
5498 < done
4864 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4865 < rm -f conftest.err conftest.$ac_ext
4866 < if $ac_preproc_ok; then
4867 <  break
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 <    done
4871 <    ac_cv_prog_CXXCPP=$CXXCPP
5507 >  LIBS="-lm $LIBS"
5508  
4873 – fi
4874 –  CXXCPP=$ac_cv_prog_CXXCPP
5509   else
5510 <  ac_cv_prog_CXXCPP=$CXXCPP
4877 < fi
4878 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
4879 < echo "${ECHO_T}$CXXCPP" >&6
4880 < ac_preproc_ok=false
4881 < for ac_cxx_preproc_warn_flag in '' yes
4882 < do
4883 <  # Use a header file that comes with gcc, so configuring glibc
4884 <  # with a fresh cross-compiler works.
4885 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4886 <  # <limits.h> exists even on freestanding compilers.
4887 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4888 <  # not just through cpp. "Syntax error" is here to catch this case.
4889 <  cat >conftest.$ac_ext <<_ACEOF
4890 < /* confdefs.h.  */
4891 < _ACEOF
4892 < cat confdefs.h >>conftest.$ac_ext
4893 < cat >>conftest.$ac_ext <<_ACEOF
4894 < /* end confdefs.h.  */
4895 < #ifdef __STDC__
4896 < # include <limits.h>
4897 < #else
4898 < # include <assert.h>
4899 < #endif
4900 <                     Syntax error
4901 < _ACEOF
4902 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4903 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4904 <  ac_status=$?
4905 <  grep -v '^ *+' conftest.er1 >conftest.err
4906 <  rm -f conftest.er1
4907 <  cat conftest.err >&5
4908 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4909 <  (exit $ac_status); } >/dev/null; then
4910 <  if test -s conftest.err; then
4911 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
4912 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
4913 <  else
4914 <    ac_cpp_err=
4915 <  fi
4916 < else
4917 <  ac_cpp_err=yes
5510 >  exit
5511   fi
4919 – if test -z "$ac_cpp_err"; then
4920 –  :
4921 – else
4922 –  echo "$as_me: failed program was:" >&5
4923 – sed 's/^/| /' conftest.$ac_ext >&5
5512  
4925 –  # Broken: fails on valid input.
4926 – continue
4927 – fi
4928 – rm -f conftest.err conftest.$ac_ext
5513  
4930 –  # OK, works on sane cases.  Now check whether non-existent headers
4931 –  # can be detected and how.
4932 –  cat >conftest.$ac_ext <<_ACEOF
4933 – /* confdefs.h.  */
4934 – _ACEOF
4935 – cat confdefs.h >>conftest.$ac_ext
4936 – cat >>conftest.$ac_ext <<_ACEOF
4937 – /* end confdefs.h.  */
4938 – #include <ac_nonexistent.h>
4939 – _ACEOF
4940 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4941 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4942 –  ac_status=$?
4943 –  grep -v '^ *+' conftest.er1 >conftest.err
4944 –  rm -f conftest.er1
4945 –  cat conftest.err >&5
4946 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4947 –  (exit $ac_status); } >/dev/null; then
4948 –  if test -s conftest.err; then
4949 –    ac_cpp_err=$ac_cxx_preproc_warn_flag
4950 –    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
4951 –  else
4952 –    ac_cpp_err=
4953 –  fi
4954 – else
4955 –  ac_cpp_err=yes
4956 – fi
4957 – if test -z "$ac_cpp_err"; then
4958 –  # Broken: success on invalid input.
4959 – continue
4960 – else
4961 –  echo "$as_me: failed program was:" >&5
4962 – sed 's/^/| /' conftest.$ac_ext >&5
4963 –
4964 –  # Passes both tests.
4965 – ac_preproc_ok=:
4966 – break
4967 – fi
4968 – rm -f conftest.err conftest.$ac_ext
4969 –
4970 – done
4971 – # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4972 – rm -f conftest.err conftest.$ac_ext
4973 – if $ac_preproc_ok; then
4974 –  :
4975 – else
4976 –  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
4977 – See \`config.log' for more details." >&5
4978 – echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
4979 – See \`config.log' for more details." >&2;}
4980 –   { (exit 1); exit 1; }; }
4981 – fi
4982 –
4983 – ac_ext=cc
4984 – ac_cpp='$CXXCPP $CPPFLAGS'
4985 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4986 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4987 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4988 –
4989 –
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
# Line 5003 | Line 5527 | cat >>conftest.$ac_ext <<_ACEOF
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   {
# Line 5020 | Line 5552 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5552    cat conftest.err >&5
5553    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554    (exit $ac_status); } &&
5555 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5149 | Line 5681 | cat >>confdefs.h <<\_ACEOF
5681  
5682   cat >>confdefs.h <<\_ACEOF
5683   #define STDC_HEADERS 1
5152 – _ACEOF
5153 –
5154 – fi
5155 –
5156 – echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
5157 – echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
5158 – if test "${ac_cv_cxx_namespaces+set}" = set; then
5159 –  echo $ECHO_N "(cached) $ECHO_C" >&6
5160 – else
5161 –
5162 –
5163 – ac_ext=cc
5164 – ac_cpp='$CXXCPP $CPPFLAGS'
5165 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5166 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5167 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5168 –
5169 – cat >conftest.$ac_ext <<_ACEOF
5170 – /* confdefs.h.  */
5171 – _ACEOF
5172 – cat confdefs.h >>conftest.$ac_ext
5173 – cat >>conftest.$ac_ext <<_ACEOF
5174 – /* end confdefs.h.  */
5175 – namespace Outer { namespace Inner { int i = 0; }}
5176 – int
5177 – main ()
5178 – {
5179 – using namespace Outer::Inner; return i;
5180 –  ;
5181 –  return 0;
5182 – }
5183 – _ACEOF
5184 – rm -f conftest.$ac_objext
5185 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5186 –  (eval $ac_compile) 2>conftest.er1
5187 –  ac_status=$?
5188 –  grep -v '^ *+' conftest.er1 >conftest.err
5189 –  rm -f conftest.er1
5190 –  cat conftest.err >&5
5191 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5192 –  (exit $ac_status); } &&
5193 –         { ac_try='test -z "$ac_cxx_werror_flag"
5194 –                         || test ! -s conftest.err'
5195 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5196 –  (eval $ac_try) 2>&5
5197 –  ac_status=$?
5198 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5199 –  (exit $ac_status); }; } &&
5200 –         { ac_try='test -s conftest.$ac_objext'
5201 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5202 –  (eval $ac_try) 2>&5
5203 –  ac_status=$?
5204 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5205 –  (exit $ac_status); }; }; then
5206 –  ac_cv_cxx_namespaces=yes
5207 – else
5208 –  echo "$as_me: failed program was:" >&5
5209 – sed 's/^/| /' conftest.$ac_ext >&5
5210 –
5211 – ac_cv_cxx_namespaces=no
5212 – fi
5213 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5214 – ac_ext=cc
5215 – ac_cpp='$CXXCPP $CPPFLAGS'
5216 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5217 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5218 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5219 –
5220 –
5221 – fi
5222 – echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
5223 – echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
5224 – if test "$ac_cv_cxx_namespaces" = yes; then
5225 –
5226 – cat >>confdefs.h <<\_ACEOF
5227 – #define HAVE_NAMESPACES
5684   _ACEOF
5685  
5686   fi
# Line 5267 | Line 5723 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5723    cat conftest.err >&5
5724    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725    (exit $ac_status); } &&
5726 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5301 | Line 5757 | done
5757   done
5758  
5759  
5760 < echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
5761 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
5762 < if test "${ac_cv_cxx_have_stl+set}" = set; then
5763 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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  
5312 – ac_ext=cc
5313 – ac_cpp='$CXXCPP $CPPFLAGS'
5314 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5315 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5316 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5801  
5802 < cat >conftest.$ac_ext <<_ACEOF
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 < #include <list>
5822 < #include <deque>
5823 < #ifdef HAVE_NAMESPACES
5824 < using namespace std;
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 < list<int> x; x.push_back(5);
5333 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
5840 > inflateEnd ();
5841    ;
5842    return 0;
5843   }
5844   _ACEOF
5845 < rm -f conftest.$ac_objext
5846 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5847 <  (eval $ac_compile) 2>conftest.er1
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_cxx_werror_flag"
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_objext'
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_cxx_have_stl=yes
5867 >  ac_cv_lib_z_inflateEnd=yes
5868   else
5869    echo "$as_me: failed program was:" >&5
5870   sed 's/^/| /' conftest.$ac_ext >&5
5364 –
5365 – ac_cv_cxx_have_stl=no
5366 – fi
5367 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5368 – ac_ext=cc
5369 – ac_cpp='$CXXCPP $CPPFLAGS'
5370 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5371 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5372 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5871  
5872 <
5872 > ac_cv_lib_z_inflateEnd=no
5873   fi
5874 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
5875 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
5876 < if test "$ac_cv_cxx_have_stl" = yes; then
5379 <
5380 < cat >>confdefs.h <<\_ACEOF
5381 < #define HAVE_STL
5382 < _ACEOF
5383 <
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 <
5887 <
5888 <  if test "${ac_cv_header_iostream+set}" = set; then
5889 <  echo "$as_me:$LINENO: checking for iostream" >&5
5390 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
5391 < if test "${ac_cv_header_iostream+set}" = set; then
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_iostream" >&5
5893 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
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 iostream usability" >&5
5897 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
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
# Line 5404 | Line 5902 | $ac_includes_default
5902   cat >>conftest.$ac_ext <<_ACEOF
5903   /* end confdefs.h.  */
5904   $ac_includes_default
5905 < #include <iostream>
5905 > #include <zlib.h>
5906   _ACEOF
5907   rm -f conftest.$ac_objext
5908   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5415 | Line 5913 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5913    cat conftest.err >&5
5914    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915    (exit $ac_status); } &&
5916 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5440 | Line 5938 | echo "${ECHO_T}$ac_header_compiler" >&6
5938   echo "${ECHO_T}$ac_header_compiler" >&6
5939  
5940   # Is the header present?
5941 < echo "$as_me:$LINENO: checking iostream presence" >&5
5942 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
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 <iostream>
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
# Line 5459 | Line 5957 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
5961 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 5480 | Line 5978 | echo "${ECHO_T}$ac_header_preproc" >&6
5978   echo "${ECHO_T}$ac_header_preproc" >&6
5979  
5980   # So?  What about this header?
5981 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
5981 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982    yes:no: )
5983 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
5984 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
5986 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
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: iostream: present but cannot be compiled" >&5
5991 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
5992 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
5993 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
5994 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
5995 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
5996 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
5997 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
5998 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
5999 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
6000 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
6001 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 5511 | Line 6009 | esac
6009        sed "s/^/$as_me: WARNING:     /" >&2
6010      ;;
6011   esac
6012 < echo "$as_me:$LINENO: checking for iostream" >&5
6013 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
6014 < if test "${ac_cv_header_iostream+set}" = set; then
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_iostream=$ac_header_preproc
6017 >  ac_cv_header_zlib_h=$ac_header_preproc
6018   fi
6019 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6020 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
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_iostream = yes; then
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 < cat >>confdefs.h <<\_ACEOF
6031 < #define HAVE_IOSTREAM 1
6032 < _ACEOF
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 < else
6043 <
6044 <
5536 < for ac_header in iostream.h
5537 < do
5538 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5539 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5540 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5541 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5542 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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
5544 – fi
5545 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5546 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6046   else
6047 <  # Is the header compilable?
6048 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5550 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
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 < $ac_includes_default
6056 < #include <$ac_header>
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
6080 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6081 <  (eval $ac_compile) 2>conftest.er1
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_cxx_werror_flag"
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_objext'
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_header_compiler=yes
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_header_compiler=no
6106 > ac_cv_lib_z_inflateEnd=no
6107   fi
6108 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6109 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6110 < echo "${ECHO_T}$ac_header_compiler" >&6
6111 <
6112 < # Is the header present?
6113 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6114 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6115 < cat >conftest.$ac_ext <<_ACEOF
6116 < /* confdefs.h.  */
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 < cat confdefs.h >>conftest.$ac_ext
6119 < cat >>conftest.$ac_ext <<_ACEOF
6120 < /* end confdefs.h.  */
5602 < #include <$ac_header>
5603 < _ACEOF
5604 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5605 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5606 <  ac_status=$?
5607 <  grep -v '^ *+' conftest.er1 >conftest.err
5608 <  rm -f conftest.er1
5609 <  cat conftest.err >&5
5610 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5611 <  (exit $ac_status); } >/dev/null; then
5612 <  if test -s conftest.err; then
5613 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5614 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5615 <  else
5616 <    ac_cpp_err=
5617 <  fi
5618 < else
5619 <  ac_cpp_err=yes
6118 >
6119 >  LIBS="-lz $LIBS"
6120 >
6121   fi
5621 – if test -z "$ac_cpp_err"; then
5622 –  ac_header_preproc=yes
5623 – else
5624 –  echo "$as_me: failed program was:" >&5
5625 – sed 's/^/| /' conftest.$ac_ext >&5
6122  
6123 <  ac_header_preproc=no
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
5629 – rm -f conftest.err conftest.$ac_ext
5630 – echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5631 – echo "${ECHO_T}$ac_header_preproc" >&6
6142  
6143 < # So?  What about this header?
6144 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6145 <  yes:no: )
6146 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6147 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6148 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5639 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5640 <    ac_header_preproc=yes
5641 <    ;;
5642 <  no:yes:* )
5643 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5644 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5645 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5646 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5647 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5648 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5649 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5650 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5651 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5652 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5653 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5654 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5655 <    (
5656 <      cat <<\_ASBOX
5657 < ## ------------------------------ ##
5658 < ## Report this to gezelter@nd.edu ##
5659 < ## ------------------------------ ##
5660 < _ASBOX
5661 <    ) |
5662 <      sed "s/^/$as_me: WARNING:     /" >&2
5663 <    ;;
5664 < esac
5665 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5666 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5667 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5668 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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 <  eval "$as_ac_Header=\$ac_header_preproc"
6151 < fi
6152 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5673 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6150 >  with_fftw=yes
6151 > fi;
6152 > if test "$with_fftw" = "no"; then
6153  
6154 < fi
6155 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5677 <  cat >>confdefs.h <<_ACEOF
5678 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
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  
5683 – done
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 <
6177 <
6178 <  if test "${ac_cv_header_iomanip+set}" = set; then
6179 <  echo "$as_me:$LINENO: checking for iomanip" >&5
6180 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
5694 < if test "${ac_cv_header_iomanip+set}" = set; then
5695 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5696 < fi
5697 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
5698 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
5699 < else
5700 <  # Is the header compilable?
5701 < echo "$as_me:$LINENO: checking iomanip usability" >&5
5702 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
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 < $ac_includes_default
6188 < #include <iomanip>
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
# Line 5718 | Line 6210 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6210    cat conftest.err >&5
6211    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212    (exit $ac_status); } &&
6213 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5731 | Line 6223 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6223    ac_status=$?
6224    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225    (exit $ac_status); }; }; then
6226 <  ac_header_compiler=yes
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 < ac_header_compiler=no
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
5742 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5743 – echo "${ECHO_T}$ac_header_compiler" >&6
6239  
6240 < # Is the header present?
6241 < echo "$as_me:$LINENO: checking iomanip presence" >&5
6242 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
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 <iomanip>
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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6269 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
6277 <  if test -s conftest.err; then
6278 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6279 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6280 <  else
6281 <    ac_cpp_err=
6282 <  fi
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
5771 –  ac_cpp_err=yes
5772 – fi
5773 – if test -z "$ac_cpp_err"; then
5774 –  ac_header_preproc=yes
5775 – else
6295    echo "$as_me: failed program was:" >&5
6296   sed 's/^/| /' conftest.$ac_ext >&5
6297  
6298 <  ac_header_preproc=no
6298 > ok=no
6299   fi
6300 < rm -f conftest.err conftest.$ac_ext
5782 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5783 < echo "${ECHO_T}$ac_header_preproc" >&6
5784 <
5785 < # So?  What about this header?
5786 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
5787 <  yes:no: )
5788 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
5789 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
5790 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
5791 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
5792 <    ac_header_preproc=yes
5793 <    ;;
5794 <  no:yes:* )
5795 <    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
5796 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
5797 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
5798 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
5799 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
5800 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
5801 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
5802 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
5803 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
5804 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
5805 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
5806 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
5807 <    (
5808 <      cat <<\_ASBOX
5809 < ## ------------------------------ ##
5810 < ## Report this to gezelter@nd.edu ##
5811 < ## ------------------------------ ##
5812 < _ASBOX
5813 <    ) |
5814 <      sed "s/^/$as_me: WARNING:     /" >&2
5815 <    ;;
5816 < esac
5817 < echo "$as_me:$LINENO: checking for iomanip" >&5
5818 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
5819 < if test "${ac_cv_header_iomanip+set}" = set; then
5820 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5821 < else
5822 <  ac_cv_header_iomanip=$ac_header_preproc
6300 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301   fi
5824 – echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
5825 – echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6302  
6303 < fi
6304 < if test $ac_cv_header_iomanip = yes; then
6305 <
6306 <
5831 < cat >>confdefs.h <<\_ACEOF
5832 < #define HAVE_IOMANIP 1
5833 < _ACEOF
5834 <
5835 <
5836 < else
5837 <
5838 <
5839 < for ac_header in iomanip.h
5840 < do
5841 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5842 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5843 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5844 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5845 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5846 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5847 < fi
5848 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5849 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5850 < else
5851 <  # Is the header compilable?
5852 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5853 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5854 < cat >conftest.$ac_ext <<_ACEOF
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 < $ac_includes_default
6313 < #include <$ac_header>
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
# Line 5869 | Line 6335 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6335    cat conftest.err >&5
6336    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337    (exit $ac_status); } &&
6338 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5882 | Line 6348 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6348    ac_status=$?
6349    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350    (exit $ac_status); }; }; then
6351 <  ac_header_compiler=yes
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 < ac_header_compiler=no
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
5893 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5894 – echo "${ECHO_T}$ac_header_compiler" >&6
5895 –
5896 – # Is the header present?
5897 – echo "$as_me:$LINENO: checking $ac_header presence" >&5
5898 – echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 <$ac_header>
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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6412 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
6420 <  if test -s conftest.err; then
6421 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6422 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6423 <  else
6424 <    ac_cpp_err=
6425 <  fi
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
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_header_preproc=no
9584 > ac_cv_func_pow=no
9585   fi
9586 < rm -f conftest.err conftest.$ac_ext
9587 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9588 < echo "${ECHO_T}$ac_header_preproc" >&6
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 < # So?  What about this header?
9593 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9594 <  yes:no: )
9595 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5940 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5941 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5942 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5943 <    ac_header_preproc=yes
5944 <    ;;
5945 <  no:yes:* )
5946 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5947 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5948 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5949 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5950 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5951 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5952 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5953 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5954 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5955 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5956 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5957 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5958 <    (
5959 <      cat <<\_ASBOX
5960 < ## ------------------------------ ##
5961 < ## Report this to gezelter@nd.edu ##
5962 < ## ------------------------------ ##
5963 < _ASBOX
5964 <    ) |
5965 <      sed "s/^/$as_me: WARNING:     /" >&2
5966 <    ;;
5967 < esac
5968 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5969 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5970 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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 <  eval "$as_ac_Header=\$ac_header_preproc"
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 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9660 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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
5979 – if test `eval echo '${'$as_ac_Header'}'` = yes; then
5980 –  cat >>confdefs.h <<_ACEOF
5981 – #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5982 – _ACEOF
9673  
9674   fi
9675  
9676 < done
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 < for ac_header in cmath
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
# Line 6024 | Line 9912 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9912    cat conftest.err >&5
9913    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914    (exit $ac_status); } &&
9915 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6068 | Line 9956 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
9960 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 6089 | Line 9977 | echo "${ECHO_T}$ac_header_preproc" >&6
9977   echo "${ECHO_T}$ac_header_preproc" >&6
9978  
9979   # So?  What about this header?
9980 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
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;}
# Line 6141 | Line 10029 | done
10029   done
10030  
10031  
10032 <
10033 <
10034 <  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
10035 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
10036 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
10032 > for ac_func in getopt_long
10033 > do
10034 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10036 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10038    echo $ECHO_N "(cached) $ECHO_C" >&6
10039   else
10040 <
6152 <      ac_cv_cxx_have_std_iostream=no
6153 <      ac_cv_cxx_need_use_std_iostream=no
6154 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6155 <
6156 <
6157 <        ac_ext=cc
6158 < ac_cpp='$CXXCPP $CPPFLAGS'
6159 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6160 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6161 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6162 <
6163 <        cat >conftest.$ac_ext <<_ACEOF
10040 >  cat >conftest.$ac_ext <<_ACEOF
10041   /* confdefs.h.  */
10042   _ACEOF
10043   cat confdefs.h >>conftest.$ac_ext
10044   cat >>conftest.$ac_ext <<_ACEOF
10045   /* end confdefs.h.  */
10046 + /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048 + #define $ac_func innocuous_$ac_func
10049  
10050 < #ifdef HAVE_IOSTREAM
10051 < #include <iostream>
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 <iostream.h>
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 < std::cout<<"Hello World"<<std::endl;return 0;
10094 > return f != $ac_func;
10095    ;
10096    return 0;
10097   }
10098   _ACEOF
10099 < rm -f conftest.$ac_objext
10100 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10101 <  (eval $ac_compile) 2>conftest.er1
10099 > rm -f conftest.$ac_objext conftest$ac_exeext
10100 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10101 >  (eval $ac_link) 2>conftest.er1
10102    ac_status=$?
10103    grep -v '^ *+' conftest.er1 >conftest.err
10104    rm -f conftest.er1
10105    cat conftest.err >&5
10106    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10107    (exit $ac_status); } &&
10108 <         { ac_try='test -z "$ac_cxx_werror_flag"
10108 >         { ac_try='test -z "$ac_c_werror_flag"
10109                           || test ! -s conftest.err'
10110    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10111    (eval $ac_try) 2>&5
10112    ac_status=$?
10113    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10114    (exit $ac_status); }; } &&
10115 <         { ac_try='test -s conftest.$ac_objext'
10115 >         { ac_try='test -s conftest$ac_exeext'
10116    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10117    (eval $ac_try) 2>&5
10118    ac_status=$?
10119    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120    (exit $ac_status); }; }; then
10121 <  ac_cv_cxx_have_std_iostream=yes
10121 >  eval "$as_ac_var=yes"
10122   else
10123    echo "$as_me: failed program was:" >&5
10124   sed 's/^/| /' conftest.$ac_ext >&5
10125  
10126 + eval "$as_ac_var=no"
10127   fi
10128 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10129 <        cat >conftest.$ac_ext <<_ACEOF
10128 > rm -f conftest.err conftest.$ac_objext \
10129 >      conftest$ac_exeext conftest.$ac_ext
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 > 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
10151   cat >>conftest.$ac_ext <<_ACEOF
10152   /* end confdefs.h.  */
10153  
10154 < #define __USE_STD_IOSTREAM 1
10155 < #ifdef HAVE_IOSTREAM
10156 < #include <iostream>
6223 < #else
6224 < #include <iostream.h>
10154 > /* Override any gcc2 internal prototype to avoid an error.  */
10155 > #ifdef __cplusplus
10156 > extern "C"
10157   #endif
10158 <
10158 > /* We use char because int might match the return type of a gcc2
10159 >   builtin and then its argument prototype would still apply.  */
10160 > char getopt_long ();
10161 > #ifdef FC_DUMMY_MAIN
10162 > #ifndef FC_DUMMY_MAIN_EQ_F77
10163 > #  ifdef __cplusplus
10164 >     extern "C"
10165 > #  endif
10166 >   int FC_DUMMY_MAIN() { return 1; }
10167 > #endif
10168 > #endif
10169   int
10170   main ()
10171   {
10172 < std::cout<<"Hello World"<<std::endl;return 0;
10172 > getopt_long ();
10173    ;
10174    return 0;
10175   }
10176   _ACEOF
10177 < rm -f conftest.$ac_objext
10178 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10179 <  (eval $ac_compile) 2>conftest.er1
10177 > rm -f conftest.$ac_objext conftest$ac_exeext
10178 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10179 >  (eval $ac_link) 2>conftest.er1
10180    ac_status=$?
10181    grep -v '^ *+' conftest.er1 >conftest.err
10182    rm -f conftest.er1
10183    cat conftest.err >&5
10184    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10185    (exit $ac_status); } &&
10186 <         { ac_try='test -z "$ac_cxx_werror_flag"
10186 >         { ac_try='test -z "$ac_c_werror_flag"
10187                           || test ! -s conftest.err'
10188    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10189    (eval $ac_try) 2>&5
10190    ac_status=$?
10191    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192    (exit $ac_status); }; } &&
10193 <         { ac_try='test -s conftest.$ac_objext'
10193 >         { ac_try='test -s conftest$ac_exeext'
10194    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10195    (eval $ac_try) 2>&5
10196    ac_status=$?
10197    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198    (exit $ac_status); }; }; then
10199 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
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 conftest.$ac_ext
10207 <        ac_ext=cc
10208 < ac_cpp='$CXXCPP $CPPFLAGS'
6266 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6267 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6268 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6269 <
6270 <      fi
6271 <
10206 > rm -f conftest.err conftest.$ac_objext \
10207 >      conftest$ac_exeext conftest.$ac_ext
10208 > LIBS=$ac_check_lib_save_LIBS
10209   fi
10210 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
10211 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
10212 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
10213 <
10214 < cat >>confdefs.h <<\_ACEOF
6278 < #define HAVE_STD_IOSTREAM 1
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 <  fi
10218 <  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
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 __USE_STD_IOSTREAM 1
10229 < _ACEOF
10227 >      case $LIBOBJS in
10228 >    "getopt1.$ac_objext"   | \
10229 >  *" getopt1.$ac_objext"   | \
10230 >    "getopt1.$ac_objext "* | \
10231 >  *" getopt1.$ac_objext "* ) ;;
10232 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10233 > esac
10234  
10235 <  fi
10235 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10236  
10237 + fi
10238  
10239 + fi
10240 + done
10241  
10242  
10243 <  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
10244 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
10245 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
10243 > ac_ext=cc
10244 > ac_cpp='$CXXCPP $CPPFLAGS'
10245 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10246 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10247 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10248 >
10249 >
10250 > 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
10255  
6299 –      ac_cv_cxx_have_std_stl=no
6300 –      if test "x$ac_cv_cxx_namespaces" = xyes; then
10256  
10257 <
6303 <        ac_ext=cc
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
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 < #include <list>
10270 <
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 < std::list<int> foo;return 0;
10281 > using namespace Outer::Inner; return i;
10282    ;
10283    return 0;
10284   }
# Line 6344 | 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_cxx_have_std_stl=yes
10308 >  ac_cv_cxx_namespaces=yes
10309   else
10310    echo "$as_me: failed program was:" >&5
10311   sed 's/^/| /' conftest.$ac_ext >&5
10312  
10313 + ac_cv_cxx_namespaces=no
10314   fi
10315   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316 <        ac_ext=cc
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  
6360 –      fi
10322  
10323   fi
10324 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
10325 < echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
10326 <  if test "$ac_cv_cxx_have_std_stl" = yes; then
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   cat >>confdefs.h <<\_ACEOF
10329 < #define HAVE_STD_STL 1
10329 > #define HAVE_NAMESPACES
10330   _ACEOF
10331  
10332 <  fi
10332 > fi
10333  
10334 <
6374 <
6375 <  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
6376 < echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
6377 < if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
6378 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6379 < else
6380 <
6381 <    ac_cv_cxx_have_fstream_attach=no
6382 <
6383 <
6384 <    ac_ext=cc
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 <
10340 <    cat >conftest.$ac_ext <<_ACEOF
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 CXXCPP needs to be expanded
10346 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10347 >    do
10348 >      ac_preproc_ok=false
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.
10353 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10354 >  # <limits.h> exists even on freestanding compilers.
10355 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10356 >  # not just through cpp. "Syntax error" is here to catch this case.
10357 >  cat >conftest.$ac_ext <<_ACEOF
10358   /* confdefs.h.  */
10359   _ACEOF
10360   cat confdefs.h >>conftest.$ac_ext
10361   cat >>conftest.$ac_ext <<_ACEOF
10362   /* end confdefs.h.  */
10363 <
10364 < #ifdef HAVE_IOSTREAM
6398 < #include <fstream>
10363 > #ifdef __STDC__
10364 > # include <limits.h>
10365   #else
10366 < #include <fstream.h>
10366 > # include <assert.h>
10367   #endif
10368 < #ifdef HAVE_STD_IOSTREAM
10369 < using namespace std;
10370 < #endif
10368 >                     Syntax error
10369 > _ACEOF
10370 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10371 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10372 >  ac_status=$?
10373 >  grep -v '^ *+' conftest.er1 >conftest.err
10374 >  rm -f conftest.er1
10375 >  cat conftest.err >&5
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_cxx_preproc_warn_flag
10380 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10381 >  else
10382 >    ac_cpp_err=
10383 >  fi
10384 > else
10385 >  ac_cpp_err=yes
10386 > fi
10387 > if test -z "$ac_cpp_err"; then
10388 >  :
10389 > else
10390 >  echo "$as_me: failed program was:" >&5
10391 > sed 's/^/| /' conftest.$ac_ext >&5
10392  
10393 < int
10394 < main ()
10395 < {
10396 < int fd=0;ofstream s;s.attach(fd);
10397 <  ;
10398 <  return 0;
10399 < }
10393 >  # Broken: fails on valid input.
10394 > continue
10395 > fi
10396 > rm -f conftest.err conftest.$ac_ext
10397 >
10398 >  # OK, works on sane cases.  Now check whether non-existent headers
10399 >  # can be detected and how.
10400 >  cat >conftest.$ac_ext <<_ACEOF
10401 > /* confdefs.h.  */
10402   _ACEOF
10403 < rm -f conftest.$ac_objext
10404 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10405 <  (eval $ac_compile) 2>conftest.er1
10403 > cat confdefs.h >>conftest.$ac_ext
10404 > cat >>conftest.$ac_ext <<_ACEOF
10405 > /* end confdefs.h.  */
10406 > #include <ac_nonexistent.h>
10407 > _ACEOF
10408 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10409 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10410    ac_status=$?
10411    grep -v '^ *+' conftest.er1 >conftest.err
10412    rm -f conftest.er1
10413    cat conftest.err >&5
10414    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10415 <  (exit $ac_status); } &&
10416 <         { ac_try='test -z "$ac_cxx_werror_flag"
10417 <                         || test ! -s conftest.err'
10418 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10419 <  (eval $ac_try) 2>&5
10415 >  (exit $ac_status); } >/dev/null; then
10416 >  if test -s conftest.err; then
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
10422 > else
10423 >  ac_cpp_err=yes
10424 > fi
10425 > if test -z "$ac_cpp_err"; then
10426 >  # Broken: success on invalid input.
10427 > continue
10428 > else
10429 >  echo "$as_me: failed program was:" >&5
10430 > sed 's/^/| /' conftest.$ac_ext >&5
10431 >
10432 >  # Passes both tests.
10433 > ac_preproc_ok=:
10434 > break
10435 > fi
10436 > rm -f conftest.err conftest.$ac_ext
10437 >
10438 > done
10439 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10440 > rm -f conftest.err conftest.$ac_ext
10441 > if $ac_preproc_ok; then
10442 >  break
10443 > fi
10444 >
10445 >    done
10446 >    ac_cv_prog_CXXCPP=$CXXCPP
10447 >
10448 > fi
10449 >  CXXCPP=$ac_cv_prog_CXXCPP
10450 > else
10451 >  ac_cv_prog_CXXCPP=$CXXCPP
10452 > fi
10453 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10454 > echo "${ECHO_T}$CXXCPP" >&6
10455 > ac_preproc_ok=false
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.
10460 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10461 >  # <limits.h> exists even on freestanding compilers.
10462 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10463 >  # not just through cpp. "Syntax error" is here to catch this case.
10464 >  cat >conftest.$ac_ext <<_ACEOF
10465 > /* confdefs.h.  */
10466 > _ACEOF
10467 > cat confdefs.h >>conftest.$ac_ext
10468 > cat >>conftest.$ac_ext <<_ACEOF
10469 > /* end confdefs.h.  */
10470 > #ifdef __STDC__
10471 > # include <limits.h>
10472 > #else
10473 > # include <assert.h>
10474 > #endif
10475 >                     Syntax error
10476 > _ACEOF
10477 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10478 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10479    ac_status=$?
10480 +  grep -v '^ *+' conftest.er1 >conftest.err
10481 +  rm -f conftest.er1
10482 +  cat conftest.err >&5
10483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10484 <  (exit $ac_status); }; } &&
10485 <         { ac_try='test -s conftest.$ac_objext'
10486 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10487 <  (eval $ac_try) 2>&5
10484 >  (exit $ac_status); } >/dev/null; then
10485 >  if test -s conftest.err; then
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); }; }; then
10523 <  ac_cv_cxx_have_fstream_attach=yes
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_objext conftest.$ac_ext
10544 <    ac_ext=cc
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 < fi
10566 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
10567 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
6453 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
6454 <
6455 < cat >>confdefs.h <<\_ACEOF
6456 < #define HAVE_FSTREAM_ATTACH 1
6457 < _ACEOF
6458 <
6459 <  fi
6460 <
6461 <
6462 <
6463 <  echo "$as_me:$LINENO: checking for fstream::open()" >&5
6464 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
6465 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
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  
6469 –    ac_cv_cxx_have_fstream_open=no
6470 –    ac_cv_cxx_fstream_open_prot=no
10571  
10572  
10573 <    ac_ext=cc
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 <    # Try with 2 parameters
6480 <    cat >conftest.$ac_ext <<_ACEOF
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 <
10586 < #ifdef HAVE_IOSTREAM
10587 < #include <fstream>
6489 < #else
6490 < #include <fstream.h>
6491 < #endif
6492 < #ifdef HAVE_STD_IOSTREAM
10585 > #include <list>
10586 > #include <deque>
10587 > #ifdef HAVE_NAMESPACES
10588   using namespace std;
10589   #endif
10590 <
10591 < int
10592 < main ()
10593 < {
10594 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
10595 <  ;
6501 <  return 0;
6502 < }
6503 < _ACEOF
6504 < rm -f conftest.$ac_objext
6505 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6506 <  (eval $ac_compile) 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_cxx_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_objext'
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 <  ac_cv_cxx_have_fstream_open=yes
6527 < else
6528 <  echo "$as_me: failed program was:" >&5
6529 < sed 's/^/| /' conftest.$ac_ext >&5
6530 <
6531 < fi
6532 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6533 <    # Try with mode parameter
6534 <    cat >conftest.$ac_ext <<_ACEOF
6535 < /* confdefs.h.  */
6536 < _ACEOF
6537 < cat confdefs.h >>conftest.$ac_ext
6538 < cat >>conftest.$ac_ext <<_ACEOF
6539 < /* end confdefs.h.  */
6540 <
6541 < #ifdef HAVE_IOSTREAM
6542 < #include <fstream>
6543 < #else
6544 < #include <fstream.h>
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
6546 – #ifdef HAVE_STD_IOSTREAM
6547 – using namespace std;
10597   #endif
6549 –
10598   int
10599   main ()
10600   {
10601 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
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   }
# Line 6577 | Line 10626 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10626    ac_status=$?
10627    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628    (exit $ac_status); }; }; then
10629 <  ac_cv_cxx_fstream_open_prot=yes
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
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'
# Line 6592 | Line 10642 | fi
10642  
10643  
10644   fi
10645 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
10646 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
10647 <  if test "$ac_cv_cxx_have_fstream_open" = yes; then
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_FSTREAM_OPEN 1
10650 > #define HAVE_STL
10651   _ACEOF
10652  
10653 <  fi
6604 <  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
10653 > fi
10654  
6606 – cat >>confdefs.h <<\_ACEOF
6607 – #define FSTREAM_OPEN_PROT 1
6608 – _ACEOF
10655  
6610 –  fi
10656  
10657 <
10658 <
10659 <
10660 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
6616 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
6617 < if test "${ac_cv_lib_m_asin+set}" = set; then
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 <  ac_check_lib_save_LIBS=$LIBS
10667 < LIBS="-lm  $LIBS"
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 <
10676 < /* Override any gcc2 internal prototype to avoid an error.  */
6630 < #ifdef __cplusplus
6631 < extern "C"
6632 < #endif
6633 < /* We use char because int might match the return type of a gcc2
6634 <   builtin and then its argument prototype would still apply.  */
6635 < char asin ();
6636 < int
6637 < main ()
6638 < {
6639 < asin ();
6640 <  ;
6641 <  return 0;
6642 < }
10675 > $ac_includes_default
10676 > #include <iostream>
10677   _ACEOF
10678 < rm -f conftest.$ac_objext conftest$ac_exeext
10679 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10680 <  (eval $ac_link) 2>conftest.er1
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
# Line 6657 | Line 10691 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10691    ac_status=$?
10692    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10693    (exit $ac_status); }; } &&
10694 <         { ac_try='test -s conftest$ac_exeext'
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_cv_lib_m_asin=yes
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_cv_lib_m_asin=no
10705 > ac_header_compiler=no
10706   fi
10707 < rm -f conftest.err conftest.$ac_objext \
10708 <      conftest$ac_exeext conftest.$ac_ext
10709 < LIBS=$ac_check_lib_save_LIBS
6676 < fi
6677 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
6678 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
6679 < if test $ac_cv_lib_m_asin = yes; then
6680 <  cat >>confdefs.h <<_ACEOF
6681 < #define HAVE_LIBM 1
6682 < _ACEOF
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 <  LIBS="-lm $LIBS"
10712 <
10713 < else
6687 <  exit
6688 < fi
6689 <
6690 <
6691 <
6692 < #
6693 < # Handle user hints
6694 < #
6695 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
6696 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
6697 <
6698 < # Check whether --with-zlib or --without-zlib was given.
6699 < if test "${with_zlib+set}" = set; then
6700 <  withval="$with_zlib"
6701 <  if test "$withval" != no ; then
6702 <  echo "$as_me:$LINENO: result: yes" >&5
6703 < echo "${ECHO_T}yes" >&6
6704 <  if test -d "$withval"
6705 <  then
6706 <    ZLIB_HOME="$withval"
6707 <  else
6708 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
6709 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
6710 <  fi
6711 < else
6712 <  echo "$as_me:$LINENO: result: no" >&5
6713 < echo "${ECHO_T}no" >&6
6714 < fi
6715 < fi;
6716 <
6717 < ZLIB_HOME=/usr/local
6718 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
6719 < then
6720 <        ZLIB_HOME=/usr
6721 < fi
6722 <
6723 < #
6724 < # Locate zlib, if wanted
6725 < #
6726 < if test -n "${ZLIB_HOME}"
6727 < then
6728 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
6729 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
6730 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
6731 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
6732 <
6733 <
6734 <        ac_ext=c
6735 < ac_cpp='$CPP $CPPFLAGS'
6736 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6737 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6738 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6739 <
6740 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6741 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6742 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6743 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6744 < else
6745 <  ac_check_lib_save_LIBS=$LIBS
6746 < LIBS="-lz  $LIBS"
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 <
6754 < /* Override any gcc2 internal prototype to avoid an error.  */
6755 < #ifdef __cplusplus
6756 < extern "C"
6757 < #endif
6758 < /* We use char because int might match the return type of a gcc2
6759 <   builtin and then its argument prototype would still apply.  */
6760 < char inflateEnd ();
6761 < int
6762 < main ()
6763 < {
6764 < inflateEnd ();
6765 <  ;
6766 <  return 0;
6767 < }
10720 > #include <iostream>
10721   _ACEOF
10722 < rm -f conftest.$ac_objext conftest$ac_exeext
10723 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6771 <  (eval $ac_link) 2>conftest.er1
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); } &&
10730 <         { ac_try='test -z "$ac_c_werror_flag"
10731 <                         || test ! -s conftest.err'
10732 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10733 <  (eval $ac_try) 2>&5
10734 <  ac_status=$?
10735 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6784 <  (exit $ac_status); }; } &&
6785 <         { ac_try='test -s conftest$ac_exeext'
6786 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6787 <  (eval $ac_try) 2>&5
6788 <  ac_status=$?
6789 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6790 <  (exit $ac_status); }; }; then
6791 <  ac_cv_lib_z_inflateEnd=yes
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
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_cv_lib_z_inflateEnd=no
10745 >  ac_header_preproc=no
10746   fi
10747 < rm -f conftest.err conftest.$ac_objext \
10748 <      conftest$ac_exeext conftest.$ac_ext
10749 < LIBS=$ac_check_lib_save_LIBS
10750 < fi
10751 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
10752 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
10753 < if test $ac_cv_lib_z_inflateEnd = yes; then
10754 <  zlib_cv_libz=yes
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 <  zlib_cv_libz=no
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 <        if test "${ac_cv_header_zlib_h+set}" = set; then
10794 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
10795 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10796 < if test "${ac_cv_header_zlib_h+set}" = set; then
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: $ac_cv_header_zlib_h" >&5
10815 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
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 zlib.h usability" >&5
10819 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
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
# Line 6826 | Line 10824 | $ac_includes_default
10824   cat >>conftest.$ac_ext <<_ACEOF
10825   /* end confdefs.h.  */
10826   $ac_includes_default
10827 < #include <zlib.h>
10827 > #include <$ac_header>
10828   _ACEOF
10829   rm -f conftest.$ac_objext
10830   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6837 | Line 10835 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10835    cat conftest.err >&5
10836    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837    (exit $ac_status); } &&
10838 <         { ac_try='test -z "$ac_c_werror_flag"
10838 >         { ac_try='test -z "$ac_cxx_werror_flag"
10839                           || test ! -s conftest.err'
10840    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10841    (eval $ac_try) 2>&5
# Line 6862 | Line 10860 | echo "${ECHO_T}$ac_header_compiler" >&6
10860   echo "${ECHO_T}$ac_header_compiler" >&6
10861  
10862   # Is the header present?
10863 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
10864 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
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 <zlib.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 6881 | 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 6902 | Line 10900 | echo "${ECHO_T}$ac_header_preproc" >&6
10900   echo "${ECHO_T}$ac_header_preproc" >&6
10901  
10902   # So?  What about this header?
10903 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10903 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904    yes:no: )
10905 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
10906 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
10907 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
10908 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
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: zlib.h: present but cannot be compiled" >&5
10913 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
10914 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
10915 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
10916 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
10917 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
10918 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
10919 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
10920 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
10921 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
10922 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
10923 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 6933 | Line 10931 | esac
10931        sed "s/^/$as_me: WARNING:     /" >&2
10932      ;;
10933   esac
10934 < echo "$as_me:$LINENO: checking for zlib.h" >&5
10935 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10936 < if test "${ac_cv_header_zlib_h+set}" = set; then
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 <  ac_cv_header_zlib_h=$ac_header_preproc
10939 >  eval "$as_ac_Header=\$ac_header_preproc"
10940   fi
10941 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10942 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10941 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10942 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10943  
10944   fi
10945 < if test $ac_cv_header_zlib_h = yes; then
10946 <  zlib_cv_zlib_h=yes
10947 < else
10948 <  zlib_cv_zlib_h=no
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 + done
10953  
6954 –        ac_ext=cc
6955 – ac_cpp='$CXXCPP $CPPFLAGS'
6956 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6957 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6958 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10954  
10955 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6961 <        then
6962 <                #
6963 <                # If both library and header were found, use them
6964 <                #
10955 > fi
10956  
10957 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
10958 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
10959 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
10957 >
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 <  ac_check_lib_save_LIBS=$LIBS
10970 < LIBS="-lz  $LIBS"
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 <
10979 < /* Override any gcc2 internal prototype to avoid an error.  */
6981 < #ifdef __cplusplus
6982 < extern "C"
6983 < #endif
6984 < /* We use char because int might match the return type of a gcc2
6985 <   builtin and then its argument prototype would still apply.  */
6986 < char inflateEnd ();
6987 < int
6988 < main ()
6989 < {
6990 < inflateEnd ();
6991 <  ;
6992 <  return 0;
6993 < }
10978 > $ac_includes_default
10979 > #include <iomanip>
10980   _ACEOF
10981 < rm -f conftest.$ac_objext conftest$ac_exeext
10982 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10983 <  (eval $ac_link) 2>conftest.er1
10981 > rm -f conftest.$ac_objext
10982 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10983 >  (eval $ac_compile) 2>conftest.er1
10984    ac_status=$?
10985    grep -v '^ *+' conftest.er1 >conftest.err
10986    rm -f conftest.er1
# Line 7008 | Line 10994 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10994    ac_status=$?
10995    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10996    (exit $ac_status); }; } &&
10997 <         { ac_try='test -s conftest$ac_exeext'
10997 >         { ac_try='test -s conftest.$ac_objext'
10998    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10999    (eval $ac_try) 2>&5
11000    ac_status=$?
11001    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002    (exit $ac_status); }; }; then
11003 <  ac_cv_lib_z_inflateEnd=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_lib_z_inflateEnd=no
11008 > ac_header_compiler=no
11009   fi
11010 < rm -f conftest.err conftest.$ac_objext \
11011 <      conftest$ac_exeext conftest.$ac_ext
11012 < LIBS=$ac_check_lib_save_LIBS
7027 < fi
7028 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7029 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
7030 < if test $ac_cv_lib_z_inflateEnd = yes; then
7031 <  cat >>confdefs.h <<_ACEOF
7032 < #define HAVE_LIBZ 1
7033 < _ACEOF
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 <  LIBS="-lz $LIBS"
11015 <
11014 > # Is the header present?
11015 > echo "$as_me:$LINENO: checking iomanip presence" >&5
11016 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017 > cat >conftest.$ac_ext <<_ACEOF
11018 > /* confdefs.h.  */
11019 > _ACEOF
11020 > cat confdefs.h >>conftest.$ac_ext
11021 > cat >>conftest.$ac_ext <<_ACEOF
11022 > /* end confdefs.h.  */
11023 > #include <iomanip>
11024 > _ACEOF
11025 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11026 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11027 >  ac_status=$?
11028 >  grep -v '^ *+' conftest.er1 >conftest.err
11029 >  rm -f conftest.er1
11030 >  cat conftest.err >&5
11031 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032 >  (exit $ac_status); } >/dev/null; then
11033 >  if test -s conftest.err; then
11034 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11035 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11036 >  else
11037 >    ac_cpp_err=
11038 >  fi
11039 > else
11040 >  ac_cpp_err=yes
11041   fi
11042 + if test -z "$ac_cpp_err"; then
11043 +  ac_header_preproc=yes
11044 + else
11045 +  echo "$as_me: failed program was:" >&5
11046 + sed 's/^/| /' conftest.$ac_ext >&5
11047  
11048 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7040 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7041 <                echo "$as_me:$LINENO: result: ok" >&5
7042 < echo "${ECHO_T}ok" >&6
7043 <        else
7044 <                #
7045 <                # If either header or library was not found, revert and bomb
7046 <                #
7047 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7048 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7049 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
7050 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
7051 <                echo "$as_me:$LINENO: result: failed" >&5
7052 < echo "${ECHO_T}failed" >&6
7053 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
7054 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
7055 <   { (exit 1); exit 1; }; }
7056 <        fi
11048 >  ac_header_preproc=no
11049   fi
11050 + rm -f conftest.err conftest.$ac_ext
11051 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11052 + echo "${ECHO_T}$ac_header_preproc" >&6
11053  
11054 + # So?  What about this header?
11055 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11056 +  yes:no: )
11057 +    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11058 + echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059 +    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11060 + echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11061 +    ac_header_preproc=yes
11062 +    ;;
11063 +  no:yes:* )
11064 +    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11065 + echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11066 +    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11067 + echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11068 +    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11069 + echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11070 +    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11071 + echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11072 +    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11073 + echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11074 +    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11075 + echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11076 +    (
11077 +      cat <<\_ASBOX
11078 + ## ------------------------------ ##
11079 + ## Report this to gezelter@nd.edu ##
11080 + ## ------------------------------ ##
11081 + _ASBOX
11082 +    ) |
11083 +      sed "s/^/$as_me: WARNING:     /" >&2
11084 +    ;;
11085 + esac
11086 + echo "$as_me:$LINENO: checking for iomanip" >&5
11087 + echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11088 + if test "${ac_cv_header_iomanip+set}" = set; then
11089 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11090 + else
11091 +  ac_cv_header_iomanip=$ac_header_preproc
11092 + fi
11093 + echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094 + echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095  
11096 + fi
11097 + if test $ac_cv_header_iomanip = yes; then
11098  
11099  
11100 + cat >>confdefs.h <<\_ACEOF
11101 + #define HAVE_IOMANIP 1
11102 + _ACEOF
11103  
11104  
11105 + else
11106  
11107  
11108 <
7067 <
7068 <
7069 <
7070 <
7071 <
7072 <
7073 <
7074 <
7075 <
7076 <
7077 <
7078 <
7079 < for ac_header in stdlib.h string.h sys/param.h unistd.h sys/time.h stdio.h conio.h strstream.h iostream.h fstream.h math.h time.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
11108 > for ac_header in iomanip.h
11109   do
11110   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7224 | Line 11253 | done
11253   fi
11254  
11255   done
7227 –
7228 – ac_ext=cc
7229 – ac_cpp='$CXXCPP $CPPFLAGS'
7230 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7231 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7232 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11256  
11257  
11258 + fi
11259  
11260  
11261  
11262  
11263 < for ac_header in ctype.h iostream fstream sstream strstream
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 7385 | Line 11409 | done
11409  
11410   done
11411  
7388 – ac_ext=c
7389 – ac_cpp='$CPP $CPPFLAGS'
7390 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7391 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7392 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
11412  
11413  
11414  
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  
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 <
11427 <
11428 <
11429 <
11430 <
7404 <
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 < for ac_func in rint snprintf sranddev strcasecmp strncasecmp stricmp strnicmp pstat_getstatic sysmp getsysinfo sysctl table
7407 < do
7408 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7409 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7410 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7411 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7412 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7413 < else
7414 <  cat >conftest.$ac_ext <<_ACEOF
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.  */
7420 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7421 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7422 – #define $ac_func innocuous_$ac_func
11438  
11439 < /* System header to define __stub macros and hopefully few prototypes,
11440 <    which can conflict with char $ac_func (); below.
7426 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7427 <    <limits.h> exists even on freestanding compilers.  */
7428 <
7429 < #ifdef __STDC__
7430 < # include <limits.h>
11439 > #ifdef HAVE_IOSTREAM
11440 > #include <iostream>
11441   #else
11442 < # include <assert.h>
11442 > #include <iostream.h>
11443   #endif
11444  
11445 < #undef $ac_func
11446 <
11447 < /* Override any gcc2 internal prototype to avoid an error.  */
11448 < #ifdef __cplusplus
11449 < extern "C"
11450 < {
11445 > #ifdef FC_DUMMY_MAIN
11446 > #ifndef FC_DUMMY_MAIN_EQ_F77
11447 > #  ifdef __cplusplus
11448 >     extern "C"
11449 > #  endif
11450 >   int FC_DUMMY_MAIN() { return 1; }
11451   #endif
7442 – /* We use char because int might match the return type of a gcc2
7443 –   builtin and then its argument prototype would still apply.  */
7444 – char $ac_func ();
7445 – /* The GNU C library defines this for functions which it implements
7446 –    to always fail with ENOSYS.  Some functions are actually named
7447 –    something starting with __ and the normal name is an alias.  */
7448 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7449 – choke me
7450 – #else
7451 – char (*f) () = $ac_func;
11452   #endif
7453 – #ifdef __cplusplus
7454 – }
7455 – #endif
7456 –
11453   int
11454   main ()
11455   {
11456 < return f != $ac_func;
11456 > std::cout<<"Hello World"<<std::endl;return 0;
11457    ;
11458    return 0;
11459   }
11460   _ACEOF
11461 < rm -f conftest.$ac_objext conftest$ac_exeext
11462 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11463 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"
11470 >         { ac_try='test -z "$ac_cxx_werror_flag"
11471                           || test ! -s conftest.err'
11472    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473    (eval $ac_try) 2>&5
11474    ac_status=$?
11475    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11476    (exit $ac_status); }; } &&
11477 <         { ac_try='test -s conftest$ac_exeext'
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 <  eval "$as_ac_var=yes"
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  
7492 – eval "$as_ac_var=no"
11488   fi
11489 < rm -f conftest.err conftest.$ac_objext \
11490 <      conftest$ac_exeext conftest.$ac_ext
7496 < fi
7497 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7498 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7499 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7500 <  cat >>confdefs.h <<_ACEOF
7501 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7502 < _ACEOF
7503 <
7504 < fi
7505 < done
7506 <
7507 < # special check for _system_configuration because AIX <4.3.2 do not
7508 < # contain the `physmem' member.
7509 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
7510 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
7511 < cat >conftest.$ac_ext <<_ACEOF
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 < #include <sys/systemcfg.h>
11496 >
11497 > #define __USE_STD_IOSTREAM 1
11498 > #ifdef HAVE_IOSTREAM
11499 > #include <iostream>
11500 > #else
11501 > #include <iostream.h>
11502 > #endif
11503 >
11504 > #ifdef FC_DUMMY_MAIN
11505 > #ifndef FC_DUMMY_MAIN_EQ_F77
11506 > #  ifdef __cplusplus
11507 >     extern "C"
11508 > #  endif
11509 >   int FC_DUMMY_MAIN() { return 1; }
11510 > #endif
11511 > #endif
11512   int
11513   main ()
11514   {
11515 < double x = _system_configuration.physmem;
11515 > std::cout<<"Hello World"<<std::endl;return 0;
11516    ;
11517    return 0;
11518   }
# Line 7532 | Line 11526 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11526    cat conftest.err >&5
11527    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528    (exit $ac_status); } &&
11529 <         { ac_try='test -z "$ac_c_werror_flag"
11529 >         { ac_try='test -z "$ac_cxx_werror_flag"
11530                           || test ! -s conftest.err'
11531    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532    (eval $ac_try) 2>&5
# Line 7545 | Line 11539 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11539    ac_status=$?
11540    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541    (exit $ac_status); }; }; then
11542 <  echo "$as_me:$LINENO: result: yes" >&5
7549 < echo "${ECHO_T}yes" >&6
7550 <
7551 < cat >>confdefs.h <<\_ACEOF
7552 < #define HAVE__SYSTEM_CONFIGURATION 1
7553 < _ACEOF
7554 <
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  
7559 – echo "$as_me:$LINENO: result: no" >&5
7560 – echo "${ECHO_T}no" >&6
11547   fi
11548   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11549 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11550 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
11551 < if test "${ac_cv_header_time+set}" = set; then
11549 >        ac_ext=cc
11550 > ac_cpp='$CXXCPP $CPPFLAGS'
11551 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11552 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11553 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11554 >
11555 >      fi
11556 >
11557 > fi
11558 > echo "$as_me:$LINENO: result: $ac_cv_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 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568 >
11569 > cat >>confdefs.h <<\_ACEOF
11570 > #define __USE_STD_IOSTREAM 1
11571 > _ACEOF
11572 >
11573 >  fi
11574 >
11575 >
11576 >
11577 >
11578 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581    echo $ECHO_N "(cached) $ECHO_C" >&6
11582   else
11583 <  cat >conftest.$ac_ext <<_ACEOF
11583 >
11584 >      ac_cv_cxx_have_std_stl=no
11585 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11586 >
11587 >
11588 >        ac_ext=cc
11589 > ac_cpp='$CXXCPP $CPPFLAGS'
11590 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593 >
11594 >        cat >conftest.$ac_ext <<_ACEOF
11595   /* confdefs.h.  */
11596   _ACEOF
11597   cat confdefs.h >>conftest.$ac_ext
11598   cat >>conftest.$ac_ext <<_ACEOF
11599   /* end confdefs.h.  */
11600 < #include <sys/types.h>
7575 < #include <sys/time.h>
7576 < #include <time.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 < if ((struct tm *) 0)
7582 < return 0;
11613 > std::list<int> foo;return 0;
11614    ;
11615    return 0;
11616   }
# Line 7593 | 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 7606 | Line 11637 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11637    ac_status=$?
11638    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639    (exit $ac_status); }; }; then
11640 <  ac_cv_header_time=yes
11640 >  ac_cv_cxx_have_std_stl=yes
11641   else
11642    echo "$as_me: failed program was:" >&5
11643   sed 's/^/| /' conftest.$ac_ext >&5
11644  
7614 – ac_cv_header_time=no
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_header_time" >&5
11657 < echo "${ECHO_T}$ac_cv_header_time" >&6
11658 < if test $ac_cv_header_time = yes; then
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 TIME_WITH_SYS_TIME 1
11661 > #define HAVE_STD_STL 1
11662   _ACEOF
11663  
11664 < fi
11664 >  fi
11665  
11666  
11667 < echo "$as_me:$LINENO: checking for clock_t" >&5
11668 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11669 < if test "${ac_cv_type_clock_t+set}" = set; then
11667 >
11668 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671    echo $ECHO_N "(cached) $ECHO_C" >&6
11672   else
11673 <  cat >conftest.$ac_ext <<_ACEOF
11673 >
11674 >    ac_cv_cxx_have_fstream_attach=no
11675 >
11676 >
11677 >    ac_ext=cc
11678 > ac_cpp='$CXXCPP $CPPFLAGS'
11679 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11680 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11681 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11682 >
11683 >    cat >conftest.$ac_ext <<_ACEOF
11684   /* confdefs.h.  */
11685   _ACEOF
11686   cat confdefs.h >>conftest.$ac_ext
11687   cat >>conftest.$ac_ext <<_ACEOF
11688   /* end confdefs.h.  */
11689 < $ac_includes_default
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 < if ((clock_t *) 0)
7645 <  return 0;
7646 < if (sizeof (clock_t))
7647 <  return 0;
11710 > int fd=0;ofstream s;s.attach(fd);
11711    ;
11712    return 0;
11713   }
# Line 7658 | Line 11721 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11721    cat conftest.err >&5
11722    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723    (exit $ac_status); } &&
11724 <         { ac_try='test -z "$ac_c_werror_flag"
11724 >         { ac_try='test -z "$ac_cxx_werror_flag"
11725                           || test ! -s conftest.err'
11726    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727    (eval $ac_try) 2>&5
# Line 7671 | Line 11734 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11734    ac_status=$?
11735    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736    (exit $ac_status); }; }; then
11737 <  ac_cv_type_clock_t=yes
11737 >  ac_cv_cxx_have_fstream_attach=yes
11738   else
11739    echo "$as_me: failed program was:" >&5
11740   sed 's/^/| /' conftest.$ac_ext >&5
11741  
7679 – ac_cv_type_clock_t=no
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 +
11750 +
11751   fi
11752 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11753 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11754 < if test $ac_cv_type_clock_t = yes; then
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_CLOCK_T 1
11756 > cat >>confdefs.h <<\_ACEOF
11757 > #define HAVE_FSTREAM_ATTACH 1
11758   _ACEOF
11759  
11760 +  fi
11761  
7692 – fi
11762  
11763 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11764 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11765 < if test "${ac_cv_c_const+set}" = set; then
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 <  cat >conftest.$ac_ext <<_ACEOF
11769 >
11770 >    ac_cv_cxx_have_fstream_open=no
11771 >    ac_cv_cxx_fstream_open_prot=no
11772 >
11773 >
11774 >    ac_ext=cc
11775 > ac_cpp='$CXXCPP $CPPFLAGS'
11776 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779 >
11780 >    # Try with 2 parameters
11781 >    cat >conftest.$ac_ext <<_ACEOF
11782   /* confdefs.h.  */
11783   _ACEOF
11784   cat confdefs.h >>conftest.$ac_ext
11785   cat >>conftest.$ac_ext <<_ACEOF
11786   /* end confdefs.h.  */
11787  
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 < /* FIXME: Include the comments suggested by Paul. */
7710 < #ifndef __cplusplus
7711 <  /* Ultrix mips cc rejects this.  */
7712 <  typedef int charset[2];
7713 <  const charset x;
7714 <  /* SunOS 4.1.1 cc rejects this.  */
7715 <  char const *const *ccp;
7716 <  char **p;
7717 <  /* NEC SVR4.0.2 mips cc rejects this.  */
7718 <  struct point {int x, y;};
7719 <  static struct point const zero = {0,0};
7720 <  /* AIX XL C 1.02.0.0 rejects this.
7721 <     It does not let you subtract one const X* pointer from another in
7722 <     an arm of an if-expression whose if-part is not a constant
7723 <     expression */
7724 <  const char *g = "string";
7725 <  ccp = &g + (g ? g-g : 0);
7726 <  /* HPUX 7.0 cc rejects these. */
7727 <  ++ccp;
7728 <  p = (char**) ccp;
7729 <  ccp = (char const *const *) p;
7730 <  { /* SCO 3.2v4 cc rejects this.  */
7731 <    char *t;
7732 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
7733 <
7734 <    *t++ = 0;
7735 <  }
7736 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7737 <    int x[] = {25, 17};
7738 <    const int *foo = &x[0];
7739 <    ++foo;
7740 <  }
7741 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7742 <    typedef const int *iptr;
7743 <    iptr p = 0;
7744 <    ++p;
7745 <  }
7746 <  { /* AIX XL C 1.02.0.0 rejects this saying
7747 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7748 <    struct s { int j; const int *ap[3]; };
7749 <    struct s *b; b->j = 5;
7750 <  }
7751 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7752 <    const int foo = 10;
7753 <  }
7754 < #endif
7755 <
11808 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809    ;
11810    return 0;
11811   }
# Line 7766 | Line 11819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11819    cat conftest.err >&5
11820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821    (exit $ac_status); } &&
11822 <         { ac_try='test -z "$ac_c_werror_flag"
11822 >         { ac_try='test -z "$ac_cxx_werror_flag"
11823                           || test ! -s conftest.err'
11824    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825    (eval $ac_try) 2>&5
# Line 7779 | Line 11832 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11832    ac_status=$?
11833    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834    (exit $ac_status); }; }; then
11835 <  ac_cv_c_const=yes
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
7786 –
7787 – ac_cv_c_const=no
7788 – fi
7789 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7790 – fi
7791 – echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7792 – echo "${ECHO_T}$ac_cv_c_const" >&6
7793 – if test $ac_cv_c_const = no; then
7794 –
7795 – cat >>confdefs.h <<\_ACEOF
7796 – #define const
7797 – _ACEOF
11839  
11840   fi
11841 <
11842 < echo "$as_me:$LINENO: checking for inline" >&5
11843 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7803 < if test "${ac_cv_c_inline+set}" = set; then
7804 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7805 < else
7806 <  ac_cv_c_inline=no
7807 < for ac_kw in inline __inline__ __inline; do
7808 <  cat >conftest.$ac_ext <<_ACEOF
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 < #ifndef __cplusplus
11850 < typedef int foo_t;
11851 < static $ac_kw foo_t static_foo () {return 0; }
11852 < $ac_kw foo_t foo () {return 0; }
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
# Line 7827 | Line 11881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11881    cat conftest.err >&5
11882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883    (exit $ac_status); } &&
11884 <         { ac_try='test -z "$ac_c_werror_flag"
11884 >         { ac_try='test -z "$ac_cxx_werror_flag"
11885                           || test ! -s conftest.err'
11886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887    (eval $ac_try) 2>&5
# Line 7840 | Line 11894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11894    ac_status=$?
11895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896    (exit $ac_status); }; }; then
11897 <  ac_cv_c_inline=$ac_kw; break
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 < done
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_c_inline" >&5
11913 < echo "${ECHO_T}$ac_cv_c_inline" >&6
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 < case $ac_cv_c_inline in
11921 <  inline | yes) ;;
11922 <  *)
11923 <    case $ac_cv_c_inline in
11924 <      no) ac_val=;;
7862 <      *) ac_val=$ac_cv_c_inline;;
7863 <    esac
7864 <    cat >>confdefs.h <<_ACEOF
7865 < #ifndef __cplusplus
7866 < #define inline $ac_val
7867 < #endif
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
7869 –    ;;
7870 – esac
11926  
11927 +  fi
11928  
11929  
7874 –  # clean out junk possibly left behind by a previous configuration
7875 –  rm -f src/getopt.h
7876 –  # Check for getopt_long support
11930  
11931 < for ac_header in getopt.h
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 7908 | 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 7952 | 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 7973 | 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 8024 | 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
8032 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8033 < if eval "test \"\${$as_ac_var+set}\" = set"; then
12091 >
12092 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12093 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12094 > if test "${ac_cv_cpp_func+set}" = set; then
12095    echo $ECHO_N "(cached) $ECHO_C" >&6
12096   else
12097    cat >conftest.$ac_ext <<_ACEOF
# Line 8039 | Line 12100 | cat >>conftest.$ac_ext <<_ACEOF
12100   cat confdefs.h >>conftest.$ac_ext
12101   cat >>conftest.$ac_ext <<_ACEOF
12102   /* end confdefs.h.  */
8042 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8043 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8044 – #define $ac_func innocuous_$ac_func
12103  
12104 < /* System header to define __stub macros and hopefully few prototypes,
12105 <    which can conflict with char $ac_func (); below.
12106 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12107 <    <limits.h> exists even on freestanding compilers.  */
12108 <
12109 < #ifdef __STDC__
8052 < # include <limits.h>
8053 < #else
8054 < # include <assert.h>
8055 < #endif
8056 <
8057 < #undef $ac_func
8058 <
8059 < /* Override any gcc2 internal prototype to avoid an error.  */
8060 < #ifdef __cplusplus
8061 < extern "C"
8062 < {
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
8064 – /* We use char because int might match the return type of a gcc2
8065 –   builtin and then its argument prototype would still apply.  */
8066 – char $ac_func ();
8067 – /* The GNU C library defines this for functions which it implements
8068 –    to always fail with ENOSYS.  Some functions are actually named
8069 –    something starting with __ and the normal name is an alias.  */
8070 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8071 – choke me
8072 – #else
8073 – char (*f) () = $ac_func;
12111   #endif
8075 – #ifdef __cplusplus
8076 – }
8077 – #endif
8078 –
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  
8114 – eval "$as_ac_var=no"
8115 – fi
8116 – rm -f conftest.err conftest.$ac_objext \
8117 –      conftest$ac_exeext conftest.$ac_ext
8118 – fi
8119 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8120 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8121 – if test `eval echo '${'$as_ac_var'}'` = yes; then
8122 –  cat >>confdefs.h <<_ACEOF
8123 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8124 – _ACEOF
8125 –
8126 – else
8127 –  # FreeBSD has a gnugetopt library for this
8128 –    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
8129 – echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
8130 – if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
8131 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8132 – else
8133 –  ac_check_lib_save_LIBS=$LIBS
8134 – LIBS="-lgnugetopt  $LIBS"
12147   cat >conftest.$ac_ext <<_ACEOF
12148   /* confdefs.h.  */
12149   _ACEOF
# Line 8139 | 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
8147 <   builtin and then its argument prototype would still apply.  */
8148 < 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 \
8187 <      conftest$ac_exeext conftest.$ac_ext
8188 < 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
8198 <  # use the GNU replacement
8199 <      case $LIBOBJS in
8200 <    "getopt.$ac_objext"   | \
8201 <  *" getopt.$ac_objext"   | \
8202 <    "getopt.$ac_objext "* | \
8203 <  *" getopt.$ac_objext "* ) ;;
8204 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
8205 < esac
12211 > elif test $ac_cv_cpp_func = no; then
12212  
12213 <      case $LIBOBJS in
12214 <    "getopt1.$ac_objext"   | \
12215 <  *" getopt1.$ac_objext"   | \
8210 <    "getopt1.$ac_objext "* | \
8211 <  *" getopt1.$ac_objext "* ) ;;
8212 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
8213 < esac
8214 <
8215 <                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
12213 > cat >>confdefs.h <<\_ACEOF
12214 > #define __func__ ""
12215 > _ACEOF
12216  
12217   fi
12218  
8219 – fi
8220 – done
12219  
12220  
12221  
12222 +
12223   case $debug in
12224    1)
12225       ;;
# Line 8229 | 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 8309 | 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 8322 | 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 8349 | 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 8380 | 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 8403 | 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 8432 | 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 8455 | 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 8488 | 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 8546 | 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 8579 | 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 8607 | 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 8652 | 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 8763 | 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 8776 | 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 8803 | 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 8834 | 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 8857 | 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 8886 | 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 8909 | 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 8942 | 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
13068 <        ac_m_cpu_60x=yes
8953 < else
8954 <        ac_m_cpu_60x=no
8955 < fi
8956 < rm -f conftest*
8957 <
8958 < fi
8959 < echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
8960 < echo "${ECHO_T}$ac_m_cpu_60x" >&6
8961 < if test "$ac_m_cpu_60x" = yes; then
8962 <        :
8963 <        CPU_FLAGS=-mcpu=$cputype
8964 < else
8965 <        :
8966 <
8967 < fi
8968 <
8969 <                elif test "$cputype" = 750; then
8970 <
8971 <
8972 < echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
8973 < echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
8974 < if test "${ac_cv_prog_gxx_2_95+set}" = set; then
8975 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8976 < else
8977 <
8978 < cat > conftest.cpp <<EOF
8979 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
8980 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
8981 <     yes;
8982 < #  endif
8983 < #endif
8984 < EOF
8985 < if { ac_try='${CXX-c++} -E conftest.cpp'
8986 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8987 <  (eval $ac_try) 2>&5
8988 <  ac_status=$?
8989 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8990 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8991 <  ac_cv_prog_gxx_2_95=yes
8992 < else
8993 <  ac_cv_prog_gxx_2_95=no
8994 < fi
8995 <
8996 < fi
8997 < echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8998 < echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8999 < if test "$ac_cv_prog_gxx_2_95" = yes; then
9000 <        :
9001 <
9002 <
9003 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
9004 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
9005 < if test "${ac_m_cpu_750+set}" = set; then
9006 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9007 < else
9008 <  echo 'void f(){}' > conftest.cpp
9009 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
9010 <        ac_m_cpu_750=yes
9011 < else
9012 <        ac_m_cpu_750=no
9013 < fi
9014 < rm -f conftest*
9015 <
9016 < fi
9017 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
9018 < echo "${ECHO_T}$ac_m_cpu_750" >&6
9019 < if test "$ac_m_cpu_750" = yes; then
9020 <        :
9021 <        CPU_FLAGS=-mcpu=750
9022 < else
9023 <        :
9024 <
9025 < fi
9026 <
9027 < else
9028 <        :
9029 <
9030 < fi
9031 <
9032 <                fi
9033 <                if test -z "$CPU_FLAGS"; then
9034 <
9035 <
9036 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
9037 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
9038 < if test "${ac_m_cpu_powerpc+set}" = set; then
9039 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9040 < else
9041 <  echo 'void f(){}' > conftest.cpp
9042 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
9043 <        ac_m_cpu_powerpc=yes
9044 < else
9045 <        ac_m_cpu_powerpc=no
9046 < fi
9047 < rm -f conftest*
9048 <
9049 < fi
9050 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
9051 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
9052 < if test "$ac_m_cpu_powerpc" = yes; then
9053 <        :
9054 <        CPU_FLAGS=-mcpu=powerpc
9055 < else
9056 <        :
9057 <
9058 < fi
9059 <
9060 <                fi
9061 <                if test -z "$CPU_FLAGS"; then
9062 <
9063 <
9064 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
9065 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
9066 < if test "${ac_m_powerpc+set}" = set; then
9067 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9068 < else
9069 <  echo 'void f(){}' > conftest.cpp
9070 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
9071 <        ac_m_powerpc=yes
9072 < else
9073 <        ac_m_powerpc=no
9074 < fi
9075 < rm -f conftest*
9076 <
9077 < fi
9078 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
9079 < echo "${ECHO_T}$ac_m_powerpc" >&6
9080 < if test "$ac_m_powerpc" = yes; then
9081 <        :
9082 <        CPU_FLAGS=-mpowerpc
9083 < else
9084 <        :
9085 <
9086 < fi
9087 <
9088 <                fi
9089 <          esac
9090 <  fi
9091 <
9092 <  if test -n "$CPU_FLAGS"; then
9093 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
9094 <  fi
9095 <
9096 <  if test -z "$CXXFLAGS"; then
9097 <        echo ""
9098 <        echo "**********************************************************"
9099 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
9100 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9101 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
9102 <        echo "**********************************************************"
9103 <        echo ""
9104 <        CXXFLAGS="-O3"
9105 <  fi
9106 <
9107 <
9108 <
9109 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
9110 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
9111 < if test "${ac_guessed_cxxflags+set}" = set; then
9112 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9113 < else
9114 <  echo 'void f(){}' > conftest.cpp
9115 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
9116 <        ac_guessed_cxxflags=yes
9117 < else
9118 <        ac_guessed_cxxflags=no
9119 < fi
9120 < rm -f conftest*
9121 <
9122 < fi
9123 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
9124 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
9125 < if test "$ac_guessed_cxxflags" = yes; then
9126 <        :
9127 <
9128 < else
9129 <        :
9130 <
9131 <        echo ""
9132 <        echo "**********************************************************"
9133 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
9134 <        echo "* your compiler.                                         *"
9135 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9136 <        echo "**********************************************************"
9137 <        echo ""
9138 <        CXXFLAGS=""
9139 <
9140 < fi
9141 <
9142 <
9143 < fi
9144 <
9145 <
9146 <
9147 <
9148 <
9149 < # Try to determine "good" native compiler flags if none specified on command
9150 < # line
9151 <
9152 < if test x"$F90FLAGS" = x ; then
9153 <  F90FLAGS=""
9154 <  case "${host_cpu}-${host_os}" in
9155 <
9156 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
9157 <                    F90FLAGS="-O"
9158 <                fi;;
9159 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
9160 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
9161 <                fi;;
9162 <   powerpc*-aix*)
9163 <        if test "$F90" = f90 -o "$F90" = xlf90; then
9164 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
9165 <                echo "*******************************************************"
9166 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
9167 <                echo "*  recommended that you use                           *"
9168 <                echo "*                                                     *"
9169 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
9170 <                echo "*                                 ^^^                 *"
9171 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
9172 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
9173 <                echo "*******************************************************"
9174 <        fi;;
9175 <   *darwin*)
9176 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
9177 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
9178 <        fi;;
9179 <  esac
9180 <
9181 <  if test -n "$CPU_FLAGS"; then
9182 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
9183 <  fi
9184 <
9185 <  if test -z "$F90FLAGS"; then
9186 <        echo ""
9187 <        echo "**********************************************************"
9188 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
9189 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9190 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
9191 <        echo "**********************************************************"
9192 <        echo ""
9193 <        F90FLAGS="-O3"
9194 <  fi
9195 <
9196 <
9197 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
9198 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
9199 < if test "${ac_guessed_f90flags+set}" = set; then
9200 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9201 < else
9202 <
9203 <
9204 <
9205 < ac_ext=f90
9206 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
9207 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9208 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
9209 <
9210 < echo 'program main' > conftest.$ac_ext
9211 < echo 'end program main' >> conftest.$ac_ext
9212 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
9213 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9214 <  (eval $ac_compile) 2>&5
9215 <  ac_status=$?
9216 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9217 <  (exit $ac_status); }; then
9218 <        ac_guessed_f90flags=yes
9219 < else
9220 <        ac_guessed_f90flags=no
9221 < fi
9222 < rm -f conftest*
9223 < ac_ext=c
9224 < ac_cpp='$CPP $CPPFLAGS'
9225 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9226 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9227 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9228 <
9229 <
9230 < fi
9231 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
9232 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
9233 < if test "$ac_guessed_f90flags" = yes; then
9234 <        :
9235 <
9236 < else
9237 <        :
9238 <
9239 <        echo ""
9240 <        echo "**********************************************************"
9241 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
9242 <        echo "* your compiler.                                         *"
9243 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9244 <        echo "**********************************************************"
9245 <        echo ""
9246 <        F90FLAGS=""
9247 <
9248 < fi
9249 <
9250 <
9251 < fi
9252 <
9253 <     ;;
9254 < esac
9255 <
9256 < ac_ext=cc
9257 < ac_cpp='$CXXCPP $CPPFLAGS'
9258 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9259 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9260 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9261 <
9262 < # AC_CPP_FUNC
9263 < # ------------------ #
9264 < # Checks to see if ANSI C99 CPP variable __func__ works.
9265 < # If not, perhaps __FUNCTION__ works instead.
9266 < # If not, we'll just define __func__ to "".
9267 < # AC_CPP_FUNC
9268 <
9269 <
9270 < echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
9271 < echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
9272 < if test "${ac_cv_cpp_func+set}" = set; then
9273 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9274 < else
9275 <  cat >conftest.$ac_ext <<_ACEOF
9276 < /* confdefs.h.  */
9277 < _ACEOF
9278 < cat confdefs.h >>conftest.$ac_ext
9279 < cat >>conftest.$ac_ext <<_ACEOF
9280 < /* end confdefs.h.  */
9281 <
9282 < int
9283 < main ()
9284 < {
9285 < const char *foo = __func__;
9286 <  ;
9287 <  return 0;
9288 < }
9289 < _ACEOF
9290 < rm -f conftest.$ac_objext
9291 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9292 <  (eval $ac_compile) 2>conftest.er1
9293 <  ac_status=$?
9294 <  grep -v '^ *+' conftest.er1 >conftest.err
9295 <  rm -f conftest.er1
9296 <  cat conftest.err >&5
9297 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9298 <  (exit $ac_status); } &&
9299 <         { ac_try='test -z "$ac_cxx_werror_flag"
9300 <                         || test ! -s conftest.err'
9301 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9302 <  (eval $ac_try) 2>&5
9303 <  ac_status=$?
9304 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9305 <  (exit $ac_status); }; } &&
9306 <         { ac_try='test -s conftest.$ac_objext'
9307 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9308 <  (eval $ac_try) 2>&5
9309 <  ac_status=$?
9310 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9311 <  (exit $ac_status); }; }; then
9312 <  ac_cv_cpp_func=yes
9313 < else
9314 <  echo "$as_me: failed program was:" >&5
9315 < sed 's/^/| /' conftest.$ac_ext >&5
9316 <
9317 < cat >conftest.$ac_ext <<_ACEOF
9318 < /* confdefs.h.  */
9319 < _ACEOF
9320 < cat confdefs.h >>conftest.$ac_ext
9321 < cat >>conftest.$ac_ext <<_ACEOF
9322 < /* end confdefs.h.  */
9323 <
9324 < int
9325 < main ()
9326 < {
9327 < const char *foo = __FUNCTION__;
9328 <  ;
9329 <  return 0;
9330 < }
9331 < _ACEOF
9332 < rm -f conftest.$ac_objext
9333 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9334 <  (eval $ac_compile) 2>conftest.er1
9335 <  ac_status=$?
9336 <  grep -v '^ *+' conftest.er1 >conftest.err
9337 <  rm -f conftest.er1
9338 <  cat conftest.err >&5
9339 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9340 <  (exit $ac_status); } &&
9341 <         { ac_try='test -z "$ac_cxx_werror_flag"
9342 <                         || test ! -s conftest.err'
9343 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9344 <  (eval $ac_try) 2>&5
9345 <  ac_status=$?
9346 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9347 <  (exit $ac_status); }; } &&
9348 <         { ac_try='test -s conftest.$ac_objext'
9349 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9350 <  (eval $ac_try) 2>&5
9351 <  ac_status=$?
9352 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9353 <  (exit $ac_status); }; }; then
9354 <  ac_cv_cpp_func=__FUNCTION__
9355 < else
9356 <  echo "$as_me: failed program was:" >&5
9357 < sed 's/^/| /' conftest.$ac_ext >&5
9358 <
9359 < ac_cv_cpp_func=no
9360 < fi
9361 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9362 < fi
9363 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9364 < fi
9365 < echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
9366 < echo "${ECHO_T}$ac_cv_cpp_func" >&6
9367 < if test $ac_cv_cpp_func = __FUNCTION__; then
9368 <
9369 < cat >>confdefs.h <<\_ACEOF
9370 < #define __func__ __FUNCTION__
9371 < _ACEOF
9372 <
9373 < elif test $ac_cv_cpp_func = no; then
9374 <
9375 < cat >>confdefs.h <<\_ACEOF
9376 < #define __func__ ""
9377 < _ACEOF
9378 <
9379 < fi
9380 <
9381 <
9382 < ac_ext=c
9383 < ac_cpp='$CPP $CPPFLAGS'
9384 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9385 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9386 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9387 <
9388 <
9389 < # Find a good install program.  We prefer a C program (faster),
9390 < # so one script is as good as another.  But avoid the broken or
9391 < # incompatible versions:
9392 < # SysV /etc/install, /usr/sbin/install
9393 < # SunOS /usr/etc/install
9394 < # IRIX /sbin/install
9395 < # AIX /bin/install
9396 < # AmigaOS /C/install, which installs bootblocks on floppy discs
9397 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
9398 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
9399 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
9400 < # OS/2's system install, which has a completely different semantic
9401 < # ./install, which can be erroneously created by make from ./install.sh.
9402 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
9403 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
9404 < if test -z "$INSTALL"; then
9405 < if test "${ac_cv_path_install+set}" = set; then
9406 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9407 < else
9408 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9409 < for as_dir in $PATH
9410 < do
9411 <  IFS=$as_save_IFS
9412 <  test -z "$as_dir" && as_dir=.
9413 <  # Account for people who put trailing slashes in PATH elements.
9414 < case $as_dir/ in
9415 <  ./ | .// | /cC/* | \
9416 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
9417 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
9418 <  /usr/ucb/* ) ;;
9419 <  *)
9420 <    # OSF1 and SCO ODT 3.0 have their own names for install.
9421 <    # Don't use installbsd from OSF since it installs stuff as root
9422 <    # by default.
9423 <    for ac_prog in ginstall scoinst install; do
9424 <      for ac_exec_ext in '' $ac_executable_extensions; do
9425 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
9426 <          if test $ac_prog = install &&
9427 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9428 <            # AIX install.  It has an incompatible calling convention.
9429 <            :
9430 <          elif test $ac_prog = install &&
9431 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9432 <            # program-specific install script used by HP pwplus--don't use.
9433 <            :
9434 <          else
9435 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
9436 <            break 3
9437 <          fi
9438 <        fi
9439 <      done
9440 <    done
9441 <    ;;
9442 < esac
9443 < done
9444 <
9445 <
9446 < fi
9447 <  if test "${ac_cv_path_install+set}" = set; then
9448 <    INSTALL=$ac_cv_path_install
9449 <  else
9450 <    # As a last resort, use the slow shell script.  We don't cache a
9451 <    # path for INSTALL within a source directory, because that will
9452 <    # break other packages using the cache if that directory is
9453 <    # removed, or if the path is relative.
9454 <    INSTALL=$ac_install_sh
9455 <  fi
9456 < fi
9457 < echo "$as_me:$LINENO: result: $INSTALL" >&5
9458 < echo "${ECHO_T}$INSTALL" >&6
9459 <
9460 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
9461 < # It thinks the first close brace ends the variable substitution.
9462 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
9463 <
9464 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
9465 <
9466 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
9467 <
9468 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
9469 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
9470 < LN_S=$as_ln_s
9471 < if test "$LN_S" = "ln -s"; then
9472 <  echo "$as_me:$LINENO: result: yes" >&5
9473 < echo "${ECHO_T}yes" >&6
13067 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068 >        ac_m_cpu_60x=yes
13069   else
13070 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
9476 < echo "${ECHO_T}no, using $LN_S" >&6
13070 >        ac_m_cpu_60x=no
13071   fi
13072 + rm -f conftest*
13073  
9479 – echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
9480 – echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
9481 – set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
9482 – if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
9483 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9484 – else
9485 –  cat >conftest.make <<\_ACEOF
9486 – all:
9487 –        @echo 'ac_maketemp="$(MAKE)"'
9488 – _ACEOF
9489 – # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
9490 – eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
9491 – if test -n "$ac_maketemp"; then
9492 –  eval ac_cv_prog_make_${ac_make}_set=yes
9493 – else
9494 –  eval ac_cv_prog_make_${ac_make}_set=no
13074   fi
13075 < rm -f conftest.make
13076 < fi
13077 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
13078 <  echo "$as_me:$LINENO: result: yes" >&5
13079 < echo "${ECHO_T}yes" >&6
9501 <  SET_MAKE=
13075 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
13076 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
13077 > if test "$ac_m_cpu_60x" = yes; then
13078 >        :
13079 >        CPU_FLAGS=-mcpu=$cputype
13080   else
13081 <  echo "$as_me:$LINENO: result: no" >&5
13082 < echo "${ECHO_T}no" >&6
9505 <  SET_MAKE="MAKE=${MAKE-make}"
13081 >        :
13082 >
13083   fi
13084  
13085 < if test -n "$ac_tool_prefix"; then
13086 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
13087 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
13088 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13089 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13090 < if test "${ac_cv_prog_RANLIB+set}" = set; then
13085 >                elif test "$cputype" = 750; then
13086 >
13087 >
13088 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
13089 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
13090 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
13091    echo $ECHO_N "(cached) $ECHO_C" >&6
13092   else
9516 –  if test -n "$RANLIB"; then
9517 –  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
9518 – else
9519 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9520 – for as_dir in $PATH
9521 – do
9522 –  IFS=$as_save_IFS
9523 –  test -z "$as_dir" && as_dir=.
9524 –  for ac_exec_ext in '' $ac_executable_extensions; do
9525 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9526 –    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
9527 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9528 –    break 2
9529 –  fi
9530 – done
9531 – done
13093  
13094 < fi
13095 < fi
13096 < RANLIB=$ac_cv_prog_RANLIB
13097 < if test -n "$RANLIB"; then
13098 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
13099 < echo "${ECHO_T}$RANLIB" >&6
13094 > cat > conftest.cpp <<EOF
13095 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
13096 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
13097 >     yes;
13098 > #  endif
13099 > #endif
13100 > EOF
13101 > if { ac_try='${CXX-c++} -E conftest.cpp'
13102 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13103 >  (eval $ac_try) 2>&5
13104 >  ac_status=$?
13105 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13106 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13107 >  ac_cv_prog_gxx_2_95=yes
13108   else
13109 <  echo "$as_me:$LINENO: result: no" >&5
9541 < echo "${ECHO_T}no" >&6
13109 >  ac_cv_prog_gxx_2_95=no
13110   fi
13111  
13112   fi
13113 < if test -z "$ac_cv_prog_RANLIB"; then
13114 <  ac_ct_RANLIB=$RANLIB
13115 <  # Extract the first word of "ranlib", so it can be a program name with args.
13116 < set dummy ranlib; ac_word=$2
13117 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13118 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13119 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
13113 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
13114 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
13115 > if test "$ac_cv_prog_gxx_2_95" = yes; then
13116 >        :
13117 >
13118 >
13119 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121 > if test "${ac_m_cpu_750+set}" = set; then
13122    echo $ECHO_N "(cached) $ECHO_C" >&6
13123   else
13124 <  if test -n "$ac_ct_RANLIB"; then
13125 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
13124 >  echo 'void f(){}' > conftest.cpp
13125 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126 >        ac_m_cpu_750=yes
13127   else
13128 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13129 < for as_dir in $PATH
13130 < do
9560 <  IFS=$as_save_IFS
9561 <  test -z "$as_dir" && as_dir=.
9562 <  for ac_exec_ext in '' $ac_executable_extensions; do
9563 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9564 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
9565 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9566 <    break 2
9567 <  fi
9568 < done
9569 < done
13128 >        ac_m_cpu_750=no
13129 > fi
13130 > rm -f conftest*
13131  
9571 –  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
13132   fi
13133 < fi
13134 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
13135 < if test -n "$ac_ct_RANLIB"; then
13136 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
13137 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
13133 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13134 > echo "${ECHO_T}$ac_m_cpu_750" >&6
13135 > if test "$ac_m_cpu_750" = yes; then
13136 >        :
13137 >        CPU_FLAGS=-mcpu=750
13138   else
13139 <  echo "$as_me:$LINENO: result: no" >&5
13140 < echo "${ECHO_T}no" >&6
13139 >        :
13140 >
13141   fi
13142  
9583 –  RANLIB=$ac_ct_RANLIB
13143   else
13144 <  RANLIB="$ac_cv_prog_RANLIB"
13144 >        :
13145 >
13146   fi
13147  
13148 < for ac_prog in 'bison -y' byacc
13149 < do
13150 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13151 < set dummy $ac_prog; ac_word=$2
13152 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13153 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13154 < if test "${ac_cv_prog_YACC+set}" = set; then
13148 >                fi
13149 >                if test -z "$CPU_FLAGS"; then
13150 >
13151 >
13152 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13153 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13154 > if test "${ac_m_cpu_powerpc+set}" = set; then
13155    echo $ECHO_N "(cached) $ECHO_C" >&6
13156   else
13157 <  if test -n "$YACC"; then
13158 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
13157 >  echo 'void f(){}' > conftest.cpp
13158 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13159 >        ac_m_cpu_powerpc=yes
13160   else
13161 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13162 < for as_dir in $PATH
13163 < do
9603 <  IFS=$as_save_IFS
9604 <  test -z "$as_dir" && as_dir=.
9605 <  for ac_exec_ext in '' $ac_executable_extensions; do
9606 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9607 <    ac_cv_prog_YACC="$ac_prog"
9608 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9609 <    break 2
9610 <  fi
9611 < done
9612 < done
13161 >        ac_m_cpu_powerpc=no
13162 > fi
13163 > rm -f conftest*
13164  
13165   fi
13166 < fi
13167 < YACC=$ac_cv_prog_YACC
13168 < if test -n "$YACC"; then
13169 <  echo "$as_me:$LINENO: result: $YACC" >&5
13170 < echo "${ECHO_T}$YACC" >&6
13166 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13167 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
13168 > if test "$ac_m_cpu_powerpc" = yes; then
13169 >        :
13170 >        CPU_FLAGS=-mcpu=powerpc
13171   else
13172 <  echo "$as_me:$LINENO: result: no" >&5
13173 < echo "${ECHO_T}no" >&6
13172 >        :
13173 >
13174   fi
13175  
13176 <  test -n "$YACC" && break
13177 < done
9627 < test -n "$YACC" || YACC="yacc"
13176 >                fi
13177 >                if test -z "$CPU_FLAGS"; then
13178  
13179 < for ac_prog in flex lex
13180 < do
13181 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13182 < set dummy $ac_prog; ac_word=$2
9633 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9634 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9635 < if test "${ac_cv_prog_LEX+set}" = set; then
13179 >
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 <  if test -n "$LEX"; then
13186 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
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 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13190 < for as_dir in $PATH
13191 < do
9644 <  IFS=$as_save_IFS
9645 <  test -z "$as_dir" && as_dir=.
9646 <  for ac_exec_ext in '' $ac_executable_extensions; do
9647 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9648 <    ac_cv_prog_LEX="$ac_prog"
9649 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9650 <    break 2
9651 <  fi
9652 < done
9653 < done
13189 >        ac_m_powerpc=no
13190 > fi
13191 > rm -f conftest*
13192  
13193   fi
13194 < fi
13195 < LEX=$ac_cv_prog_LEX
13196 < if test -n "$LEX"; then
13197 <  echo "$as_me:$LINENO: result: $LEX" >&5
13198 < echo "${ECHO_T}$LEX" >&6
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 <  echo "$as_me:$LINENO: result: no" >&5
13201 < echo "${ECHO_T}no" >&6
13200 >        :
13201 >
13202   fi
13203  
13204 <  test -n "$LEX" && break
13205 < done
13206 < test -n "$LEX" || LEX=":"
9669 <
9670 < if test -z "$LEXLIB"
9671 < then
9672 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
9673 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
9674 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
9675 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9676 < else
9677 <  ac_check_lib_save_LIBS=$LIBS
9678 < LIBS="-lfl  $LIBS"
9679 < cat >conftest.$ac_ext <<_ACEOF
9680 < /* confdefs.h.  */
9681 < _ACEOF
9682 < cat confdefs.h >>conftest.$ac_ext
9683 < cat >>conftest.$ac_ext <<_ACEOF
9684 < /* end confdefs.h.  */
13204 >                fi
13205 >          esac
13206 >  fi
13207  
13208 < /* Override any gcc2 internal prototype to avoid an error.  */
13209 < #ifdef __cplusplus
13210 < extern "C"
9689 < #endif
9690 < /* We use char because int might match the return type of a gcc2
9691 <   builtin and then its argument prototype would still apply.  */
9692 < char yywrap ();
9693 < int
9694 < main ()
9695 < {
9696 < yywrap ();
9697 <  ;
9698 <  return 0;
9699 < }
9700 < _ACEOF
9701 < rm -f conftest.$ac_objext conftest$ac_exeext
9702 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9703 <  (eval $ac_link) 2>conftest.er1
9704 <  ac_status=$?
9705 <  grep -v '^ *+' conftest.er1 >conftest.err
9706 <  rm -f conftest.er1
9707 <  cat conftest.err >&5
9708 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9709 <  (exit $ac_status); } &&
9710 <         { ac_try='test -z "$ac_c_werror_flag"
9711 <                         || test ! -s conftest.err'
9712 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9713 <  (eval $ac_try) 2>&5
9714 <  ac_status=$?
9715 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9716 <  (exit $ac_status); }; } &&
9717 <         { ac_try='test -s conftest$ac_exeext'
9718 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9719 <  (eval $ac_try) 2>&5
9720 <  ac_status=$?
9721 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9722 <  (exit $ac_status); }; }; then
9723 <  ac_cv_lib_fl_yywrap=yes
9724 < else
9725 <  echo "$as_me: failed program was:" >&5
9726 < sed 's/^/| /' conftest.$ac_ext >&5
13208 >  if test -n "$CPU_FLAGS"; then
13209 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13210 >  fi
13211  
13212 < ac_cv_lib_fl_yywrap=no
13213 < fi
13214 < rm -f conftest.err conftest.$ac_objext \
13215 <      conftest$ac_exeext conftest.$ac_ext
13216 < LIBS=$ac_check_lib_save_LIBS
13217 < fi
13218 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
13219 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
13220 < if test $ac_cv_lib_fl_yywrap = yes; then
13221 <  LEXLIB="-lfl"
9738 < else
9739 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
9740 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
9741 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
9742 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9743 < else
9744 <  ac_check_lib_save_LIBS=$LIBS
9745 < LIBS="-ll  $LIBS"
9746 < cat >conftest.$ac_ext <<_ACEOF
9747 < /* confdefs.h.  */
9748 < _ACEOF
9749 < cat confdefs.h >>conftest.$ac_ext
9750 < cat >>conftest.$ac_ext <<_ACEOF
9751 < /* end confdefs.h.  */
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  
9753 – /* Override any gcc2 internal prototype to avoid an error.  */
9754 – #ifdef __cplusplus
9755 – extern "C"
9756 – #endif
9757 – /* We use char because int might match the return type of a gcc2
9758 –   builtin and then its argument prototype would still apply.  */
9759 – char yywrap ();
9760 – int
9761 – main ()
9762 – {
9763 – yywrap ();
9764 –  ;
9765 –  return 0;
9766 – }
9767 – _ACEOF
9768 – rm -f conftest.$ac_objext conftest$ac_exeext
9769 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9770 –  (eval $ac_link) 2>conftest.er1
9771 –  ac_status=$?
9772 –  grep -v '^ *+' conftest.er1 >conftest.err
9773 –  rm -f conftest.er1
9774 –  cat conftest.err >&5
9775 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9776 –  (exit $ac_status); } &&
9777 –         { ac_try='test -z "$ac_c_werror_flag"
9778 –                         || test ! -s conftest.err'
9779 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9780 –  (eval $ac_try) 2>&5
9781 –  ac_status=$?
9782 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9783 –  (exit $ac_status); }; } &&
9784 –         { ac_try='test -s conftest$ac_exeext'
9785 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9786 –  (eval $ac_try) 2>&5
9787 –  ac_status=$?
9788 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9789 –  (exit $ac_status); }; }; then
9790 –  ac_cv_lib_l_yywrap=yes
9791 – else
9792 –  echo "$as_me: failed program was:" >&5
9793 – sed 's/^/| /' conftest.$ac_ext >&5
13223  
9795 – ac_cv_lib_l_yywrap=no
9796 – fi
9797 – rm -f conftest.err conftest.$ac_objext \
9798 –      conftest$ac_exeext conftest.$ac_ext
9799 – LIBS=$ac_check_lib_save_LIBS
9800 – fi
9801 – echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9802 – echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9803 – if test $ac_cv_lib_l_yywrap = yes; then
9804 –  LEXLIB="-ll"
9805 – fi
13224  
13225 < fi
13226 <
13227 < fi
9810 <
9811 < if test "x$LEX" != "x:"; then
9812 <  echo "$as_me:$LINENO: checking lex output file root" >&5
9813 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9814 < if test "${ac_cv_prog_lex_root+set}" = set; then
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 <  # The minimal lex program is just a single line: %%.  But some broken lexes
13231 < # (Solaris, I think it was) want two %% lines, so accommodate them.
13232 < cat >conftest.l <<_ACEOF
9820 < %%
9821 < %%
9822 < _ACEOF
9823 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9824 <  (eval $LEX conftest.l) 2>&5
9825 <  ac_status=$?
9826 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9827 <  (exit $ac_status); }
9828 < if test -f lex.yy.c; then
9829 <  ac_cv_prog_lex_root=lex.yy
9830 < elif test -f lexyy.c; then
9831 <  ac_cv_prog_lex_root=lexyy
13230 >  echo 'void f(){}' > conftest.cpp
13231 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13232 >        ac_guessed_cxxflags=yes
13233   else
13234 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9834 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9835 <   { (exit 1); exit 1; }; }
13234 >        ac_guessed_cxxflags=no
13235   fi
13236 < fi
9838 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9839 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9840 < rm -f conftest.l
9841 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13236 > rm -f conftest*
13237  
9843 – echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9844 – echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9845 – if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9846 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9847 – else
9848 –  # POSIX says lex can declare yytext either as a pointer or an array; the
9849 – # default is implementation-dependent. Figure out which it is, since
9850 – # not all implementations provide the %pointer and %array declarations.
9851 – ac_cv_prog_lex_yytext_pointer=no
9852 – echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9853 – ac_save_LIBS=$LIBS
9854 – LIBS="$LIBS $LEXLIB"
9855 – cat >conftest.$ac_ext <<_ACEOF
9856 – `cat $LEX_OUTPUT_ROOT.c`
9857 – _ACEOF
9858 – rm -f conftest.$ac_objext conftest$ac_exeext
9859 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9860 –  (eval $ac_link) 2>conftest.er1
9861 –  ac_status=$?
9862 –  grep -v '^ *+' conftest.er1 >conftest.err
9863 –  rm -f conftest.er1
9864 –  cat conftest.err >&5
9865 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866 –  (exit $ac_status); } &&
9867 –         { ac_try='test -z "$ac_c_werror_flag"
9868 –                         || test ! -s conftest.err'
9869 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9870 –  (eval $ac_try) 2>&5
9871 –  ac_status=$?
9872 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9873 –  (exit $ac_status); }; } &&
9874 –         { ac_try='test -s conftest$ac_exeext'
9875 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9876 –  (eval $ac_try) 2>&5
9877 –  ac_status=$?
9878 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9879 –  (exit $ac_status); }; }; then
9880 –  ac_cv_prog_lex_yytext_pointer=yes
9881 – else
9882 –  echo "$as_me: failed program was:" >&5
9883 – sed 's/^/| /' conftest.$ac_ext >&5
9884 –
13238   fi
13239 < rm -f conftest.err conftest.$ac_objext \
13240 <      conftest$ac_exeext conftest.$ac_ext
13241 < LIBS=$ac_save_LIBS
13242 < rm -f "${LEX_OUTPUT_ROOT}.c"
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  
9891 – fi
9892 – echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9893 – echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9894 – if test $ac_cv_prog_lex_yytext_pointer = yes; then
9895 –
9896 – cat >>confdefs.h <<\_ACEOF
9897 – #define YYTEXT_POINTER 1
9898 – _ACEOF
9899 –
9900 – fi
9901 –
9902 – fi
9903 –
9904 –   # Extract the first word of "perl", so it can be a program name with args.
9905 – set dummy perl; ac_word=$2
9906 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9907 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9908 – if test "${ac_cv_path_PERLINTERP+set}" = set; then
9909 –  echo $ECHO_N "(cached) $ECHO_C" >&6
13244   else
13245 <  case $PERLINTERP in
9912 <  [\\/]* | ?:[\\/]*)
9913 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9914 <  ;;
9915 <  *)
9916 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9917 < for as_dir in $PATH
9918 < do
9919 <  IFS=$as_save_IFS
9920 <  test -z "$as_dir" && as_dir=.
9921 <  for ac_exec_ext in '' $ac_executable_extensions; do
9922 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9923 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9924 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9925 <    break 2
9926 <  fi
9927 < done
9928 < done
13245 >        :
13246  
13247 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
13248 <  ;;
13249 < esac
13250 < fi
13251 < PERLINTERP=$ac_cv_path_PERLINTERP
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  
9936 – if test -n "$PERLINTERP"; then
9937 –  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9938 – echo "${ECHO_T}$PERLINTERP" >&6
9939 – else
9940 –  echo "$as_me:$LINENO: result: no" >&5
9941 – echo "${ECHO_T}no" >&6
13256   fi
13257  
9944 –   ac_cv_path_perlinterp="$PERLINTERP"
9945 –   _sHpB='#!'
13258  
9947 –
9948 – # Check whether --with-perl-shebang or --without-perl-shebang was given.
9949 – if test "${with_perl_shebang+set}" = set; then
9950 –  withval="$with_perl_shebang"
9951 –  opt_perl_shebang="$withval"
9952 – else
9953 –                opt_perl_shebang="not_set"
9954 – fi;
9955 –   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9956 – echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9957 – if test "${ax_cv_opt_perl_shebang+set}" = set; then
9958 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9959 – else
9960 –   case "$opt_perl_shebang" in
9961 –                      not_set  ) ax_cv_opt_perl_shebang=''
9962 –                               ;;
9963 –                         *     )
9964 –        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9965 –                    esac
9966 –
13259   fi
9968 – echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9969 – echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9970 –   if test "A$ax_cv_opt_perl_shebang" != "A"
9971 –     then
9972 –       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9973 –       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9974 –              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9975 – echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
13260  
13261 < # Automatic detection of sharpbang formula starts here
9978 <     else
9979 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
9980 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9981 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9982 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9983 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9984 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9985 < else
9986 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9987 <        if test "x$_somian_kspb_perl" == x
9988 <          then _somian_ksbp_warn_empty='durnit'
9989 <          else
9990 <          case "A$_somian_kspb_perl" in
9991 <                 A#!*perl* )
9992 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9993 <                        ;;
9994 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9995 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9996 <          esac
9997 <        fi
9998 <
9999 < fi
10000 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
10001 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
10002 < # The above prints Checking ... result message to user.
10003 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
10004 <
10005 <    if test A${_somian_ksbp_warn_empty+set} == Aset
10006 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
10007 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
10008 <    fi
10009 < # Inform user after printing result value
10010 <    if test A${_somian_ksbp_warn_defau+set} == Aset
10011 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
10012 < echo "$as_me: Maybe Not good -" >&6;}
10013 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
10014 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
10015 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
10016 < echo "$as_me: OK Good result - " >&6;}
10017 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
10018 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
10019 <    fi
10020 <  fi
10021 <
10022 < # Extract the first word of "ar", so it can be a program name with args.
10023 < set dummy ar; ac_word=$2
10024 < echo "$as_me:$LINENO: checking for $ac_word" >&5
10025 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10026 < if test "${ac_cv_prog_AR+set}" = set; then
10027 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10028 < else
10029 <  if test -n "$AR"; then
10030 <  ac_cv_prog_AR="$AR" # Let the user override the test.
10031 < else
10032 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10033 < for as_dir in $PATH
10034 < do
10035 <  IFS=$as_save_IFS
10036 <  test -z "$as_dir" && as_dir=.
10037 <  for ac_exec_ext in '' $ac_executable_extensions; do
10038 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10039 <    ac_cv_prog_AR="ar"
10040 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10041 <    break 2
10042 <  fi
10043 < done
10044 < done
10045 <
10046 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
10047 < fi
10048 < fi
10049 < AR=$ac_cv_prog_AR
10050 < if test -n "$AR"; then
10051 <  echo "$as_me:$LINENO: result: $AR" >&5
10052 < echo "${ECHO_T}$AR" >&6
10053 < else
10054 <  echo "$as_me:$LINENO: result: no" >&5
10055 < echo "${ECHO_T}no" >&6
10056 < fi
10057 <
10058 < if test "$AR" = "NONE"; then
10059 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
10060 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
10061 <   { (exit 1); exit 1; }; }
10062 <  cat >confcache <<\_ACEOF
10063 < # This file is a shell script that caches the results of configure
10064 < # tests run on this system so they can be shared between configure
10065 < # scripts and configure runs, see configure's option --config-cache.
10066 < # It is not useful on other systems.  If it contains results you don't
10067 < # want to keep, you may remove or edit it.
10068 < #
10069 < # config.status only pays attention to the cache file if you give it
10070 < # the --recheck option to rerun configure.
10071 < #
10072 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
10073 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
10074 < # following values.
10075 <
10076 < _ACEOF
10077 <
10078 < # The following way of writing the cache mishandles newlines in values,
10079 < # but we know of no workaround that is simple, portable, and efficient.
10080 < # So, don't put newlines in cache variables' values.
10081 < # Ultrix sh set writes to stderr and can't be redirected directly,
10082 < # and sets the high bit in the cache file unless we assign to the vars.
10083 < {
10084 <  (set) 2>&1 |
10085 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
10086 <    *ac_space=\ *)
10087 <      # `set' does not quote correctly, so add quotes (double-quote
10088 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
10089 <      sed -n \
10090 <        "s/'/'\\\\''/g;
10091 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
10092 <      ;;
10093 <    *)
10094 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
10095 <      sed -n \
10096 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
10097 <      ;;
10098 <    esac;
10099 < } |
10100 <  sed '
10101 <     t clear
10102 <     : clear
10103 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
10104 <     t end
10105 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
10106 <     : end' >>confcache
10107 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
10108 <  if test -w $cache_file; then
10109 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
10110 <    cat confcache >$cache_file
10111 <  else
10112 <    echo "not updating unwritable cache $cache_file"
10113 <  fi
10114 < fi
10115 < rm -f confcache
10116 <  exit 1
10117 < fi
10118 <
10119 < # Extract the first word of "ps", so it can be a program name with args.
10120 < set dummy ps; ac_word=$2
10121 < echo "$as_me:$LINENO: checking for $ac_word" >&5
10122 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10123 < if test "${ac_cv_path_PS+set}" = set; then
10124 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10125 < else
10126 <  case $PS in
10127 <  [\\/]* | ?:[\\/]*)
10128 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
10129 <  ;;
10130 <  *)
10131 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 < for as_dir in $PATH
10133 < do
10134 <  IFS=$as_save_IFS
10135 <  test -z "$as_dir" && as_dir=.
10136 <  for ac_exec_ext in '' $ac_executable_extensions; do
10137 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
10139 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10140 <    break 2
10141 <  fi
10142 < done
10143 < done
10144 <
10145 <  ;;
13261 >     ;;
13262   esac
10147 – fi
10148 – PS=$ac_cv_path_PS
13263  
10150 – if test -n "$PS"; then
10151 –  echo "$as_me:$LINENO: result: $PS" >&5
10152 – echo "${ECHO_T}$PS" >&6
10153 – else
10154 –  echo "$as_me:$LINENO: result: no" >&5
10155 – echo "${ECHO_T}no" >&6
10156 – fi
13264  
10158 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
10159 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
10160 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
10161 –  echo $ECHO_N "(cached) $ECHO_C" >&6
10162 – else
10163 –
10164 –        if $PS ax -o rss > /dev/null 2>&1; then
10165 –                ac_cv_prog_ps_ax=yes
10166 –        else
10167 –                ac_cv_prog_ps_ax=no
10168 –        fi
10169 –        if $PS -ef -o rss > /dev/null 2>&1; then
10170 –                ac_cv_prog_ps_ef=yes
10171 –        else
10172 –                ac_cv_prog_ps_ef=no
10173 –        fi
10174 –        if test "$ac_cv_prog_ps_ax" = yes; then
10175 –                ac_cv_prog_ps_syntax=BSD
10176 –        else
10177 –                if test "$ac_cv_prog_ps_ef" = yes; then
10178 –                        ac_cv_prog_ps_syntax=POSIX
10179 –                else
10180 –                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
10181 – echo "$as_me: error: Could not determine ps syntax" >&2;}
10182 –   { (exit 1); exit 1; }; }
10183 –                fi
10184 –        fi
10185 –
10186 – fi
10187 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
10188 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
10189 –
10190 –
10191 – cat >>confdefs.h <<_ACEOF
10192 – #define PSCOMMAND $PS
10193 – _ACEOF
10194 –
10195 –
13265   cat >>confdefs.h <<\_ACEOF
13266   #define OBAPI
13267   _ACEOF
13268  
13269  
13270  
10202 – if test "$ac_cv_prog_ps_syntax" = BSD; then
13271  
10204 – cat >>confdefs.h <<\_ACEOF
10205 – #define PSTYPE_IS_BSD 1
10206 – _ACEOF
10207 –
10208 – else
10209 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
10210 –
10211 – cat >>confdefs.h <<\_ACEOF
10212 – #define PSTYPE_IS_POSIX 1
10213 – _ACEOF
10214 –
10215 –   else
10216 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
10217 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
10218 –   { (exit 1); exit 1; }; }
10219 –   fi
10220 – fi
10221 –
10222 –
13272   # Check whether --with-mpi or --without-mpi was given.
13273   if test "${with_mpi+set}" = set; then
13274    withval="$with_mpi"
# Line 10275 | 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 10334 | 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 10404 | 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 10475 | 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 10546 | 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 10590 | 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 10618 | 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 11036 | 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 11276 | Line 14373 | fi
14373   else
14374          enable_dot=yes
14375   fi
11279 –
11280 –
11281 –
11282 –
11283 –
11284 –
11285 –
11286 – OBJEXT=".$OBJEXT"
11287 –
11288 – OOPSE=oopse
11289 –
11290 – if test "x${prefix}" = "xNONE"
11291 – then
11292 –  OOPSE_HOME=${ac_default_prefix}/oopse
11293 – else
11294 –  OOPSE_HOME=${prefix}/oopse
11295 – fi
11296 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
11297 – if test "${enable_oopse_home+set}" = set; then
11298 –  enableval="$enable_oopse_home"
11299 –  OOPSE_HOME="${enableval}"
11300 – fi;
11301 –
11302 – case "x$INSTALL" in
11303 –   x/*) ;;
11304 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
11305 – esac
14376  
11307 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14377  
11309 – CFLAGS=${CFLAGS-""}
11310 – CXXFLAGS=${CXXFLAGS-""}
11311 – CPPFLAGS=${CPPFLAGS-""}
11312 – FFLAGS=${FFLAGS-""}
11313 – F90FLAGS=${F90FLAGS-""}
11314 – LDFLAGS=${LDFLAGS-""}
11315 – DEBUG=${DEBUG-"-g"}
14378  
11317 – case $debug in
11318 –  1)
11319 –     FFLAGS="$DEBUG $FFLAGS"
11320 –     F90FLAGS="$DEBUG $F90FLAGS"
11321 –     ;;
11322 –  *)
11323 –     ;;
11324 – esac
14379  
14380  
14381  
# Line 11338 | Line 14392 | esac
14392  
14393  
14394  
11341 –
11342 –
11343 –          ac_config_headers="$ac_config_headers src/config.h"
11344 –
14395                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396  
14397  
# Line 11707 | 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 11770 | 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 11964 | 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
11967 – s,@PROGNAME@,$PROGNAME,;t t
11968 – 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 11974 | 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
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
11989 – s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11990 – s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11991 – s,@F90@,$F90,;t t
11992 – s,@F90FLAGS@,$F90FLAGS,;t t
11993 – s,@ac_ct_F90@,$ac_ct_F90,;t t
11994 – s,@PREPFLAG@,$PREPFLAG,;t t
11995 – s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11996 – s,@F90LIBS@,$F90LIBS,;t t
11997 – s,@F90_FUNC@,$F90_FUNC,;t t
11998 – s,@F90_FUNC_@,$F90_FUNC_,;t t
11999 – s,@MOD@,$MOD,;t t
12000 – s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
12001 – s,@MODDIRFLAG@,$MODDIRFLAG,;t t
12002 – s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
12003 – s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
12004 – s,@CXXCPP@,$CXXCPP,;t t
12005 – s,@LIBOBJS@,$LIBOBJS,;t t
12006 – s,@__func__@,$__func__,;t t
12007 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12008 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12009 – s,@INSTALL_DATA@,$INSTALL_DATA,;t t
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
12014 – s,@YACC@,$YACC,;t t
12015 – s,@LEX@,$LEX,;t t
12016 – s,@LEXLIB@,$LEXLIB,;t t
12017 – s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046   s,@PERLINTERP@,$PERLINTERP,;t t
15047   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051   s,@AR@,$AR,;t t
15052   s,@PS@,$PS,;t t
15053 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056 + s,@FCLIBS@,$FCLIBS,;t t
15057 + s,@FC_FUNC@,$FC_FUNC,;t t
15058 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15059 + s,@MOD@,$MOD,;t t
15060 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064 + s,@LIBOBJS@,$LIBOBJS,;t t
15065 + s,@POW_LIB@,$POW_LIB,;t t
15066 + s,@CXXCPP@,$CXXCPP,;t t
15067 + s,@__func__@,$__func__,;t t
15068   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 12043 | 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
12046 – s,@FFLAGS@,$FFLAGS,;t t
15092   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093   CEOF
15094  

Diff Legend

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