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 811 by gezelter, Thu Dec 15 14:47:17 2005 UTC vs.
Revision 1197 by chuckv, Thu Dec 6 20:40:07 2007 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 4.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='4.0'
273 > PACKAGE_STRING='OOPSE 4.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX CPP EGREP OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug USE_SINGLE_PRECISION 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 ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_CXXFLAGS CGAL_LDFLAGS CGAL_CPPFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
764 ac_env_LDFLAGS_set=${LDFLAGS+set}
765 ac_env_LDFLAGS_value=$LDFLAGS
766 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 ac_cv_env_LDFLAGS_value=$LDFLAGS
768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 ac_env_CPPFLAGS_value=$CPPFLAGS
770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 + ac_env_LDFLAGS_set=${LDFLAGS+set}
765 + ac_env_LDFLAGS_value=$LDFLAGS
766 + ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 + ac_cv_env_LDFLAGS_value=$LDFLAGS
768 + ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 + ac_env_CPPFLAGS_value=$CPPFLAGS
770 + ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 + ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 + ac_env_CC_set=${CC+set}
773 + ac_env_CC_value=$CC
774 + ac_cv_env_CC_set=${CC+set}
775 + ac_cv_env_CC_value=$CC
776 + ac_env_CFLAGS_set=${CFLAGS+set}
777 + ac_env_CFLAGS_value=$CFLAGS
778 + ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 + ac_cv_env_CFLAGS_value=$CFLAGS
780 + ac_env_FC_set=${FC+set}
781 + ac_env_FC_value=$FC
782 + ac_cv_env_FC_set=${FC+set}
783 + ac_cv_env_FC_value=$FC
784 + ac_env_FCFLAGS_set=${FCFLAGS+set}
785 + ac_env_FCFLAGS_value=$FCFLAGS
786 + ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 + ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 ac_env_F90_set=${F90+set}
785 ac_env_F90_value=$F90
786 ac_cv_env_F90_set=${F90+set}
787 ac_cv_env_F90_value=$F90
788 ac_env_F90FLAGS_set=${F90FLAGS+set}
789 ac_env_F90FLAGS_value=$F90FLAGS
790 ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 4.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 4.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-single         compile OOPSE in single precision
875 +  --enable-float          synonym for --enable-single
876    --enable-doxygen        enable documentation generation with doxygen (auto)
877    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
878    --enable-html-docs      enable HTML generation with doxygen (yes)
879    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880  
881   Optional Packages:
882    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882  --with-zlib=DIR root directory path of zlib installation defaults to
883                    /usr/local or /usr if not found in /usr/local
884  --without-zlib to disable zlib usage completely
884    --with-perl-shebang     override what perl thinks is the way for the kernel
885                            to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891 <  --with-cgal-makefile=FILE  CGAL makefile that should be used
891 >  --with-cgalmakefile=makefile
892 >                          Use the following CGAL makefile
893  
894   Some influential environment variables:
895 <  CC          C compiler command
896 <  CFLAGS      C compiler flags
895 >  CXX         C++ compiler command
896 >  CXXFLAGS    C++ compiler flags
897    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
898                nonstandard directory <lib dir>
899    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
900                headers in a nonstandard directory <include dir>
901 <  CXX         C++ compiler command
902 <  CXXFLAGS    C++ compiler flags
901 >  CC          C compiler command
902 >  CFLAGS      C compiler flags
903 >  FC          Fortran compiler command
904 >  FCFLAGS     Fortran compiler flags
905    CPP         C preprocessor
900  F90         Fortran 90 compiler command
901  F90FLAGS    Fortran 90 compiler flags
906    CXXCPP      C++ preprocessor
907  
908   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1004 | if $ac_init_version; then
1004   test -n "$ac_init_help" && exit 0
1005   if $ac_init_version; then
1006    cat <<\_ACEOF
1007 < OOPSE configure 2.0
1007 > OOPSE configure 4.0
1008   generated by GNU Autoconf 2.59
1009  
1010   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1018 | running configure, to aid debugging if configure makes
1018   This file contains any messages produced by compilers while
1019   running configure, to aid debugging if configure makes a mistake.
1020  
1021 < It was created by OOPSE $as_me 2.0, which was
1021 > It was created by OOPSE $as_me 4.0, which was
1022   generated by GNU Autoconf 2.59.  Invocation command line was
1023  
1024    $ $0 $@
# Line 1376 | Line 1380 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1380   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1381  
1382  
1383 < # 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).
1383 >          ac_config_headers="$ac_config_headers src/config.h"
1384  
1385  
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
1386  
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
1387  
1388  
1389  
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
1390  
1391  
1392  
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1393  
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1394  
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1395  
1396  
1397  
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1398  
1399  
1400  
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1401  
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1402  
1403  
1404  
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1405  
1406  
1407  
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1408  
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1409  
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1410  
1411  
1412  
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1413  
1414  
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1415  
1416  
1417  
1553 # ------------------------ #
1554 # 2c. Fortran 95 sources.  #
1555 # ------------------------ #
1418  
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1419  
1420  
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1421  
1422  
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1423  
1424  
1425  
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1426  
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1427  
1578
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1582
1583
1584
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1589
1590
1591
1592 # AC_PROG_F90([COMPILERS...])
1593 # ---------------------------
1594 # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 # for.
1428   #
1597 # Compilers are ordered by
1598 #  1. F90, F95
1599 #  2. Good/tested native compilers, bad/untested native compilers
1429   #
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
1607
1608
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1612
1613
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1617
1618
1619
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1624
1625
1626
1627 # AC_PROG_F95([COMPILERS...])
1628 # ---------------------------
1629 # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 # for.
1430   #
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
1431  
1432  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1433  
1434  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1435  
1436  
1437 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1438 < # -------------------------------------------------
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
1660 <
1661 <
1662 < # _AC_PROG_F90_V
1663 < # --------------
1437 > # AC_F90_MODULE_NAMES
1438 > # -------------------
1439   #
1440 < # 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
1670 <
1671 <
1672 < # AC_F90_LIBRARY_LDFLAGS
1673 < # ----------------------
1440 > # Figure out how the Fortran 90 compiler constructs module file names
1441   #
1442 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 < # intrinsic and run-time libraries that are required to successfully
1677 < # link a Fortran 90 program or shared library.  The output variable
1678 < # F90LIBS is set to these flags.
1679 < #
1680 < # This macro is intended to be used in those situations when it is
1681 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 < # program or shared library.
1683 < #
1684 < # For example, if object files from a C++ and Fortran 90 compiler must
1685 < # be linked together, then the C++ compiler/linker must be used for
1686 < # linking (since special C++-ish things need to happen at link time
1687 < # like calling global constructors, instantiating templates, enabling
1688 < # exception support, etc.).
1689 < #
1690 < # However, the Fortran 90 intrinsic and run-time libraries must be
1691 < # linked in as well, but the C++ compiler/linker doesn't know how to
1692 < # add these Fortran 90 libraries.  Hence, the macro
1693 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 < # libraries.
1695 < #
1696 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 < # AC_F90_LIBRARY_LDFLAGS
1442 > # AC_F90_MODULE_NAMES
1443  
1444  
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
1445  
1717 # The replacement is empty.
1446  
1447  
1448  
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
1449  
1450  
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
1451  
1452  
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1453  
1454  
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
1455  
1456  
1754 # _AC_PROG_F95_V
1755 # --------------
1756 #
1757 # Determine the flag that causes the Fortran 95 compiler to print
1758 # information of library and object files (normally -v)
1759 # Needed for AC_F95_LIBRARY_FLAGS
1760 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 # _AC_PROG_F95_V
1457  
1458  
1764 # AC_F95_LIBRARY_LDFLAGS
1765 # ----------------------
1766 #
1767 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 # intrinsic and run-time libraries that are required to successfully
1769 # link a Fortran 95 program or shared library.  The output variable
1770 # F95LIBS is set to these flags.
1771 #
1772 # This macro is intended to be used in those situations when it is
1773 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 # program or shared library.
1775 #
1776 # For example, if object files from a C++ and Fortran 95 compiler must
1777 # be linked together, then the C++ compiler/linker must be used for
1778 # linking (since special C++-ish things need to happen at link time
1779 # like calling global constructors, instantiating templates, enabling
1780 # exception support, etc.).
1781 #
1782 # However, the Fortran 95 intrinsic and run-time libraries must be
1783 # linked in as well, but the C++ compiler/linker doesn't know how to
1784 # add these Fortran 95 libraries.  Hence, the macro
1785 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 # libraries.
1787 #
1788 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 # AC_F95_LIBRARY_LDFLAGS
1459  
1460  
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
1461  
1809 # The replacement is empty.
1462  
1463  
1464  
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
1465  
1466  
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
1467  
1829 # AC_F90_MODULE_NAMES
1830 # -------------------
1831 #
1832 # Figure out how the Fortran 90 compiler constructs module file names
1833 #
1834 # AC_F90_MODULE_NAMES
1468  
1469  
1470  
# Line 1885 | Line 1518 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1518  
1519  
1520  
1888 #
1889 #
1890 #
1521  
1522  
1523  
# Line 1919 | Line 1549 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1549  
1550  
1551  
1552 + # This is taken from http://autoqt.sourceforge.net/
1553 + # Copyright (c) 2002, Geoffrey Wossum
1554 + # All rights reserved.
1555  
1556 + # Redistribution and use in source and binary forms, with or without
1557 + # modification, are permitted provided that the following conditions are
1558 + # met:
1559  
1560 + #  - Redistributions of source code must retain the above copyright notice,
1561 + #    this list of conditions and the following disclaimer.
1562  
1563 + #  - Redistributions in binary form must reproduce the above copyright
1564 + #    notice, this list of conditions and the following disclaimer in the
1565 + #    documentation and/or other materials provided with the distribution.
1566  
1567 + #  - Neither the name of Geoffrey Wossum nor the names of its
1568 + #    contributors may be used to endorse or promote products derived from
1569 + #    this software without specific prior written permission.
1570  
1571  
1572 + # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1573 + # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
1574 + # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1575 + # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1576 + # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1577 + # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1578 + # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1579 + # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1580 + # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1581 + # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1582 + # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1583  
1584  
1585 + # Check for Qt compiler flags, linker flags, and binary packages
1586  
1587  
1588  
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
1589   # who am i
1590   # Make sure we can run config.sub.
1591   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 2011 | Line 1644 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1644  
1645  
1646  
1647 < ac_ext=c
1648 < ac_cpp='$CPP $CPPFLAGS'
1649 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1650 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1651 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1647 > # set program name
1648 > PROGNAME="oopse"
1649 >
1650 >
1651 >
1652 >
1653 > OBJEXT=".$OBJEXT"
1654 >
1655 > OOPSE=oopse
1656 >
1657 > if test "x${prefix}" = "xNONE"
1658 > then
1659 >  OOPSE_HOME=${ac_default_prefix}/oopse
1660 > else
1661 >  OOPSE_HOME=${prefix}/oopse
1662 > fi
1663 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1664 > if test "${enable_oopse_home+set}" = set; then
1665 >  enableval="$enable_oopse_home"
1666 >  OOPSE_HOME="${enableval}"
1667 > fi;
1668 >
1669 > # there are two ways to do debugging.  One with the --enable-debug flag
1670 > # and one using the DEBUG environment variable
1671 >
1672 > debug=0
1673 > # Check whether --enable-debug or --disable-debug was given.
1674 > if test "${enable_debug+set}" = set; then
1675 >  enableval="$enable_debug"
1676 >  debug=1
1677 > fi;
1678 > if test "${DEBUG}"; then
1679 >
1680 > cat >>confdefs.h <<\_ACEOF
1681 > #define debug 1
1682 > _ACEOF
1683 >
1684 >  msg="$msg, debug mode"
1685 > fi
1686 >
1687 >
1688 > # Check whether --enable-single or --disable-single was given.
1689 > if test "${enable_single+set}" = set; then
1690 >  enableval="$enable_single"
1691 >  ok=$enableval
1692 > else
1693 >  ok=no
1694 > fi;
1695 > # Check whether --enable-float or --disable-float was given.
1696 > if test "${enable_float+set}" = set; then
1697 >  enableval="$enable_float"
1698 >  ok=$enableval
1699 > fi;
1700 > if test "$ok" = "yes"; then
1701 >
1702 > cat >>confdefs.h <<\_ACEOF
1703 > #define SINGLE_PRECISION 1
1704 > _ACEOF
1705 >
1706 >        USE_SINGLE_PRECISION=yes
1707 >
1708 > fi
1709 >
1710 > # Checks for programs.
1711 > ac_ext=cc
1712 > ac_cpp='$CXXCPP $CPPFLAGS'
1713 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1714 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1715 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1716   if test -n "$ac_tool_prefix"; then
1717 <  for ac_prog in pathcc icc xlc gcc cc
1717 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1718    do
1719      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1720   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1721   echo "$as_me:$LINENO: checking for $ac_word" >&5
1722   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1723 < if test "${ac_cv_prog_CC+set}" = set; then
1723 > if test "${ac_cv_prog_CXX+set}" = set; then
1724    echo $ECHO_N "(cached) $ECHO_C" >&6
1725   else
1726 <  if test -n "$CC"; then
1727 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1726 >  if test -n "$CXX"; then
1727 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1728   else
1729   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1730   for as_dir in $PATH
# Line 2036 | Line 1733 | do
1733    test -z "$as_dir" && as_dir=.
1734    for ac_exec_ext in '' $ac_executable_extensions; do
1735    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1736 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1736 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1737      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1738      break 2
1739    fi
# Line 2045 | Line 1742 | fi
1742  
1743   fi
1744   fi
1745 < CC=$ac_cv_prog_CC
1746 < if test -n "$CC"; then
1747 <  echo "$as_me:$LINENO: result: $CC" >&5
1748 < echo "${ECHO_T}$CC" >&6
1745 > CXX=$ac_cv_prog_CXX
1746 > if test -n "$CXX"; then
1747 >  echo "$as_me:$LINENO: result: $CXX" >&5
1748 > echo "${ECHO_T}$CXX" >&6
1749   else
1750    echo "$as_me:$LINENO: result: no" >&5
1751   echo "${ECHO_T}no" >&6
1752   fi
1753  
1754 <    test -n "$CC" && break
1754 >    test -n "$CXX" && break
1755    done
1756   fi
1757 < if test -z "$CC"; then
1758 <  ac_ct_CC=$CC
1759 <  for ac_prog in pathcc icc xlc gcc cc
1757 > if test -z "$CXX"; then
1758 >  ac_ct_CXX=$CXX
1759 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1760   do
1761    # Extract the first word of "$ac_prog", so it can be a program name with args.
1762   set dummy $ac_prog; ac_word=$2
1763   echo "$as_me:$LINENO: checking for $ac_word" >&5
1764   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1765 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1765 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1766    echo $ECHO_N "(cached) $ECHO_C" >&6
1767   else
1768 <  if test -n "$ac_ct_CC"; then
1769 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1768 >  if test -n "$ac_ct_CXX"; then
1769 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1770   else
1771   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1772   for as_dir in $PATH
# Line 2078 | Line 1775 | do
1775    test -z "$as_dir" && as_dir=.
1776    for ac_exec_ext in '' $ac_executable_extensions; do
1777    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1778 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1778 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1779      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1780      break 2
1781    fi
# Line 2087 | Line 1784 | fi
1784  
1785   fi
1786   fi
1787 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1788 < if test -n "$ac_ct_CC"; then
1789 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1790 < echo "${ECHO_T}$ac_ct_CC" >&6
1787 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1788 > if test -n "$ac_ct_CXX"; then
1789 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1790 > echo "${ECHO_T}$ac_ct_CXX" >&6
1791   else
1792    echo "$as_me:$LINENO: result: no" >&5
1793   echo "${ECHO_T}no" >&6
1794   fi
1795  
1796 <  test -n "$ac_ct_CC" && break
1796 >  test -n "$ac_ct_CXX" && break
1797   done
1798 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1799  
1800 <  CC=$ac_ct_CC
1800 >  CXX=$ac_ct_CXX
1801   fi
1802  
1803  
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
1804   # Provide some information about the compiler.
1805   echo "$as_me:$LINENO:" \
1806 <     "checking for C compiler version" >&5
1806 >     "checking for C++ compiler version" >&5
1807   ac_compiler=`set X $ac_compile; echo $2`
1808   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1809    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2149 | Line 1841 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1841   # Try to create an executable without -o first, disregard a.out.
1842   # It will help us diagnose broken compilers, and finding out an intuition
1843   # of exeext.
1844 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1845 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1844 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1845 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1846   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1847   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1848    (eval $ac_link_default) 2>&5
# Line 2193 | Line 1885 | sed 's/^/| /' conftest.$ac_ext >&5
1885    echo "$as_me: failed program was:" >&5
1886   sed 's/^/| /' conftest.$ac_ext >&5
1887  
1888 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1888 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1889   See \`config.log' for more details." >&5
1890 < echo "$as_me: error: C compiler cannot create executables
1890 > echo "$as_me: error: C++ compiler cannot create executables
1891   See \`config.log' for more details." >&2;}
1892     { (exit 77); exit 77; }; }
1893   fi
# Line 2206 | Line 1898 | echo "${ECHO_T}$ac_file" >&6
1898  
1899   # Check the compiler produces executables we can run.  If not, either
1900   # the compiler is broken, or we cross compile.
1901 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1902 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1901 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1902 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1903   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1904   # If not cross compiling, check that we can run a simple program.
1905   if test "$cross_compiling" != yes; then
# Line 2222 | Line 1914 | if test "$cross_compiling" != yes; then
1914      if test "$cross_compiling" = maybe; then
1915          cross_compiling=yes
1916      else
1917 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1917 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1918   If you meant to cross compile, use \`--host'.
1919   See \`config.log' for more details." >&5
1920 < echo "$as_me: error: cannot run C compiled programs.
1920 > echo "$as_me: error: cannot run C++ compiled programs.
1921   If you meant to cross compile, use \`--host'.
1922   See \`config.log' for more details." >&2;}
1923     { (exit 1); exit 1; }; }
# Line 2330 | Line 2022 | ac_objext=$OBJEXT
2022   echo "${ECHO_T}$ac_cv_objext" >&6
2023   OBJEXT=$ac_cv_objext
2024   ac_objext=$OBJEXT
2025 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2026 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2027 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
2025 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2026 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2027 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2028    echo $ECHO_N "(cached) $ECHO_C" >&6
2029   else
2030    cat >conftest.$ac_ext <<_ACEOF
# Line 2362 | Line 2054 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2054    cat conftest.err >&5
2055    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2056    (exit $ac_status); } &&
2057 <         { ac_try='test -z "$ac_c_werror_flag"
2057 >         { ac_try='test -z "$ac_cxx_werror_flag"
2058                           || test ! -s conftest.err'
2059    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2060    (eval $ac_try) 2>&5
# Line 2383 | Line 2075 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2075   ac_compiler_gnu=no
2076   fi
2077   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2078 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
2078 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2079  
2080   fi
2081 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2082 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2083 < GCC=`test $ac_compiler_gnu = yes && echo yes`
2084 < ac_test_CFLAGS=${CFLAGS+set}
2085 < ac_save_CFLAGS=$CFLAGS
2086 < CFLAGS="-g"
2087 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2088 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2089 < if test "${ac_cv_prog_cc_g+set}" = set; then
2081 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2082 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2083 > GXX=`test $ac_compiler_gnu = yes && echo yes`
2084 > ac_test_CXXFLAGS=${CXXFLAGS+set}
2085 > ac_save_CXXFLAGS=$CXXFLAGS
2086 > CXXFLAGS="-g"
2087 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2088 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2089 > if test "${ac_cv_prog_cxx_g+set}" = set; then
2090    echo $ECHO_N "(cached) $ECHO_C" >&6
2091   else
2092    cat >conftest.$ac_ext <<_ACEOF
# Line 2421 | Line 2113 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2113    cat conftest.err >&5
2114    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2115    (exit $ac_status); } &&
2116 <         { ac_try='test -z "$ac_c_werror_flag"
2116 >         { ac_try='test -z "$ac_cxx_werror_flag"
2117                           || test ! -s conftest.err'
2118    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2119    (eval $ac_try) 2>&5
# Line 2434 | Line 2126 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2126    ac_status=$?
2127    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2128    (exit $ac_status); }; }; then
2129 <  ac_cv_prog_cc_g=yes
2129 >  ac_cv_prog_cxx_g=yes
2130   else
2131    echo "$as_me: failed program was:" >&5
2132   sed 's/^/| /' conftest.$ac_ext >&5
2133  
2134 < ac_cv_prog_cc_g=no
2134 > ac_cv_prog_cxx_g=no
2135   fi
2136   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2137   fi
2138 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2139 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2140 < if test "$ac_test_CFLAGS" = set; then
2141 <  CFLAGS=$ac_save_CFLAGS
2142 < elif test $ac_cv_prog_cc_g = yes; then
2143 <  if test "$GCC" = yes; then
2144 <    CFLAGS="-g -O2"
2138 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2139 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2140 > if test "$ac_test_CXXFLAGS" = set; then
2141 >  CXXFLAGS=$ac_save_CXXFLAGS
2142 > elif test $ac_cv_prog_cxx_g = yes; then
2143 >  if test "$GXX" = yes; then
2144 >    CXXFLAGS="-g -O2"
2145    else
2146 <    CFLAGS="-g"
2146 >    CXXFLAGS="-g"
2147    fi
2148   else
2149 <  if test "$GCC" = yes; then
2150 <    CFLAGS="-O2"
2149 >  if test "$GXX" = yes; then
2150 >    CXXFLAGS="-O2"
2151    else
2152 <    CFLAGS=
2152 >    CXXFLAGS=
2153    fi
2154   fi
2155 < 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 \
2155 > for ac_declaration in \
2156     '' \
2157     'extern "C" void std::exit (int) throw (); using std::exit;' \
2158     'extern "C" void std::exit (int); using std::exit;' \
# Line 2639 | Line 2185 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2185    cat conftest.err >&5
2186    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2187    (exit $ac_status); } &&
2188 <         { ac_try='test -z "$ac_c_werror_flag"
2188 >         { ac_try='test -z "$ac_cxx_werror_flag"
2189                           || test ! -s conftest.err'
2190    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2191    (eval $ac_try) 2>&5
# Line 2684 | Line 2230 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2230    cat conftest.err >&5
2231    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2232    (exit $ac_status); } &&
2233 <         { ac_try='test -z "$ac_c_werror_flag"
2233 >         { ac_try='test -z "$ac_cxx_werror_flag"
2234                           || test ! -s conftest.err'
2235    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2236    (eval $ac_try) 2>&5
# Line 2712 | Line 2258 | fi
2258    echo '#endif'             >>confdefs.h
2259   fi
2260  
2715 else
2716  echo "$as_me: failed program was:" >&5
2717 sed 's/^/| /' conftest.$ac_ext >&5
2718
2719 fi
2720 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2261   ac_ext=c
2262   ac_cpp='$CPP $CPPFLAGS'
2263   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2264   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2265   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2266  
2267 <
2268 < ac_ext=cc
2269 < ac_cpp='$CXXCPP $CPPFLAGS'
2270 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2271 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2732 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2267 > ac_ext=c
2268 > ac_cpp='$CPP $CPPFLAGS'
2269 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2270 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2271 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2272   if test -n "$ac_tool_prefix"; then
2273 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2273 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2274    do
2275      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2276   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2277   echo "$as_me:$LINENO: checking for $ac_word" >&5
2278   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2279 < if test "${ac_cv_prog_CXX+set}" = set; then
2279 > if test "${ac_cv_prog_CC+set}" = set; then
2280    echo $ECHO_N "(cached) $ECHO_C" >&6
2281   else
2282 <  if test -n "$CXX"; then
2283 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2282 >  if test -n "$CC"; then
2283 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2284   else
2285   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2286   for as_dir in $PATH
# Line 2750 | Line 2289 | do
2289    test -z "$as_dir" && as_dir=.
2290    for ac_exec_ext in '' $ac_executable_extensions; do
2291    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2292 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2292 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2293      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2294      break 2
2295    fi
# Line 2759 | Line 2298 | fi
2298  
2299   fi
2300   fi
2301 < CXX=$ac_cv_prog_CXX
2302 < if test -n "$CXX"; then
2303 <  echo "$as_me:$LINENO: result: $CXX" >&5
2304 < echo "${ECHO_T}$CXX" >&6
2301 > CC=$ac_cv_prog_CC
2302 > if test -n "$CC"; then
2303 >  echo "$as_me:$LINENO: result: $CC" >&5
2304 > echo "${ECHO_T}$CC" >&6
2305   else
2306    echo "$as_me:$LINENO: result: no" >&5
2307   echo "${ECHO_T}no" >&6
2308   fi
2309  
2310 <    test -n "$CXX" && break
2310 >    test -n "$CC" && break
2311    done
2312   fi
2313 < if test -z "$CXX"; then
2314 <  ac_ct_CXX=$CXX
2315 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2313 > if test -z "$CC"; then
2314 >  ac_ct_CC=$CC
2315 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2316   do
2317    # Extract the first word of "$ac_prog", so it can be a program name with args.
2318   set dummy $ac_prog; ac_word=$2
2319   echo "$as_me:$LINENO: checking for $ac_word" >&5
2320   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2321 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2321 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2322    echo $ECHO_N "(cached) $ECHO_C" >&6
2323   else
2324 <  if test -n "$ac_ct_CXX"; then
2325 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2324 >  if test -n "$ac_ct_CC"; then
2325 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2326   else
2327   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2328   for as_dir in $PATH
# Line 2792 | Line 2331 | do
2331    test -z "$as_dir" && as_dir=.
2332    for ac_exec_ext in '' $ac_executable_extensions; do
2333    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2334 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2334 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2335      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2336      break 2
2337    fi
# Line 2801 | Line 2340 | fi
2340  
2341   fi
2342   fi
2343 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2344 < if test -n "$ac_ct_CXX"; then
2345 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2346 < echo "${ECHO_T}$ac_ct_CXX" >&6
2343 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2344 > if test -n "$ac_ct_CC"; then
2345 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2346 > echo "${ECHO_T}$ac_ct_CC" >&6
2347   else
2348    echo "$as_me:$LINENO: result: no" >&5
2349   echo "${ECHO_T}no" >&6
2350   fi
2351  
2352 <  test -n "$ac_ct_CXX" && break
2352 >  test -n "$ac_ct_CC" && break
2353   done
2815 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2354  
2355 <  CXX=$ac_ct_CXX
2355 >  CC=$ac_ct_CC
2356   fi
2357  
2358  
2359 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2360 + See \`config.log' for more details." >&5
2361 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2362 + See \`config.log' for more details." >&2;}
2363 +   { (exit 1); exit 1; }; }
2364 +
2365   # Provide some information about the compiler.
2366   echo "$as_me:$LINENO:" \
2367 <     "checking for C++ compiler version" >&5
2367 >     "checking for C compiler version" >&5
2368   ac_compiler=`set X $ac_compile; echo $2`
2369   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2370    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2838 | Line 2382 | ac_compiler=`set X $ac_compile; echo $2`
2382    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2383    (exit $ac_status); }
2384  
2385 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2386 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2387 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2385 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2386 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2387 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2388    echo $ECHO_N "(cached) $ECHO_C" >&6
2389   else
2390    cat >conftest.$ac_ext <<_ACEOF
# Line 2870 | Line 2414 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2414    cat conftest.err >&5
2415    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2416    (exit $ac_status); } &&
2417 <         { ac_try='test -z "$ac_cxx_werror_flag"
2417 >         { ac_try='test -z "$ac_c_werror_flag"
2418                           || test ! -s conftest.err'
2419    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2420    (eval $ac_try) 2>&5
# Line 2891 | Line 2435 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2435   ac_compiler_gnu=no
2436   fi
2437   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2438 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2438 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2439  
2440   fi
2441 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2442 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2443 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2444 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2445 < ac_save_CXXFLAGS=$CXXFLAGS
2446 < CXXFLAGS="-g"
2447 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2448 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2449 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2441 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2442 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2443 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2444 > ac_test_CFLAGS=${CFLAGS+set}
2445 > ac_save_CFLAGS=$CFLAGS
2446 > CFLAGS="-g"
2447 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2448 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2449 > if test "${ac_cv_prog_cc_g+set}" = set; then
2450    echo $ECHO_N "(cached) $ECHO_C" >&6
2451   else
2452    cat >conftest.$ac_ext <<_ACEOF
# Line 2929 | Line 2473 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2473    cat conftest.err >&5
2474    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2475    (exit $ac_status); } &&
2476 <         { ac_try='test -z "$ac_cxx_werror_flag"
2476 >         { ac_try='test -z "$ac_c_werror_flag"
2477                           || test ! -s conftest.err'
2478    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2479    (eval $ac_try) 2>&5
# Line 2942 | Line 2486 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2486    ac_status=$?
2487    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2488    (exit $ac_status); }; }; then
2489 <  ac_cv_prog_cxx_g=yes
2489 >  ac_cv_prog_cc_g=yes
2490   else
2491    echo "$as_me: failed program was:" >&5
2492   sed 's/^/| /' conftest.$ac_ext >&5
2493  
2494 < ac_cv_prog_cxx_g=no
2494 > ac_cv_prog_cc_g=no
2495   fi
2496   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2497   fi
2498 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2499 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2500 < if test "$ac_test_CXXFLAGS" = set; then
2501 <  CXXFLAGS=$ac_save_CXXFLAGS
2502 < elif test $ac_cv_prog_cxx_g = yes; then
2503 <  if test "$GXX" = yes; then
2504 <    CXXFLAGS="-g -O2"
2498 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2499 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2500 > if test "$ac_test_CFLAGS" = set; then
2501 >  CFLAGS=$ac_save_CFLAGS
2502 > elif test $ac_cv_prog_cc_g = yes; then
2503 >  if test "$GCC" = yes; then
2504 >    CFLAGS="-g -O2"
2505    else
2506 <    CXXFLAGS="-g"
2506 >    CFLAGS="-g"
2507    fi
2508   else
2509 <  if test "$GXX" = yes; then
2510 <    CXXFLAGS="-O2"
2509 >  if test "$GCC" = yes; then
2510 >    CFLAGS="-O2"
2511    else
2512 <    CXXFLAGS=
2512 >    CFLAGS=
2513    fi
2514   fi
2515 < for ac_declaration in \
2516 <   '' \
2517 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2518 <   'extern "C" void std::exit (int); using std::exit;' \
2519 <   'extern "C" void exit (int) throw ();' \
2520 <   'extern "C" void exit (int);' \
2521 <   'void exit (int);'
2522 < do
2979 <  cat >conftest.$ac_ext <<_ACEOF
2515 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2516 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2517 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2518 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2519 > else
2520 >  ac_cv_prog_cc_stdc=no
2521 > ac_save_CC=$CC
2522 > cat >conftest.$ac_ext <<_ACEOF
2523   /* confdefs.h.  */
2524   _ACEOF
2525   cat confdefs.h >>conftest.$ac_ext
2526   cat >>conftest.$ac_ext <<_ACEOF
2527   /* end confdefs.h.  */
2528 < $ac_declaration
2529 < #include <stdlib.h>
2530 < int
2531 < main ()
2528 > #include <stdarg.h>
2529 > #include <stdio.h>
2530 > #include <sys/types.h>
2531 > #include <sys/stat.h>
2532 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2533 > struct buf { int x; };
2534 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2535 > static char *e (p, i)
2536 >     char **p;
2537 >     int i;
2538   {
2539 +  return p[i];
2540 + }
2541 + static char *f (char * (*g) (char **, int), char **p, ...)
2542 + {
2543 +  char *s;
2544 +  va_list v;
2545 +  va_start (v,p);
2546 +  s = g (p, va_arg (v,int));
2547 +  va_end (v);
2548 +  return s;
2549 + }
2550 +
2551 + /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2552 +   function prototypes and stuff, but not '\xHH' hex character constants.
2553 +   These don't provoke an error unfortunately, instead are silently treated
2554 +   as 'x'.  The following induces an error, until -std1 is added to get
2555 +   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2556 +   array size at least.  It's necessary to write '\x00'==0 to get something
2557 +   that's true only with -std1.  */
2558 + int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2559 +
2560 + int test (int i, double x);
2561 + struct s1 {int (*f) (int a);};
2562 + struct s2 {int (*f) (double a);};
2563 + int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2564 + int argc;
2565 + char **argv;
2566 + int
2567 + main ()
2568 + {
2569 + return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2570 +  ;
2571 +  return 0;
2572 + }
2573 + _ACEOF
2574 + # Don't try gcc -ansi; that turns off useful extensions and
2575 + # breaks some systems' header files.
2576 + # AIX                   -qlanglvl=ansi
2577 + # Ultrix and OSF/1      -std1
2578 + # HP-UX 10.20 and later -Ae
2579 + # HP-UX older versions  -Aa -D_HPUX_SOURCE
2580 + # SVR4                  -Xc -D__EXTENSIONS__
2581 + for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2582 + do
2583 +  CC="$ac_save_CC $ac_arg"
2584 +  rm -f conftest.$ac_objext
2585 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2586 +  (eval $ac_compile) 2>conftest.er1
2587 +  ac_status=$?
2588 +  grep -v '^ *+' conftest.er1 >conftest.err
2589 +  rm -f conftest.er1
2590 +  cat conftest.err >&5
2591 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2592 +  (exit $ac_status); } &&
2593 +         { ac_try='test -z "$ac_c_werror_flag"
2594 +                         || test ! -s conftest.err'
2595 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2596 +  (eval $ac_try) 2>&5
2597 +  ac_status=$?
2598 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2599 +  (exit $ac_status); }; } &&
2600 +         { ac_try='test -s conftest.$ac_objext'
2601 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2602 +  (eval $ac_try) 2>&5
2603 +  ac_status=$?
2604 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2605 +  (exit $ac_status); }; }; then
2606 +  ac_cv_prog_cc_stdc=$ac_arg
2607 + break
2608 + else
2609 +  echo "$as_me: failed program was:" >&5
2610 + sed 's/^/| /' conftest.$ac_ext >&5
2611 +
2612 + fi
2613 + rm -f conftest.err conftest.$ac_objext
2614 + done
2615 + rm -f conftest.$ac_ext conftest.$ac_objext
2616 + CC=$ac_save_CC
2617 +
2618 + fi
2619 +
2620 + case "x$ac_cv_prog_cc_stdc" in
2621 +  x|xno)
2622 +    echo "$as_me:$LINENO: result: none needed" >&5
2623 + echo "${ECHO_T}none needed" >&6 ;;
2624 +  *)
2625 +    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2626 + echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2627 +    CC="$CC $ac_cv_prog_cc_stdc" ;;
2628 + esac
2629 +
2630 + # Some people use a C++ compiler to compile C.  Since we use `exit',
2631 + # in C++ we need to declare it.  In case someone uses the same compiler
2632 + # for both compiling C and C++ we need to have the C++ compiler decide
2633 + # the declaration of exit, since it's the most demanding environment.
2634 + cat >conftest.$ac_ext <<_ACEOF
2635 + #ifndef __cplusplus
2636 +  choke me
2637 + #endif
2638 + _ACEOF
2639 + rm -f conftest.$ac_objext
2640 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2641 +  (eval $ac_compile) 2>conftest.er1
2642 +  ac_status=$?
2643 +  grep -v '^ *+' conftest.er1 >conftest.err
2644 +  rm -f conftest.er1
2645 +  cat conftest.err >&5
2646 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2647 +  (exit $ac_status); } &&
2648 +         { ac_try='test -z "$ac_c_werror_flag"
2649 +                         || test ! -s conftest.err'
2650 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2651 +  (eval $ac_try) 2>&5
2652 +  ac_status=$?
2653 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2654 +  (exit $ac_status); }; } &&
2655 +         { ac_try='test -s conftest.$ac_objext'
2656 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2657 +  (eval $ac_try) 2>&5
2658 +  ac_status=$?
2659 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2660 +  (exit $ac_status); }; }; then
2661 +  for ac_declaration in \
2662 +   '' \
2663 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2664 +   'extern "C" void std::exit (int); using std::exit;' \
2665 +   'extern "C" void exit (int) throw ();' \
2666 +   'extern "C" void exit (int);' \
2667 +   'void exit (int);'
2668 + do
2669 +  cat >conftest.$ac_ext <<_ACEOF
2670 + /* confdefs.h.  */
2671 + _ACEOF
2672 + cat confdefs.h >>conftest.$ac_ext
2673 + cat >>conftest.$ac_ext <<_ACEOF
2674 + /* end confdefs.h.  */
2675 + $ac_declaration
2676 + #include <stdlib.h>
2677 + int
2678 + main ()
2679 + {
2680   exit (42);
2681    ;
2682    return 0;
# Line 3001 | Line 2691 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2691    cat conftest.err >&5
2692    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2693    (exit $ac_status); } &&
2694 <         { ac_try='test -z "$ac_cxx_werror_flag"
2694 >         { ac_try='test -z "$ac_c_werror_flag"
2695                           || test ! -s conftest.err'
2696    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2697    (eval $ac_try) 2>&5
# Line 3046 | Line 2736 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2736    cat conftest.err >&5
2737    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2738    (exit $ac_status); } &&
2739 <         { ac_try='test -z "$ac_cxx_werror_flag"
2739 >         { ac_try='test -z "$ac_c_werror_flag"
2740                           || test ! -s conftest.err'
2741    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2742    (eval $ac_try) 2>&5
# Line 3074 | Line 2764 | fi
2764    echo '#endif'             >>confdefs.h
2765   fi
2766  
2767 + else
2768 +  echo "$as_me: failed program was:" >&5
2769 + sed 's/^/| /' conftest.$ac_ext >&5
2770 +
2771 + fi
2772 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2773   ac_ext=c
2774   ac_cpp='$CPP $CPPFLAGS'
2775   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2776   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2777   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2778 +
2779 + ac_ext=${FC_SRCEXT-f}
2780 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2781 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2782 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2783 + if test -n "$ac_tool_prefix"; then
2784 +  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2785 +  do
2786 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2787 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2788 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2789 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2790 + if test "${ac_cv_prog_FC+set}" = set; then
2791 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2792 + else
2793 +  if test -n "$FC"; then
2794 +  ac_cv_prog_FC="$FC" # Let the user override the test.
2795 + else
2796 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2797 + for as_dir in $PATH
2798 + do
2799 +  IFS=$as_save_IFS
2800 +  test -z "$as_dir" && as_dir=.
2801 +  for ac_exec_ext in '' $ac_executable_extensions; do
2802 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2803 +    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2804 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2805 +    break 2
2806 +  fi
2807 + done
2808 + done
2809 +
2810 + fi
2811 + fi
2812 + FC=$ac_cv_prog_FC
2813 + if test -n "$FC"; then
2814 +  echo "$as_me:$LINENO: result: $FC" >&5
2815 + echo "${ECHO_T}$FC" >&6
2816 + else
2817 +  echo "$as_me:$LINENO: result: no" >&5
2818 + echo "${ECHO_T}no" >&6
2819 + fi
2820 +
2821 +    test -n "$FC" && break
2822 +  done
2823 + fi
2824 + if test -z "$FC"; then
2825 +  ac_ct_FC=$FC
2826 +  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2827 + do
2828 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2829 + set dummy $ac_prog; ac_word=$2
2830 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2831 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2832 + if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2833 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2834 + else
2835 +  if test -n "$ac_ct_FC"; then
2836 +  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2837 + else
2838 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2839 + for as_dir in $PATH
2840 + do
2841 +  IFS=$as_save_IFS
2842 +  test -z "$as_dir" && as_dir=.
2843 +  for ac_exec_ext in '' $ac_executable_extensions; do
2844 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2845 +    ac_cv_prog_ac_ct_FC="$ac_prog"
2846 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2847 +    break 2
2848 +  fi
2849 + done
2850 + done
2851 +
2852 + fi
2853 + fi
2854 + ac_ct_FC=$ac_cv_prog_ac_ct_FC
2855 + if test -n "$ac_ct_FC"; then
2856 +  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2857 + echo "${ECHO_T}$ac_ct_FC" >&6
2858 + else
2859 +  echo "$as_me:$LINENO: result: no" >&5
2860 + echo "${ECHO_T}no" >&6
2861 + fi
2862 +
2863 +  test -n "$ac_ct_FC" && break
2864 + done
2865 +
2866 +  FC=$ac_ct_FC
2867 + fi
2868 +
2869 +
2870 + # Provide some information about the compiler.
2871 + echo "$as_me:2871:" \
2872 +     "checking for Fortran compiler version" >&5
2873 + ac_compiler=`set X $ac_compile; echo $2`
2874 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2875 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2876 +  ac_status=$?
2877 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2878 +  (exit $ac_status); }
2879 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2880 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2881 +  ac_status=$?
2882 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883 +  (exit $ac_status); }
2884 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2885 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2886 +  ac_status=$?
2887 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888 +  (exit $ac_status); }
2889 + rm -f a.out
2890  
2891 + # If we don't use `.F' as extension, the preprocessor is not run on the
2892 + # input file.  (Note that this only needs to work for GNU compilers.)
2893 + ac_save_ext=$ac_ext
2894 + ac_ext=F
2895 + echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2896 + echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2897 + if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2898 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2899 + else
2900 +  cat >conftest.$ac_ext <<_ACEOF
2901 +      program main
2902 + #ifndef __GNUC__
2903 +       choke me
2904 + #endif
2905  
2906 +      end
2907 + _ACEOF
2908 + rm -f conftest.$ac_objext
2909 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2910 +  (eval $ac_compile) 2>conftest.er1
2911 +  ac_status=$?
2912 +  grep -v '^ *+' conftest.er1 >conftest.err
2913 +  rm -f conftest.er1
2914 +  cat conftest.err >&5
2915 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2916 +  (exit $ac_status); } &&
2917 +         { ac_try='test -z "$ac_fc_werror_flag"
2918 +                         || test ! -s conftest.err'
2919 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2920 +  (eval $ac_try) 2>&5
2921 +  ac_status=$?
2922 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2923 +  (exit $ac_status); }; } &&
2924 +         { ac_try='test -s conftest.$ac_objext'
2925 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2926 +  (eval $ac_try) 2>&5
2927 +  ac_status=$?
2928 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2929 +  (exit $ac_status); }; }; then
2930 +  ac_compiler_gnu=yes
2931 + else
2932 +  echo "$as_me: failed program was:" >&5
2933 + sed 's/^/| /' conftest.$ac_ext >&5
2934 +
2935 + ac_compiler_gnu=no
2936 + fi
2937 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2938 + ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2939 +
2940 + fi
2941 + echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2942 + echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2943 + ac_ext=$ac_save_ext
2944 + ac_test_FFLAGS=${FCFLAGS+set}
2945 + ac_save_FFLAGS=$FCFLAGS
2946 + FCFLAGS=
2947 + echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2948 + echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2949 + if test "${ac_cv_prog_fc_g+set}" = set; then
2950 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2951 + else
2952 +  FCFLAGS=-g
2953 + cat >conftest.$ac_ext <<_ACEOF
2954 +      program main
2955 +
2956 +      end
2957 + _ACEOF
2958 + rm -f conftest.$ac_objext
2959 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2960 +  (eval $ac_compile) 2>conftest.er1
2961 +  ac_status=$?
2962 +  grep -v '^ *+' conftest.er1 >conftest.err
2963 +  rm -f conftest.er1
2964 +  cat conftest.err >&5
2965 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2966 +  (exit $ac_status); } &&
2967 +         { ac_try='test -z "$ac_fc_werror_flag"
2968 +                         || test ! -s conftest.err'
2969 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2970 +  (eval $ac_try) 2>&5
2971 +  ac_status=$?
2972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2973 +  (exit $ac_status); }; } &&
2974 +         { ac_try='test -s conftest.$ac_objext'
2975 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2976 +  (eval $ac_try) 2>&5
2977 +  ac_status=$?
2978 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2979 +  (exit $ac_status); }; }; then
2980 +  ac_cv_prog_fc_g=yes
2981 + else
2982 +  echo "$as_me: failed program was:" >&5
2983 + sed 's/^/| /' conftest.$ac_ext >&5
2984 +
2985 + ac_cv_prog_fc_g=no
2986 + fi
2987 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2988 +
2989 + fi
2990 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2991 + echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2992 + if test "$ac_test_FFLAGS" = set; then
2993 +  FCFLAGS=$ac_save_FFLAGS
2994 + elif test $ac_cv_prog_fc_g = yes; then
2995 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2996 +    FCFLAGS="-g -O2"
2997 +  else
2998 +    FCFLAGS="-g"
2999 +  fi
3000 + else
3001 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3002 +    FCFLAGS="-O2"
3003 +  else
3004 +    FCFLAGS=
3005 +  fi
3006 + fi
3007 +
3008   ac_ext=c
3009   ac_cpp='$CPP $CPPFLAGS'
3010   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3011   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3012   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3013 +
3014 + ac_ext=c
3015 + ac_cpp='$CPP $CPPFLAGS'
3016 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3017 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3018 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
3019   echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
3020   echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
3021   # On Suns, sometimes $CPP names a directory.
# Line 3315 | Line 3245 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3245   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3246   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3247  
3318
3248   echo "$as_me:$LINENO: checking for egrep" >&5
3249   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3250   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3331 | Line 3260 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3260   EGREP=$ac_cv_prog_egrep
3261  
3262  
3263 + echo "$as_me:$LINENO: checking whether ln -s works" >&5
3264 + echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3265 + LN_S=$as_ln_s
3266 + if test "$LN_S" = "ln -s"; then
3267 +  echo "$as_me:$LINENO: result: yes" >&5
3268 + echo "${ECHO_T}yes" >&6
3269 + else
3270 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3271 + echo "${ECHO_T}no, using $LN_S" >&6
3272 + fi
3273  
3274 < OOPSE_TEMPLATE_FLAGS=""
3275 < if test $ac_cv_cxx_compiler_gnu = no; then
3276 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3277 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3278 <  echo 'void f(){}' > conftest.cc
3279 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3280 <    echo "$as_me:$LINENO: result: yes" >&5
3274 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3275 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3276 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3277 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3278 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3279 > else
3280 >  cat >conftest.make <<\_ACEOF
3281 > all:
3282 >        @echo 'ac_maketemp="$(MAKE)"'
3283 > _ACEOF
3284 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3285 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3286 > if test -n "$ac_maketemp"; then
3287 >  eval ac_cv_prog_make_${ac_make}_set=yes
3288 > else
3289 >  eval ac_cv_prog_make_${ac_make}_set=no
3290 > fi
3291 > rm -f conftest.make
3292 > fi
3293 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3294 >  echo "$as_me:$LINENO: result: yes" >&5
3295   echo "${ECHO_T}yes" >&6
3296 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3297 <  else
3298 <    echo "$as_me:$LINENO: result: no" >&5
3296 >  SET_MAKE=
3297 > else
3298 >  echo "$as_me:$LINENO: result: no" >&5
3299   echo "${ECHO_T}no" >&6
3300 +  SET_MAKE="MAKE=${MAKE-make}"
3301 + fi
3302 +
3303 + if test -n "$ac_tool_prefix"; then
3304 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3305 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3306 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3307 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3308 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3309 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3310 + else
3311 +  if test -n "$RANLIB"; then
3312 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3313 + else
3314 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3315 + for as_dir in $PATH
3316 + do
3317 +  IFS=$as_save_IFS
3318 +  test -z "$as_dir" && as_dir=.
3319 +  for ac_exec_ext in '' $ac_executable_extensions; do
3320 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3321 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3322 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3323 +    break 2
3324    fi
3325 <  rm -f conftest*
3326 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3327 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3328 <  echo 'void f(){}' > conftest.cc
3329 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3330 <    echo "$as_me:$LINENO: result: yes" >&5
3331 < echo "${ECHO_T}yes" >&6
3332 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3333 <  else
3334 <    echo "$as_me:$LINENO: result: no" >&5
3325 > done
3326 > done
3327 >
3328 > fi
3329 > fi
3330 > RANLIB=$ac_cv_prog_RANLIB
3331 > if test -n "$RANLIB"; then
3332 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3333 > echo "${ECHO_T}$RANLIB" >&6
3334 > else
3335 >  echo "$as_me:$LINENO: result: no" >&5
3336   echo "${ECHO_T}no" >&6
3337 + fi
3338 +
3339 + fi
3340 + if test -z "$ac_cv_prog_RANLIB"; then
3341 +  ac_ct_RANLIB=$RANLIB
3342 +  # Extract the first word of "ranlib", so it can be a program name with args.
3343 + set dummy ranlib; ac_word=$2
3344 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3345 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3346 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3347 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3348 + else
3349 +  if test -n "$ac_ct_RANLIB"; then
3350 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3351 + else
3352 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3353 + for as_dir in $PATH
3354 + do
3355 +  IFS=$as_save_IFS
3356 +  test -z "$as_dir" && as_dir=.
3357 +  for ac_exec_ext in '' $ac_executable_extensions; do
3358 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3359 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3360 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3361 +    break 2
3362    fi
3363 <  rm -f conftest*
3364 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3365 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3366 <  echo 'void f(){}' > conftest.cc
3367 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3368 <    echo "$as_me:$LINENO: result: yes" >&5
3369 < echo "${ECHO_T}yes" >&6
3370 <    OOPSE_TEMPLATE_FLAGS="-pto"
3371 <  else
3372 <    echo "$as_me:$LINENO: result: no" >&5
3363 > done
3364 > done
3365 >
3366 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3367 > fi
3368 > fi
3369 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3370 > if test -n "$ac_ct_RANLIB"; then
3371 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3372 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3373 > else
3374 >  echo "$as_me:$LINENO: result: no" >&5
3375   echo "${ECHO_T}no" >&6
3376 + fi
3377 +
3378 +  RANLIB=$ac_ct_RANLIB
3379 + else
3380 +  RANLIB="$ac_cv_prog_RANLIB"
3381 + fi
3382 +
3383 +
3384 +   # Extract the first word of "perl", so it can be a program name with args.
3385 + set dummy perl; ac_word=$2
3386 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3387 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3388 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3389 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3390 + else
3391 +  case $PERLINTERP in
3392 +  [\\/]* | ?:[\\/]*)
3393 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3394 +  ;;
3395 +  *)
3396 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3397 + for as_dir in $PATH
3398 + do
3399 +  IFS=$as_save_IFS
3400 +  test -z "$as_dir" && as_dir=.
3401 +  for ac_exec_ext in '' $ac_executable_extensions; do
3402 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3403 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3404 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3405 +    break 2
3406    fi
3407 <  rm -f conftest*
3408 <  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
3407 > done
3408 > done
3409  
3410 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3411 +  ;;
3412 + esac
3413 + fi
3414 + PERLINTERP=$ac_cv_path_PERLINTERP
3415  
3416 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3417 <  else
3418 <    echo "$as_me:$LINENO: result: no" >&5
3416 > if test -n "$PERLINTERP"; then
3417 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3418 > echo "${ECHO_T}$PERLINTERP" >&6
3419 > else
3420 >  echo "$as_me:$LINENO: result: no" >&5
3421   echo "${ECHO_T}no" >&6
3422 + fi
3423 +
3424 +   ac_cv_path_perlinterp="$PERLINTERP"
3425 +   _sHpB='#!'
3426 +
3427 +
3428 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3429 + if test "${with_perl_shebang+set}" = set; then
3430 +  withval="$with_perl_shebang"
3431 +  opt_perl_shebang="$withval"
3432 + else
3433 +                opt_perl_shebang="not_set"
3434 + fi;
3435 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3436 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3437 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3438 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3439 + else
3440 +   case "$opt_perl_shebang" in
3441 +                      not_set  ) ax_cv_opt_perl_shebang=''
3442 +                               ;;
3443 +                         *     )
3444 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3445 +                    esac
3446 +
3447 + fi
3448 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3449 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3450 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3451 +     then
3452 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3453 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3454 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3455 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3456 +
3457 + # Automatic detection of sharpbang formula starts here
3458 +     else
3459 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3460 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3461 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3462 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3463 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3464 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3465 + else
3466 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3467 +        if test "x$_somian_kspb_perl" == x
3468 +          then _somian_ksbp_warn_empty='durnit'
3469 +          else
3470 +          case "A$_somian_kspb_perl" in
3471 +                 A#!*perl* )
3472 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3473 +                        ;;
3474 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3475 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3476 +          esac
3477 +        fi
3478 +
3479 + fi
3480 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3481 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3482 + # The above prints Checking ... result message to user.
3483 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3484 +
3485 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3486 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3487 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3488 +    fi
3489 + # Inform user after printing result value
3490 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3491 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3492 + echo "$as_me: Maybe Not good -" >&6;}
3493 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3494 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3495 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3496 + echo "$as_me: OK Good result - " >&6;}
3497 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3498 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3499 +    fi
3500    fi
3501 +
3502 + # Find a good install program.  We prefer a C program (faster),
3503 + # so one script is as good as another.  But avoid the broken or
3504 + # incompatible versions:
3505 + # SysV /etc/install, /usr/sbin/install
3506 + # SunOS /usr/etc/install
3507 + # IRIX /sbin/install
3508 + # AIX /bin/install
3509 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3510 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3511 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3512 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3513 + # OS/2's system install, which has a completely different semantic
3514 + # ./install, which can be erroneously created by make from ./install.sh.
3515 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3516 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3517 + if test -z "$INSTALL"; then
3518 + if test "${ac_cv_path_install+set}" = set; then
3519 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3520 + else
3521 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3522 + for as_dir in $PATH
3523 + do
3524 +  IFS=$as_save_IFS
3525 +  test -z "$as_dir" && as_dir=.
3526 +  # Account for people who put trailing slashes in PATH elements.
3527 + case $as_dir/ in
3528 +  ./ | .// | /cC/* | \
3529 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3530 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3531 +  /usr/ucb/* ) ;;
3532 +  *)
3533 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3534 +    # Don't use installbsd from OSF since it installs stuff as root
3535 +    # by default.
3536 +    for ac_prog in ginstall scoinst install; do
3537 +      for ac_exec_ext in '' $ac_executable_extensions; do
3538 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3539 +          if test $ac_prog = install &&
3540 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3541 +            # AIX install.  It has an incompatible calling convention.
3542 +            :
3543 +          elif test $ac_prog = install &&
3544 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3545 +            # program-specific install script used by HP pwplus--don't use.
3546 +            :
3547 +          else
3548 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3549 +            break 3
3550 +          fi
3551 +        fi
3552 +      done
3553 +    done
3554 +    ;;
3555 + esac
3556 + done
3557 +
3558 +
3559   fi
3560 +  if test "${ac_cv_path_install+set}" = set; then
3561 +    INSTALL=$ac_cv_path_install
3562 +  else
3563 +    # As a last resort, use the slow shell script.  We don't cache a
3564 +    # path for INSTALL within a source directory, because that will
3565 +    # break other packages using the cache if that directory is
3566 +    # removed, or if the path is relative.
3567 +    INSTALL=$ac_install_sh
3568 +  fi
3569 + fi
3570 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3571 + echo "${ECHO_T}$INSTALL" >&6
3572  
3573 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3574 + # It thinks the first close brace ends the variable substitution.
3575 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3576  
3577 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3578  
3579 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3580  
3581 < ac_ext=f90
3582 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3583 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3584 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3585 < if test -n "$ac_tool_prefix"; then
3586 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3587 <  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
3581 > case "x$INSTALL" in
3582 >   x/*) ;;
3583 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3584 > esac
3585 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3586 > # Extract the first word of "ar", so it can be a program name with args.
3587 > set dummy ar; ac_word=$2
3588   echo "$as_me:$LINENO: checking for $ac_word" >&5
3589   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3590 < if test "${ac_cv_prog_F90+set}" = set; then
3590 > if test "${ac_cv_prog_AR+set}" = set; then
3591    echo $ECHO_N "(cached) $ECHO_C" >&6
3592   else
3593 <  if test -n "$F90"; then
3594 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3593 >  if test -n "$AR"; then
3594 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3595   else
3596   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3597   for as_dir in $PATH
# Line 3412 | Line 3600 | do
3600    test -z "$as_dir" && as_dir=.
3601    for ac_exec_ext in '' $ac_executable_extensions; do
3602    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3603 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3603 >    ac_cv_prog_AR="ar"
3604      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3605      break 2
3606    fi
3607   done
3608   done
3609  
3610 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3611   fi
3612   fi
3613 < F90=$ac_cv_prog_F90
3614 < if test -n "$F90"; then
3615 <  echo "$as_me:$LINENO: result: $F90" >&5
3616 < echo "${ECHO_T}$F90" >&6
3613 > AR=$ac_cv_prog_AR
3614 > if test -n "$AR"; then
3615 >  echo "$as_me:$LINENO: result: $AR" >&5
3616 > echo "${ECHO_T}$AR" >&6
3617   else
3618    echo "$as_me:$LINENO: result: no" >&5
3619   echo "${ECHO_T}no" >&6
3620   fi
3621  
3622 <    test -n "$F90" && break
3623 <  done
3622 > if test "$AR" = "NONE"; then
3623 >  cat >confcache <<\_ACEOF
3624 > # This file is a shell script that caches the results of configure
3625 > # tests run on this system so they can be shared between configure
3626 > # scripts and configure runs, see configure's option --config-cache.
3627 > # It is not useful on other systems.  If it contains results you don't
3628 > # want to keep, you may remove or edit it.
3629 > #
3630 > # config.status only pays attention to the cache file if you give it
3631 > # the --recheck option to rerun configure.
3632 > #
3633 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3634 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3635 > # following values.
3636 >
3637 > _ACEOF
3638 >
3639 > # The following way of writing the cache mishandles newlines in values,
3640 > # but we know of no workaround that is simple, portable, and efficient.
3641 > # So, don't put newlines in cache variables' values.
3642 > # Ultrix sh set writes to stderr and can't be redirected directly,
3643 > # and sets the high bit in the cache file unless we assign to the vars.
3644 > {
3645 >  (set) 2>&1 |
3646 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3647 >    *ac_space=\ *)
3648 >      # `set' does not quote correctly, so add quotes (double-quote
3649 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3650 >      sed -n \
3651 >        "s/'/'\\\\''/g;
3652 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3653 >      ;;
3654 >    *)
3655 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3656 >      sed -n \
3657 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3658 >      ;;
3659 >    esac;
3660 > } |
3661 >  sed '
3662 >     t clear
3663 >     : clear
3664 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3665 >     t end
3666 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3667 >     : end' >>confcache
3668 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3669 >  if test -w $cache_file; then
3670 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3671 >    cat confcache >$cache_file
3672 >  else
3673 >    echo "not updating unwritable cache $cache_file"
3674 >  fi
3675   fi
3676 < if test -z "$F90"; then
3677 <  ac_ct_F90=$F90
3678 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3679 < do
3680 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3441 < set dummy $ac_prog; ac_word=$2
3676 > rm -f confcache
3677 >  exit 1
3678 > fi
3679 > # Extract the first word of "ps", so it can be a program name with args.
3680 > set dummy ps; ac_word=$2
3681   echo "$as_me:$LINENO: checking for $ac_word" >&5
3682   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3683 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3683 > if test "${ac_cv_path_PS+set}" = set; then
3684    echo $ECHO_N "(cached) $ECHO_C" >&6
3685   else
3686 <  if test -n "$ac_ct_F90"; then
3687 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3688 < else
3689 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3686 >  case $PS in
3687 >  [\\/]* | ?:[\\/]*)
3688 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3689 >  ;;
3690 >  *)
3691 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3692   for as_dir in $PATH
3693   do
3694    IFS=$as_save_IFS
3695    test -z "$as_dir" && as_dir=.
3696    for ac_exec_ext in '' $ac_executable_extensions; do
3697    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3698 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3698 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3699      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3700      break 2
3701    fi
3702   done
3703   done
3704  
3705 +  ;;
3706 + esac
3707   fi
3708 < fi
3709 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3710 < if test -n "$ac_ct_F90"; then
3711 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3712 < echo "${ECHO_T}$ac_ct_F90" >&6
3708 > PS=$ac_cv_path_PS
3709 >
3710 > if test -n "$PS"; then
3711 >  echo "$as_me:$LINENO: result: $PS" >&5
3712 > echo "${ECHO_T}$PS" >&6
3713   else
3714    echo "$as_me:$LINENO: result: no" >&5
3715   echo "${ECHO_T}no" >&6
3716   fi
3717  
3718 <  test -n "$ac_ct_F90" && break
3719 < done
3718 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3719 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3720 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3721 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3722 > else
3723  
3724 <  F90=$ac_ct_F90
3724 >        if $PS ax -o rss > /dev/null 2>&1; then
3725 >                ac_cv_prog_ps_ax=yes
3726 >        else
3727 >                ac_cv_prog_ps_ax=no
3728 >        fi
3729 >        if $PS -ef -o rss > /dev/null 2>&1; then
3730 >                ac_cv_prog_ps_ef=yes
3731 >        else
3732 >                ac_cv_prog_ps_ef=no
3733 >        fi
3734 >        if test "$ac_cv_prog_ps_ax" = yes; then
3735 >                ac_cv_prog_ps_syntax=BSD
3736 >        else
3737 >                if test "$ac_cv_prog_ps_ef" = yes; then
3738 >                        ac_cv_prog_ps_syntax=POSIX
3739 >                else
3740 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3741 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3742 >   { (exit 1); exit 1; }; }
3743 >                fi
3744 >        fi
3745 >
3746   fi
3747 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3748 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3749  
3750 + cat >>confdefs.h <<_ACEOF
3751 + #define PSCOMMAND $PS
3752 + _ACEOF
3753  
3754 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3755 < # input file.
3756 < ac_save_ext=$ac_ext
3757 < ac_ext=F90
3758 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3759 < 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
3754 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3755 >
3756 > cat >>confdefs.h <<\_ACEOF
3757 > #define PSTYPE_IS_BSD 1
3758 > _ACEOF
3759 >
3760   else
3761 <  cat >conftest.$ac_ext <<_ACEOF
3761 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3762  
3763 < program main
3763 > cat >>confdefs.h <<\_ACEOF
3764 > #define PSTYPE_IS_POSIX 1
3765 > _ACEOF
3766  
3767 < #ifndef __GNUC__
3768 <       choke me
3769 < #endif
3767 >   else
3768 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3769 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3770 >   { (exit 1); exit 1; }; }
3771 >   fi
3772 > fi
3773  
3774 < end program main
3774 > ac_ext=${FC_SRCEXT-f}
3775 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3776 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3777 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3778  
3779 +
3780 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3781 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3782 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3783 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3784 + else
3785 +  ac_ext=F90
3786 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3787 + FCFLAGS_SRCEXT=""
3788 + ac_cv_fc_srcext_F90=unknown
3789 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3790 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3791 +  cat >conftest.$ac_ext <<_ACEOF
3792 +      program main
3793 +
3794 +      end
3795   _ACEOF
3796   rm -f conftest.$ac_objext
3797   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3508 | Line 3802 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3802    cat conftest.err >&5
3803    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804    (exit $ac_status); } &&
3805 <         { ac_try='test -z "$ac_f90_werror_flag"
3805 >         { ac_try='test -z "$ac_fc_werror_flag"
3806                           || test ! -s conftest.err'
3807    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3808    (eval $ac_try) 2>&5
# Line 3521 | Line 3815 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3815    ac_status=$?
3816    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817    (exit $ac_status); }; }; then
3818 <  ac_compiler_gnu=yes
3818 >  ac_cv_fc_srcext_F90=$ac_flag; break
3819   else
3820    echo "$as_me: failed program was:" >&5
3821   sed 's/^/| /' conftest.$ac_ext >&5
3822  
3529 ac_compiler_gnu=no
3823   fi
3824   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3825 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3825 > done
3826 > rm -f conftest.$ac_objext conftest.F90
3827 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3828  
3829   fi
3830 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3831 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3832 < ac_ext=$ac_save_ext
3833 < G95=`test $ac_compiler_gnu = yes && echo yes`
3834 < ac_ext=c
3835 < ac_cpp='$CPP $CPPFLAGS'
3836 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3837 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3838 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3830 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3831 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3832 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3833 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3834 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3835 >   { (exit 1); exit 1; }; }
3836 > else
3837 >  FC_SRCEXT=F90
3838 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3839 >    FCFLAGS_SRCEXT=""
3840 >    FCFLAGS_F90=""
3841 >  else
3842 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3843 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3844 >  fi
3845  
3846  
3847 + fi
3848  
3849  
3850  
3851 +
3852 +
3853   # Try to determine native compiler flags that allow us to use F90 suffix
3854   # for preprocessed f90 source.
3855  
# Line 3553 | Line 3857 | if test "$ac_test_PREPFLAG" != "set"; then
3857    PREPFLAG=""
3858    case "${host_cpu}-${host_os}" in
3859  
3860 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3860 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3861                      PREPFLAG="-fpp1 "
3862                  fi;;
3863 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3863 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3864                      PREPFLAG="-qsuffix=cpp=F90 "
3865                  fi;;
3866    *darwin*)
3867 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3867 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3868                  PREPFLAG="-qsuffix=cpp=F90 "
3869          fi;;
3870    esac
# Line 3575 | Line 3879 | echo $ECHO_N "checking to make sure F90 preprocessor f
3879   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3880  
3881  
3882 <  ac_ext=f90
3883 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3884 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3885 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3882 >  ac_ext=${FC_SRCEXT-f}
3883 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3884 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3885 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3886  
3887    ac_save_ext=$ac_ext
3888    ac_ext=F90
3889 <  ac_save_F90FLAGS=$F90FLAGS
3889 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3890  
3891    if test "$PREPFLAG"; then
3892 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3892 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3893   fi
3894  
3895      cat >conftest.$ac_ext <<_ACEOF
3896  
3897  
3898 < program main
3595 <
3898 > program conftest
3899    integer :: i
3900    i = 1
3901 + end program conftest
3902  
3599
3600 end program main
3601
3903   _ACEOF
3904   rm -f conftest.$ac_objext
3905   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3609 | Line 3910 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3910    cat conftest.err >&5
3911    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912    (exit $ac_status); } &&
3913 <         { ac_try='test -z "$ac_f90_werror_flag"
3913 >         { ac_try='test -z "$ac_fc_werror_flag"
3914                           || test ! -s conftest.err'
3915    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3916    (eval $ac_try) 2>&5
# Line 3631 | Line 3932 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3932   fi
3933   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3934  
3935 <  F90FLAGS=$ac_save_F90FLAGS
3935 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3936    ac_ext=$ac_save_ext
3937 <  ac_ext=c
3938 < ac_cpp='$CPP $CPPFLAGS'
3939 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3940 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3640 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3937 >  ac_ext=${FC_SRCEXT-f}
3938 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3939 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3940 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3941  
3942  
3943    if test "$prepflagworks" = 1; then
3944      echo "$as_me:$LINENO: result: yes" >&5
3945   echo "${ECHO_T}yes" >&6
3946 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3947  
3948    else
3949      echo "$as_me:$LINENO: result: no" >&5
# Line 3664 | Line 3965 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3965    PREPDEFFLAG=""
3966    case "${host_cpu}-${host_os}" in
3967  
3968 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3968 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3969                      PREPDEFFLAG=" "
3970                  fi;;
3971 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3971 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3972                      PREPDEFFLAG="-WF,"
3973                  fi;;
3974    *darwin*)
3975 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3975 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3976                  PREPDEFFLAG="-WF,"
3977          fi;;
3978    esac
# Line 3686 | Line 3987 | echo $ECHO_N "checking to make sure F90 preprocessor d
3987   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3988  
3989  
3990 <  ac_ext=f90
3991 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3992 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3993 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3990 >  ac_ext=${FC_SRCEXT-f}
3991 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3992 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3993 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3994  
3995    ac_save_ext=$ac_ext
3996    ac_ext=F90
3997 <  ac_save_F90FLAGS=$F90FLAGS
3997 >  ac_save_FCFLAGS=$FCFLAGS
3998  
3999    if test "$PREPDEFFLAG"; then
4000 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
4000 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
4001   fi
4002  
4003      cat >conftest.$ac_ext <<_ACEOF
4004  
4005  
4006 < program main
3706 <
4006 > program conftest
4007    integer :: i
4008   #ifdef TEST
4009    i = 1
4010   #else
4011    choke me
4012   #endif
4013 + end program conftest
4014  
3714
3715 end program main
3716
4015   _ACEOF
4016   rm -f conftest.$ac_objext
4017   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3724 | Line 4022 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4022    cat conftest.err >&5
4023    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4024    (exit $ac_status); } &&
4025 <         { ac_try='test -z "$ac_f90_werror_flag"
4025 >         { ac_try='test -z "$ac_fc_werror_flag"
4026                           || test ! -s conftest.err'
4027    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4028    (eval $ac_try) 2>&5
# Line 3746 | Line 4044 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
4044   fi
4045   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4046  
4047 <  F90FLAGS=$ac_save_F90FLAGS
4047 >  FCFLAGS=$ac_save_FCFLAGS
4048    ac_ext=$ac_save_ext
4049 <  ac_ext=c
4050 < ac_cpp='$CPP $CPPFLAGS'
4051 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4052 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4049 >  ac_ext=${FC_SRCEXT-f}
4050 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4051 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4052 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4053  
4054  
3758
4055    if test "$prepdefflagworks" = 1; then
4056      echo "$as_me:$LINENO: result: yes" >&5
4057   echo "${ECHO_T}yes" >&6
# Line 3769 | Line 4065 | fi
4065    fi
4066   fi
4067  
4068 < ac_ext=f90
4069 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4070 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4071 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4072 <
4073 <
4074 <
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
4068 > ac_ext=${FC_SRCEXT-f}
4069 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4070 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4071 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4072 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4073 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4074 > if test "${ac_cv_prog_fc_v+set}" = set; then
4075    echo $ECHO_N "(cached) $ECHO_C" >&6
4076   else
4077 +  cat >conftest.$ac_ext <<_ACEOF
4078 +      program main
4079  
4080 < cat >conftest.$ac_ext <<_ACEOF
3790 <
3791 < program main
3792 <
3793 <
3794 < end program main
3795 <
4080 >      end
4081   _ACEOF
4082   rm -f conftest.$ac_objext
4083   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3803 | Line 4088 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4088    cat conftest.err >&5
4089    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090    (exit $ac_status); } &&
4091 <         { ac_try='test -z "$ac_f90_werror_flag"
4091 >         { ac_try='test -z "$ac_fc_werror_flag"
4092                           || test ! -s conftest.err'
4093    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094    (eval $ac_try) 2>&5
# Line 3816 | Line 4101 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4101    ac_status=$?
4102    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103    (exit $ac_status); }; }; then
4104 <  ac_cv_prog_f90_v=
4104 >  ac_cv_prog_fc_v=
4105   # Try some options frequently used verbose output
4106   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4107 <  ac_ext=f90
4108 < 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
4107 >  cat >conftest.$ac_ext <<_ACEOF
4108 >      program main
4109  
4110 < cat >conftest.$ac_ext <<_ACEOF
3828 <
3829 < program main
3830 <
3831 <
3832 < end program main
3833 <
4110 >      end
4111   _ACEOF
4112  
4113   # Compile and link our simple test program by passing a flag (argument
4114 < # 1 to this macro) to the Fortran 90 compiler in order to get
4115 < # "verbose" output that we can then parse for the Fortran 90 linker
4114 > # 1 to this macro) to the Fortran compiler in order to get
4115 > # "verbose" output that we can then parse for the Fortran linker
4116   # flags.
4117 < ac_save_F90FLAGS=$F90FLAGS
4118 < F90FLAGS="$F90FLAGS $ac_verb"
4117 > ac_save_FFLAGS=$FCFLAGS
4118 > FCFLAGS="$FCFLAGS $ac_verb"
4119 > (eval echo $as_me:4119: \"$ac_link\") >&5
4120 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4121 > echo "$ac_fc_v_output" >&5
4122 > FCFLAGS=$ac_save_FFLAGS
4123  
4124 < (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
4124 > rm -f conftest*
4125  
4126 < rm -f conftest.*
4127 < ac_ext=f90
4128 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4129 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4130 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4126 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4127 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4128 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4129 > ac_fc_v_output="`echo $ac_fc_v_output |
4130 >        grep 'LPATH is:' |
4131 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4132  
4133 < # If we are using xlf then replace all the commas with spaces.
4134 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4135 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4136 < fi
4133 > case $ac_fc_v_output in
4134 >  # If we are using xlf then replace all the commas with spaces.
4135 >  *xlfentry*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4137  
4138 < # If we are using Cray Fortran then delete quotes.
4139 < # Use "\"" instead of '"' for font-lock-mode.
4140 < # FIXME: a more general fix for quoted arguments with spaces?
4141 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4142 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4143 < fi
4138 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4139 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4140 >  *mGLOB_options_string*)
4141 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4142 >
4143 >  # If we are using Cray Fortran then delete quotes.
4144 >  # Use "\"" instead of '"' for font-lock-mode.
4145 >  # FIXME: a more general fix for quoted arguments with spaces?
4146 >  *cft90*)
4147 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4148 > esac
4149 >
4150 >
4151    # look for -l* and *.a constructs in the output
4152 <  for ac_arg in $ac_f90_v_output; do
4152 >  for ac_arg in $ac_fc_v_output; do
4153       case $ac_arg in
4154          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4155 <          ac_cv_prog_f90_v=$ac_verb
4155 >          ac_cv_prog_fc_v=$ac_verb
4156            break 2 ;;
4157       esac
4158    done
4159   done
4160 < if test -z "$ac_cv_prog_f90_v"; then
4161 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4162 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4160 > if test -z "$ac_cv_prog_fc_v"; then
4161 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4162 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4163   fi
4164   else
4165    echo "$as_me: failed program was:" >&5
# Line 3885 | Line 4171 | fi
4171   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4172  
4173   fi
4174 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4175 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4176 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4177 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4178 < if test "${ac_cv_flibs+set}" = set; then
4174 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4175 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4176 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4177 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4178 > if test "${ac_cv_fc_libs+set}" = set; then
4179    echo $ECHO_N "(cached) $ECHO_C" >&6
4180   else
4181 <  if test "x$F90LIBS" != "x"; then
4182 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4181 >  if test "x$FCLIBS" != "x"; then
4182 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4183   else
4184  
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
4185   cat >conftest.$ac_ext <<_ACEOF
4186 +      program main
4187  
4188 < program main
3907 <
3908 <
3909 < end program main
3910 <
4188 >      end
4189   _ACEOF
4190  
4191   # Compile and link our simple test program by passing a flag (argument
4192 < # 1 to this macro) to the Fortran 90 compiler in order to get
4193 < # "verbose" output that we can then parse for the Fortran 90 linker
4192 > # 1 to this macro) to the Fortran compiler in order to get
4193 > # "verbose" output that we can then parse for the Fortran linker
4194   # flags.
4195 < ac_save_F90FLAGS=$F90FLAGS
4196 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4195 > ac_save_FFLAGS=$FCFLAGS
4196 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4197 > (eval echo $as_me:4197: \"$ac_link\") >&5
4198 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4199 > echo "$ac_fc_v_output" >&5
4200 > FCFLAGS=$ac_save_FFLAGS
4201  
4202 < (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
4202 > rm -f conftest*
4203  
4204 < rm -f conftest.*
4205 < ac_ext=f90
4206 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4207 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4208 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4204 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4205 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4206 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4207 > ac_fc_v_output="`echo $ac_fc_v_output |
4208 >        grep 'LPATH is:' |
4209 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4210  
4211 < # If we are using xlf then replace all the commas with spaces.
4212 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4213 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4214 < fi
4211 > case $ac_fc_v_output in
4212 >  # If we are using xlf then replace all the commas with spaces.
4213 >  *xlfentry*)
4214 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4215  
4216 < # If we are using Cray Fortran then delete quotes.
4217 < # Use "\"" instead of '"' for font-lock-mode.
4218 < # FIXME: a more general fix for quoted arguments with spaces?
4219 < 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
4216 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4217 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4218 >  *mGLOB_options_string*)
4219 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4220  
4221 < ac_cv_f90libs=
4221 >  # If we are using Cray Fortran then delete quotes.
4222 >  # Use "\"" instead of '"' for font-lock-mode.
4223 >  # FIXME: a more general fix for quoted arguments with spaces?
4224 >  *cft90*)
4225 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4226 > esac
4227  
4228 +
4229 +
4230 + ac_cv_fc_libs=
4231 +
4232   # Save positional arguments (if any)
4233   ac_save_positional="$@"
4234  
4235 < set X $ac_f90_v_output
4235 > set X $ac_fc_v_output
4236   while test $# != 1; do
4237    shift
4238    ac_arg=$1
4239    case $ac_arg in
4240          [\\/]*.a | ?:[\\/]*.a)
4241              ac_exists=false
4242 <  for ac_i in $ac_cv_f90libs; do
4242 >  for ac_i in $ac_cv_fc_libs; do
4243      if test x"$ac_arg" = x"$ac_i"; then
4244        ac_exists=true
4245        break
# Line 3962 | Line 4249 | else
4249    if test x"$ac_exists" = xtrue; then
4250    :
4251   else
4252 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4252 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4253   fi
4254  
4255            ;;
4256          -bI:*)
4257              ac_exists=false
4258 <  for ac_i in $ac_cv_f90libs; do
4258 >  for ac_i in $ac_cv_fc_libs; do
4259      if test x"$ac_arg" = x"$ac_i"; then
4260        ac_exists=true
4261        break
# Line 3980 | Line 4267 | else
4267   else
4268    if test "$ac_compiler_gnu" = yes; then
4269    for ac_link_opt in $ac_arg; do
4270 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4270 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4271    done
4272   else
4273 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4273 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4274   fi
4275   fi
4276  
4277            ;;
4278            # Ignore these flags.
4279 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4279 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4280            ;;
4281          -lkernel32)
4282 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4282 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4283            ;;
4284          -[LRuY])
4285            # These flags, when seen by themselves, take an argument.
4286            # We remove the space between option and argument and re-iterate
4287            # unless we find an empty arg or a new option (starting with -)
4288            case $2 in
4289 <             "" | -*);;
4290 <             *)
4289 >             "" | -*);;
4290 >             *)
4291                  ac_arg="$ac_arg$2"
4005
4292                  shift; shift
4293                  set X $ac_arg "$@"
4294                  ;;
# Line 4011 | Line 4297 | fi
4297          -YP,*)
4298            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4299                ac_exists=false
4300 <  for ac_i in $ac_cv_f90libs; do
4300 >  for ac_i in $ac_cv_fc_libs; do
4301      if test x"$ac_j" = x"$ac_i"; then
4302        ac_exists=true
4303        break
# Line 4022 | Line 4308 | else
4308    :
4309   else
4310    ac_arg="$ac_arg $ac_j"
4311 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4311 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4312   fi
4313  
4314            done
4315            ;;
4316          -[lLR]*)
4317              ac_exists=false
4318 <  for ac_i in $ac_cv_f90libs; do
4318 >  for ac_i in $ac_cv_fc_libs; do
4319      if test x"$ac_arg" = x"$ac_i"; then
4320        ac_exists=true
4321        break
# Line 4039 | Line 4325 | else
4325    if test x"$ac_exists" = xtrue; then
4326    :
4327   else
4328 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4328 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4329   fi
4330  
4331            ;;
# Line 4054 | Line 4340 | case `(uname -sr) 2>/dev/null` in
4340   # must begin with a "/").
4341   case `(uname -sr) 2>/dev/null` in
4342     "SunOS 5"*)
4343 <      ac_ld_run_path=`echo $ac_f90_v_output |
4343 >      ac_ld_run_path=`echo $ac_fc_v_output |
4344                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4345        test "x$ac_ld_run_path" != x &&
4060
4346          if test "$ac_compiler_gnu" = yes; then
4347    for ac_link_opt in $ac_ld_run_path; do
4348 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4348 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4349    done
4350   else
4351 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4351 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4352   fi
4353        ;;
4354   esac
4355 < fi # test "x$F90LIBS" = "x"
4355 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4356  
4357   fi
4358 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4359 < echo "${ECHO_T}$ac_cv_flibs" >&6
4360 < F90LIBS="$ac_cv_f90libs"
4358 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4359 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4360 > FCLIBS="$ac_cv_fc_libs"
4361  
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
4362  
4363 + ac_ext=${FC_SRCEXT-f}
4364 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4365 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4366 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4367  
4368 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4369 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4370 < if test "${ac_cv_f90_mangling+set}" = set; then
4368 >
4369 > ac_ext=${FC_SRCEXT-f}
4370 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4371 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4372 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4373 >
4374 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4375 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4376 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4377    echo $ECHO_N "(cached) $ECHO_C" >&6
4378   else
4379 <  ac_ext=f90
4380 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4381 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4382 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4383 < cat >conftest.$ac_ext <<_ACEOF
4384 < subroutine foobar()
4385 < return
4386 < end
4387 < subroutine foo_bar()
4388 < return
4389 < end
4379 >  ac_fc_dm_save_LIBS=$LIBS
4380 > LIBS="$LIBS $FCLIBS"
4381 > ac_fortran_dm_var=FC_DUMMY_MAIN
4382 > ac_ext=c
4383 > ac_cpp='$CPP $CPPFLAGS'
4384 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4385 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4386 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4387 >
4388 > # First, try linking without a dummy main:
4389 > cat >conftest.$ac_ext <<_ACEOF
4390 > /* confdefs.h.  */
4391   _ACEOF
4392 + cat confdefs.h >>conftest.$ac_ext
4393 + cat >>conftest.$ac_ext <<_ACEOF
4394 + /* end confdefs.h.  */
4395 +
4396 + #ifdef FC_DUMMY_MAIN
4397 + #ifndef FC_DUMMY_MAIN_EQ_F77
4398 + #  ifdef __cplusplus
4399 +     extern "C"
4400 + #  endif
4401 +   int FC_DUMMY_MAIN() { return 1; }
4402 + #endif
4403 + #endif
4404 + int
4405 + main ()
4406 + {
4407 +
4408 +  ;
4409 +  return 0;
4410 + }
4411 + _ACEOF
4412 + rm -f conftest.$ac_objext conftest$ac_exeext
4413 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4414 +  (eval $ac_link) 2>conftest.er1
4415 +  ac_status=$?
4416 +  grep -v '^ *+' conftest.er1 >conftest.err
4417 +  rm -f conftest.er1
4418 +  cat conftest.err >&5
4419 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4420 +  (exit $ac_status); } &&
4421 +         { ac_try='test -z "$ac_c_werror_flag"
4422 +                         || test ! -s conftest.err'
4423 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4424 +  (eval $ac_try) 2>&5
4425 +  ac_status=$?
4426 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4427 +  (exit $ac_status); }; } &&
4428 +         { ac_try='test -s conftest$ac_exeext'
4429 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4430 +  (eval $ac_try) 2>&5
4431 +  ac_status=$?
4432 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4433 +  (exit $ac_status); }; }; then
4434 +  ac_cv_fortran_dummy_main=none
4435 + else
4436 +  echo "$as_me: failed program was:" >&5
4437 + sed 's/^/| /' conftest.$ac_ext >&5
4438 +
4439 + ac_cv_fortran_dummy_main=unknown
4440 + fi
4441 + rm -f conftest.err conftest.$ac_objext \
4442 +      conftest$ac_exeext conftest.$ac_ext
4443 +
4444 + if test $ac_cv_fortran_dummy_main = unknown; then
4445 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4446 +     cat >conftest.$ac_ext <<_ACEOF
4447 + /* confdefs.h.  */
4448 + _ACEOF
4449 + cat confdefs.h >>conftest.$ac_ext
4450 + cat >>conftest.$ac_ext <<_ACEOF
4451 + /* end confdefs.h.  */
4452 + #define $ac_fortran_dm_var $ac_func
4453 + #ifdef FC_DUMMY_MAIN
4454 + #ifndef FC_DUMMY_MAIN_EQ_F77
4455 + #  ifdef __cplusplus
4456 +     extern "C"
4457 + #  endif
4458 +   int FC_DUMMY_MAIN() { return 1; }
4459 + #endif
4460 + #endif
4461 + int
4462 + main ()
4463 + {
4464 +
4465 +  ;
4466 +  return 0;
4467 + }
4468 + _ACEOF
4469 + rm -f conftest.$ac_objext conftest$ac_exeext
4470 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4471 +  (eval $ac_link) 2>conftest.er1
4472 +  ac_status=$?
4473 +  grep -v '^ *+' conftest.er1 >conftest.err
4474 +  rm -f conftest.er1
4475 +  cat conftest.err >&5
4476 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4477 +  (exit $ac_status); } &&
4478 +         { ac_try='test -z "$ac_c_werror_flag"
4479 +                         || test ! -s conftest.err'
4480 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4481 +  (eval $ac_try) 2>&5
4482 +  ac_status=$?
4483 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4484 +  (exit $ac_status); }; } &&
4485 +         { ac_try='test -s conftest$ac_exeext'
4486 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4487 +  (eval $ac_try) 2>&5
4488 +  ac_status=$?
4489 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4490 +  (exit $ac_status); }; }; then
4491 +  ac_cv_fortran_dummy_main=$ac_func; break
4492 + else
4493 +  echo "$as_me: failed program was:" >&5
4494 + sed 's/^/| /' conftest.$ac_ext >&5
4495 +
4496 + fi
4497 + rm -f conftest.err conftest.$ac_objext \
4498 +      conftest$ac_exeext conftest.$ac_ext
4499 +   done
4500 + fi
4501 + ac_ext=${FC_SRCEXT-f}
4502 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4503 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4504 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4505 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4506 + rm -f conftest*
4507 + LIBS=$ac_fc_dm_save_LIBS
4508 +
4509 + fi
4510 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4511 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4512 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4513 + if test "$FC_DUMMY_MAIN" != unknown; then
4514 +  if test $FC_DUMMY_MAIN != none; then
4515 +
4516 + cat >>confdefs.h <<_ACEOF
4517 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4518 + _ACEOF
4519 +
4520 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4521 +
4522 + cat >>confdefs.h <<\_ACEOF
4523 + #define FC_DUMMY_MAIN_EQ_F77 1
4524 + _ACEOF
4525 +
4526 +  fi
4527 + fi
4528 + else
4529 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4530 + See \`config.log' for more details." >&5
4531 + echo "$as_me: error: linking to Fortran libraries from C fails
4532 + See \`config.log' for more details." >&2;}
4533 +   { (exit 1); exit 1; }; }
4534 + fi
4535 +
4536 +
4537 + ac_ext=${FC_SRCEXT-f}
4538 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4539 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4540 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4541 +
4542 + ac_ext=${FC_SRCEXT-f}
4543 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4544 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4545 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4546 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4547 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4548 + if test "${ac_cv_fc_mangling+set}" = set; then
4549 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4550 + else
4551 +  cat >conftest.$ac_ext <<_ACEOF
4552 +      subroutine foobar()
4553 +      return
4554 +      end
4555 +      subroutine foo_bar()
4556 +      return
4557 +      end
4558 + _ACEOF
4559   rm -f conftest.$ac_objext
4560   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4561    (eval $ac_compile) 2>conftest.er1
# Line 4106 | Line 4565 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4565    cat conftest.err >&5
4566    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4567    (exit $ac_status); } &&
4568 <         { ac_try='test -z "$ac_f90_werror_flag"
4568 >         { ac_try='test -z "$ac_fc_werror_flag"
4569                           || test ! -s conftest.err'
4570    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4571    (eval $ac_try) 2>&5
# Line 4119 | Line 4578 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4578    ac_status=$?
4579    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4580    (exit $ac_status); }; }; then
4581 <  mv conftest.$ac_objext cf90_test.$ac_objext
4581 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4582  
4583 +  ac_save_LIBS=$LIBS
4584 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4585 +
4586    ac_ext=c
4587   ac_cpp='$CPP $CPPFLAGS'
4588   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4589   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4590   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4129
4130  ac_save_LIBS=$LIBS
4131  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4132
4591    ac_success=no
4592    for ac_foobar in foobar FOOBAR; do
4593      for ac_underscore in "" "_"; do
# Line 4148 | Line 4606 | char $ac_func ();
4606   /* We use char because int might match the return type of a gcc2
4607     builtin and then its argument prototype would still apply.  */
4608   char $ac_func ();
4609 + #ifdef FC_DUMMY_MAIN
4610 + #ifndef FC_DUMMY_MAIN_EQ_F77
4611 + #  ifdef __cplusplus
4612 +     extern "C"
4613 + #  endif
4614 +   int FC_DUMMY_MAIN() { return 1; }
4615 + #endif
4616 + #endif
4617   int
4618   main ()
4619   {
# Line 4188 | Line 4654 | rm -f conftest.err conftest.$ac_objext \
4654        conftest$ac_exeext conftest.$ac_ext
4655      done
4656    done
4657 +  ac_ext=${FC_SRCEXT-f}
4658 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4659 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4660 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4661  
4662    if test "$ac_success" = "yes"; then
4663       case $ac_foobar in
4664 <        foobar)
4665 <           ac_case=lower
4666 <           ac_foo_bar=foo_bar
4667 <           ;;
4668 <        FOOBAR)
4669 <           ac_case=upper
4670 <           ac_foo_bar=FOO_BAR
4671 <           ;;
4664 >        foobar)
4665 >           ac_case=lower
4666 >           ac_foo_bar=foo_bar
4667 >           ;;
4668 >        FOOBAR)
4669 >           ac_case=upper
4670 >           ac_foo_bar=FOO_BAR
4671 >           ;;
4672       esac
4673  
4674 +     ac_ext=c
4675 + ac_cpp='$CPP $CPPFLAGS'
4676 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4677 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4678 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4679       ac_success_extra=no
4680       for ac_extra in "" "_"; do
4681 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4682 <
4208 <        cat >conftest.$ac_ext <<_ACEOF
4681 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4682 >        cat >conftest.$ac_ext <<_ACEOF
4683   /* confdefs.h.  */
4684   _ACEOF
4685   cat confdefs.h >>conftest.$ac_ext
# Line 4219 | Line 4693 | char $ac_func ();
4693   /* We use char because int might match the return type of a gcc2
4694     builtin and then its argument prototype would still apply.  */
4695   char $ac_func ();
4696 + #ifdef FC_DUMMY_MAIN
4697 + #ifndef FC_DUMMY_MAIN_EQ_F77
4698 + #  ifdef __cplusplus
4699 +     extern "C"
4700 + #  endif
4701 +   int FC_DUMMY_MAIN() { return 1; }
4702 + #endif
4703 + #endif
4704   int
4705   main ()
4706   {
# Line 4258 | Line 4740 | rm -f conftest.err conftest.$ac_objext \
4740   rm -f conftest.err conftest.$ac_objext \
4741        conftest$ac_exeext conftest.$ac_ext
4742       done
4743 +     ac_ext=${FC_SRCEXT-f}
4744 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4745 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4746 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4747  
4748       if test "$ac_success_extra" = "yes"; then
4749 <        ac_cv_f90_mangling="$ac_case case"
4749 >        ac_cv_fc_mangling="$ac_case case"
4750          if test -z "$ac_underscore"; then
4751 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4751 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4752          else
4753 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4268 <
4753 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4754          fi
4755          if test -z "$ac_extra"; then
4756 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4756 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4757          else
4758 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4758 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4759          fi
4760        else
4761 <        ac_cv_f90_mangling="unknown"
4761 >        ac_cv_fc_mangling="unknown"
4762        fi
4763    else
4764 <     ac_cv_f90_mangling="unknown"
4280 <
4764 >     ac_cv_fc_mangling="unknown"
4765    fi
4766  
4767    LIBS=$ac_save_LIBS
4768 <  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*
4768 >  rm -f cfortran_test* conftest*
4769   else
4770    echo "$as_me: failed program was:" >&5
4771   sed 's/^/| /' conftest.$ac_ext >&5
4772  
4773 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4774 + See \`config.log' for more details." >&5
4775 + echo "$as_me: error: cannot compile a simple Fortran program
4776 + See \`config.log' for more details." >&2;}
4777 +   { (exit 1); exit 1; }; }
4778   fi
4779   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
4780  
4781   fi
4782 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4783 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4782 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4783 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4784  
4785 + ac_ext=${FC_SRCEXT-f}
4786 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4787 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4788 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4789  
4790 + ac_ext=${FC_SRCEXT-f}
4791 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4792 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4793 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4794  
4795 < case $ac_cv_f90_mangling in
4795 >
4796 > case $ac_cv_fc_mangling in
4797    "lower case, no underscore, no extra underscore")
4798            cat >>confdefs.h <<\_ACEOF
4799 < #define F90_FUNC(name,NAME) name
4799 > #define FC_FUNC(name,NAME) name
4800   _ACEOF
4801  
4802            cat >>confdefs.h <<\_ACEOF
4803 < #define F90_FUNC_(name,NAME) name
4803 > #define FC_FUNC_(name,NAME) name
4804   _ACEOF
4805   ;;
4806    "lower case, no underscore, extra underscore")
4807            cat >>confdefs.h <<\_ACEOF
4808 < #define F90_FUNC(name,NAME) name
4808 > #define FC_FUNC(name,NAME) name
4809   _ACEOF
4810  
4811            cat >>confdefs.h <<\_ACEOF
4812 < #define F90_FUNC_(name,NAME) name ## _
4812 > #define FC_FUNC_(name,NAME) name ## _
4813   _ACEOF
4814   ;;
4815    "lower case, underscore, no extra underscore")
4816            cat >>confdefs.h <<\_ACEOF
4817 < #define F90_FUNC(name,NAME) name ## _
4817 > #define FC_FUNC(name,NAME) name ## _
4818   _ACEOF
4819  
4820            cat >>confdefs.h <<\_ACEOF
4821 < #define F90_FUNC_(name,NAME) name ## _
4821 > #define FC_FUNC_(name,NAME) name ## _
4822   _ACEOF
4823   ;;
4824    "lower case, underscore, extra underscore")
4825            cat >>confdefs.h <<\_ACEOF
4826 < #define F90_FUNC(name,NAME) name ## _
4826 > #define FC_FUNC(name,NAME) name ## _
4827   _ACEOF
4828  
4829            cat >>confdefs.h <<\_ACEOF
4830 < #define F90_FUNC_(name,NAME) name ## __
4830 > #define FC_FUNC_(name,NAME) name ## __
4831   _ACEOF
4832   ;;
4833    "upper case, no underscore, no extra underscore")
4834            cat >>confdefs.h <<\_ACEOF
4835 < #define F90_FUNC(name,NAME) NAME
4835 > #define FC_FUNC(name,NAME) NAME
4836   _ACEOF
4837  
4838            cat >>confdefs.h <<\_ACEOF
4839 < #define F90_FUNC_(name,NAME) NAME
4839 > #define FC_FUNC_(name,NAME) NAME
4840   _ACEOF
4841   ;;
4842    "upper case, no underscore, extra underscore")
4843            cat >>confdefs.h <<\_ACEOF
4844 < #define F90_FUNC(name,NAME) NAME
4844 > #define FC_FUNC(name,NAME) NAME
4845   _ACEOF
4846  
4847            cat >>confdefs.h <<\_ACEOF
4848 < #define F90_FUNC_(name,NAME) NAME ## _
4848 > #define FC_FUNC_(name,NAME) NAME ## _
4849   _ACEOF
4850   ;;
4851    "upper case, underscore, no extra underscore")
4852            cat >>confdefs.h <<\_ACEOF
4853 < #define F90_FUNC(name,NAME) NAME ## _
4853 > #define FC_FUNC(name,NAME) NAME ## _
4854   _ACEOF
4855  
4856            cat >>confdefs.h <<\_ACEOF
4857 < #define F90_FUNC_(name,NAME) NAME ## _
4857 > #define FC_FUNC_(name,NAME) NAME ## _
4858   _ACEOF
4859   ;;
4860    "upper case, underscore, extra underscore")
4861            cat >>confdefs.h <<\_ACEOF
4862 < #define F90_FUNC(name,NAME) NAME ## _
4862 > #define FC_FUNC(name,NAME) NAME ## _
4863   _ACEOF
4864  
4865            cat >>confdefs.h <<\_ACEOF
4866 < #define F90_FUNC_(name,NAME) NAME ## __
4866 > #define FC_FUNC_(name,NAME) NAME ## __
4867   _ACEOF
4868   ;;
4869    *)
4870 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4871 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4870 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4871 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4872 >          ;;
4873 > esac
4874 >
4875 > ac_ext=${FC_SRCEXT-f}
4876 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4877 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4878 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4879 >
4880 >
4881 >
4882 > ac_ext=${FC_SRCEXT-f}
4883 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4884 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4885 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4886 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4887 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4888 > if test "${ac_cv_prog_fc_v+set}" = set; then
4889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4890 > else
4891 >  cat >conftest.$ac_ext <<_ACEOF
4892 >      program main
4893 >
4894 >      end
4895 > _ACEOF
4896 > rm -f conftest.$ac_objext
4897 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4898 >  (eval $ac_compile) 2>conftest.er1
4899 >  ac_status=$?
4900 >  grep -v '^ *+' conftest.er1 >conftest.err
4901 >  rm -f conftest.er1
4902 >  cat conftest.err >&5
4903 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4904 >  (exit $ac_status); } &&
4905 >         { ac_try='test -z "$ac_fc_werror_flag"
4906 >                         || test ! -s conftest.err'
4907 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4908 >  (eval $ac_try) 2>&5
4909 >  ac_status=$?
4910 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4911 >  (exit $ac_status); }; } &&
4912 >         { ac_try='test -s conftest.$ac_objext'
4913 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4914 >  (eval $ac_try) 2>&5
4915 >  ac_status=$?
4916 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4917 >  (exit $ac_status); }; }; then
4918 >  ac_cv_prog_fc_v=
4919 > # Try some options frequently used verbose output
4920 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4921 >  cat >conftest.$ac_ext <<_ACEOF
4922 >      program main
4923 >
4924 >      end
4925 > _ACEOF
4926 >
4927 > # Compile and link our simple test program by passing a flag (argument
4928 > # 1 to this macro) to the Fortran compiler in order to get
4929 > # "verbose" output that we can then parse for the Fortran linker
4930 > # flags.
4931 > ac_save_FFLAGS=$FCFLAGS
4932 > FCFLAGS="$FCFLAGS $ac_verb"
4933 > (eval echo $as_me:4933: \"$ac_link\") >&5
4934 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4935 > echo "$ac_fc_v_output" >&5
4936 > FCFLAGS=$ac_save_FFLAGS
4937 >
4938 > rm -f conftest*
4939 >
4940 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4941 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4942 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4943 > ac_fc_v_output="`echo $ac_fc_v_output |
4944 >        grep 'LPATH is:' |
4945 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4946 >
4947 > case $ac_fc_v_output in
4948 >  # If we are using xlf then replace all the commas with spaces.
4949 >  *xlfentry*)
4950 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4951 >
4952 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4953 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4954 >  *mGLOB_options_string*)
4955 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4956 >
4957 >  # If we are using Cray Fortran then delete quotes.
4958 >  # Use "\"" instead of '"' for font-lock-mode.
4959 >  # FIXME: a more general fix for quoted arguments with spaces?
4960 >  *cft90*)
4961 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4962 > esac
4963 >
4964 >
4965 >  # look for -l* and *.a constructs in the output
4966 >  for ac_arg in $ac_fc_v_output; do
4967 >     case $ac_arg in
4968 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4969 >          ac_cv_prog_fc_v=$ac_verb
4970 >          break 2 ;;
4971 >     esac
4972 >  done
4973 > done
4974 > if test -z "$ac_cv_prog_fc_v"; then
4975 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4976 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4977 > fi
4978 > else
4979 >  echo "$as_me: failed program was:" >&5
4980 > sed 's/^/| /' conftest.$ac_ext >&5
4981 >
4982 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4983 > echo "$as_me: WARNING: compilation failed" >&2;}
4984 > fi
4985 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4986 >
4987 > fi
4988 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4989 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4990 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4991 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4992 > if test "${ac_cv_fc_libs+set}" = set; then
4993 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4994 > else
4995 >  if test "x$FCLIBS" != "x"; then
4996 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4997 > else
4998 >
4999 > cat >conftest.$ac_ext <<_ACEOF
5000 >      program main
5001 >
5002 >      end
5003 > _ACEOF
5004 >
5005 > # Compile and link our simple test program by passing a flag (argument
5006 > # 1 to this macro) to the Fortran compiler in order to get
5007 > # "verbose" output that we can then parse for the Fortran linker
5008 > # flags.
5009 > ac_save_FFLAGS=$FCFLAGS
5010 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5011 > (eval echo $as_me:5011: \"$ac_link\") >&5
5012 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5013 > echo "$ac_fc_v_output" >&5
5014 > FCFLAGS=$ac_save_FFLAGS
5015 >
5016 > rm -f conftest*
5017 >
5018 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5019 > # /foo, /bar, and /baz are search directories for the Fortran linker.
5020 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5021 > ac_fc_v_output="`echo $ac_fc_v_output |
5022 >        grep 'LPATH is:' |
5023 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5024 >
5025 > case $ac_fc_v_output in
5026 >  # If we are using xlf then replace all the commas with spaces.
5027 >  *xlfentry*)
5028 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5029 >
5030 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5031 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
5032 >  *mGLOB_options_string*)
5033 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
5034 >
5035 >  # If we are using Cray Fortran then delete quotes.
5036 >  # Use "\"" instead of '"' for font-lock-mode.
5037 >  # FIXME: a more general fix for quoted arguments with spaces?
5038 >  *cft90*)
5039 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
5040 > esac
5041 >
5042 >
5043 >
5044 > ac_cv_fc_libs=
5045 >
5046 > # Save positional arguments (if any)
5047 > ac_save_positional="$@"
5048 >
5049 > set X $ac_fc_v_output
5050 > while test $# != 1; do
5051 >  shift
5052 >  ac_arg=$1
5053 >  case $ac_arg in
5054 >        [\\/]*.a | ?:[\\/]*.a)
5055 >            ac_exists=false
5056 >  for ac_i in $ac_cv_fc_libs; do
5057 >    if test x"$ac_arg" = x"$ac_i"; then
5058 >      ac_exists=true
5059 >      break
5060 >    fi
5061 >  done
5062 >
5063 >  if test x"$ac_exists" = xtrue; then
5064 >  :
5065 > else
5066 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5067 > fi
5068 >
5069            ;;
5070 +        -bI:*)
5071 +            ac_exists=false
5072 +  for ac_i in $ac_cv_fc_libs; do
5073 +    if test x"$ac_arg" = x"$ac_i"; then
5074 +      ac_exists=true
5075 +      break
5076 +    fi
5077 +  done
5078 +
5079 +  if test x"$ac_exists" = xtrue; then
5080 +  :
5081 + else
5082 +  if test "$ac_compiler_gnu" = yes; then
5083 +  for ac_link_opt in $ac_arg; do
5084 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5085 +  done
5086 + else
5087 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5088 + fi
5089 + fi
5090 +
5091 +          ;;
5092 +          # Ignore these flags.
5093 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5094 +          ;;
5095 +        -lkernel32)
5096 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5097 +          ;;
5098 +        -[LRuY])
5099 +          # These flags, when seen by themselves, take an argument.
5100 +          # We remove the space between option and argument and re-iterate
5101 +          # unless we find an empty arg or a new option (starting with -)
5102 +          case $2 in
5103 +             "" | -*);;
5104 +             *)
5105 +                ac_arg="$ac_arg$2"
5106 +                shift; shift
5107 +                set X $ac_arg "$@"
5108 +                ;;
5109 +          esac
5110 +          ;;
5111 +        -YP,*)
5112 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5113 +              ac_exists=false
5114 +  for ac_i in $ac_cv_fc_libs; do
5115 +    if test x"$ac_j" = x"$ac_i"; then
5116 +      ac_exists=true
5117 +      break
5118 +    fi
5119 +  done
5120 +
5121 +  if test x"$ac_exists" = xtrue; then
5122 +  :
5123 + else
5124 +  ac_arg="$ac_arg $ac_j"
5125 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5126 + fi
5127 +
5128 +          done
5129 +          ;;
5130 +        -[lLR]*)
5131 +            ac_exists=false
5132 +  for ac_i in $ac_cv_fc_libs; do
5133 +    if test x"$ac_arg" = x"$ac_i"; then
5134 +      ac_exists=true
5135 +      break
5136 +    fi
5137 +  done
5138 +
5139 +  if test x"$ac_exists" = xtrue; then
5140 +  :
5141 + else
5142 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5143 + fi
5144 +
5145 +          ;;
5146 +          # Ignore everything else.
5147 +  esac
5148 + done
5149 + # restore positional arguments
5150 + set X $ac_save_positional; shift
5151 +
5152 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5153 + # then we insist that the "run path" must be an absolute path (i.e. it
5154 + # must begin with a "/").
5155 + case `(uname -sr) 2>/dev/null` in
5156 +   "SunOS 5"*)
5157 +      ac_ld_run_path=`echo $ac_fc_v_output |
5158 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5159 +      test "x$ac_ld_run_path" != x &&
5160 +        if test "$ac_compiler_gnu" = yes; then
5161 +  for ac_link_opt in $ac_ld_run_path; do
5162 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5163 +  done
5164 + else
5165 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5166 + fi
5167 +      ;;
5168   esac
5169 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5170  
5171 + fi
5172 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5173 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5174 + FCLIBS="$ac_cv_fc_libs"
5175  
5176  
5177 + ac_ext=${FC_SRCEXT-f}
5178 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5179 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5180 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5181  
5182  
5183 +
5184   echo "$as_me:$LINENO: checking for module suffix" >&5
5185   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5186   rm -f conftest*
5187   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5188   rm -f work*
5189 < cat >conftest.f90 <<EOF
5189 > cat >conftest.$ac_ext <<EOF
5190          module conftest
5191          integer n
5192          parameter (n=1)
# Line 4400 | Line 5195 | modcase="lower"
5195   # SGI and absoft compilers generates module name in upper case!
5196   testname="conftest"
5197   modcase="lower"
5198 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5199 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5198 > if (eval $ac_compile) 2>/dev/null ; then
5199 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5200      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5201      if test -z "$MOD" ; then
5202          MOD=`ls CONFTEST* 2>/dev/null \
5203 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5203 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5204          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5205          if test -n "$MOD" ; then
5206              testname="CONFTEST"
# Line 4445 | Line 5240 | rm -f work*
5240   rm -f conftest*
5241   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5242   rm -f work*
5243 < cat >conftest.f90 <<EOF
5243 > cat >conftest.$ac_ext <<EOF
5244          module conftest
5245          integer n
5246          parameter (n=1)
# Line 4453 | Line 5248 | testname="conftest"
5248   EOF
5249   # SGI and absoft compilers generates module name in upper case!
5250   testname="conftest"
5251 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5252 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5251 > if (eval $ac_compile) 2>/dev/null ; then
5252 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5253     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5254     if test -n "$mod" ; then
5255        testname="CONFTEST"
# Line 4463 | Line 5258 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5258     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5259     cp $testname.$MOD conf
5260     rm -f conftest* CONFTEST*
5261 <   cat >conftest1.f90 <<EOF
5261 >   cat >conftest1.$ac_ext <<EOF
5262          program main
5263          use conftest
5264          print *, n
# Line 4471 | Line 5266 | EOF
5266   EOF
5267     F90_WORK_FILES_ARG=""
5268     F90MODINCSPEC=""
5269 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5269 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5270         MODDIRFLAG="-I"
5271         F90MODINCSPEC="-I<dir>"
5272         echo "$as_me:$LINENO: result: -I" >&5
5273   echo "${ECHO_T}-I" >&6
5274 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5274 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5275         MODDIRFLAG="-M"
5276         F90MODINCSPEC="-M<dir>"
5277         echo "$as_me:$LINENO: result: -M" >&5
5278   echo "${ECHO_T}-M" >&6
5279 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5279 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5280         MODDIRFLAG="-p"
5281         F90MODINCSPEC="-p<dir>"
5282         echo "$as_me:$LINENO: result: -p" >&5
# Line 4490 | Line 5285 | echo "${ECHO_T}-p" >&6
5285          cp work.pc conf/mpimod.pc
5286          echo "mpimod.pc" > conf/mpimod.pcl
5287          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5288 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5288 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5289              MODDIRFLAG='-cl,mpimod.pcl'
5290              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5291   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4520 | Line 5315 | else
5315   if test "${ac_cv_f90_module_names+set}" = set; then
5316    echo $ECHO_N "(cached) $ECHO_C" >&6
5317   else
5318 <  ac_ext=f90
5319 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5320 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5321 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5318 >  ac_ext=${FC_SRCEXT-f}
5319 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5320 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5321 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5322  
5323   # carry out the test in a new directory, so that we don't miss anything
5324   mkdir conftest
# Line 4541 | Line 5336 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5336    cat conftest.err >&5
5337    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5338    (exit $ac_status); } &&
5339 <         { ac_try='test -z "$ac_f90_werror_flag"
5339 >         { ac_try='test -z "$ac_fc_werror_flag"
5340                           || test ! -s conftest.err'
5341    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5342    (eval $ac_try) 2>&5
# Line 4657 | Line 5452 | rm -rf conftest
5452   cd ..
5453   # cleanup
5454   rm -rf conftest
5455 < ac_ext=f90
5456 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5457 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5458 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5455 > ac_ext=${FC_SRCEXT-f}
5456 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5457 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5458 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5459  
5460   fi
5461   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4749 | Line 5544 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5544   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5545  
5546  
5547 < ac_ext=cc
5548 < ac_cpp='$CXXCPP $CPPFLAGS'
5549 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5550 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5551 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5547 > ac_ext=c
5548 > ac_cpp='$CPP $CPPFLAGS'
5549 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5550 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5551 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5552  
5553  
5554 < ac_ext=cc
5555 < ac_cpp='$CXXCPP $CPPFLAGS'
5556 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5557 < 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
5554 >
5555 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5556 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5557 > if test "${ac_cv_lib_m_asin+set}" = set; then
5558    echo $ECHO_N "(cached) $ECHO_C" >&6
5559   else
5560 <      # Double quotes because CXXCPP needs to be expanded
5561 <    for CXXCPP in "$CXX -E" "/lib/cpp"
5562 <    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
5560 >  ac_check_lib_save_LIBS=$LIBS
5561 > LIBS="-lm  $LIBS"
5562 > cat >conftest.$ac_ext <<_ACEOF
5563   /* confdefs.h.  */
5564   _ACEOF
5565   cat confdefs.h >>conftest.$ac_ext
5566   cat >>conftest.$ac_ext <<_ACEOF
5567   /* end confdefs.h.  */
5568 < #ifdef __STDC__
5569 < # include <limits.h>
5570 < #else
5571 < # include <assert.h>
5568 >
5569 > /* Override any gcc2 internal prototype to avoid an error.  */
5570 > #ifdef __cplusplus
5571 > extern "C"
5572   #endif
5573 <                     Syntax error
5573 > /* We use char because int might match the return type of a gcc2
5574 >   builtin and then its argument prototype would still apply.  */
5575 > char asin ();
5576 > #ifdef FC_DUMMY_MAIN
5577 > #ifndef FC_DUMMY_MAIN_EQ_F77
5578 > #  ifdef __cplusplus
5579 >     extern "C"
5580 > #  endif
5581 >   int FC_DUMMY_MAIN() { return 1; }
5582 > #endif
5583 > #endif
5584 > int
5585 > main ()
5586 > {
5587 > asin ();
5588 >  ;
5589 >  return 0;
5590 > }
5591   _ACEOF
5592 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5593 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5592 > rm -f conftest.$ac_objext conftest$ac_exeext
5593 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5594 >  (eval $ac_link) 2>conftest.er1
5595    ac_status=$?
5596    grep -v '^ *+' conftest.er1 >conftest.err
5597    rm -f conftest.er1
5598    cat conftest.err >&5
5599    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5600 <  (exit $ac_status); } >/dev/null; then
5601 <  if test -s conftest.err; then
5602 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5603 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5604 <  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
5600 >  (exit $ac_status); } &&
5601 >         { ac_try='test -z "$ac_c_werror_flag"
5602 >                         || test ! -s conftest.err'
5603 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5604 >  (eval $ac_try) 2>&5
5605    ac_status=$?
4836  grep -v '^ *+' conftest.er1 >conftest.err
4837  rm -f conftest.er1
4838  cat conftest.err >&5
5606    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5607 <  (exit $ac_status); } >/dev/null; then
5608 <  if test -s conftest.err; then
5609 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5610 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5611 <  else
5612 <    ac_cpp_err=
5613 <  fi
5607 >  (exit $ac_status); }; } &&
5608 >         { ac_try='test -s conftest$ac_exeext'
5609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5610 >  (eval $ac_try) 2>&5
5611 >  ac_status=$?
5612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5613 >  (exit $ac_status); }; }; then
5614 >  ac_cv_lib_m_asin=yes
5615   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
5616    echo "$as_me: failed program was:" >&5
5617   sed 's/^/| /' conftest.$ac_ext >&5
5618  
5619 <  # Passes both tests.
4858 < ac_preproc_ok=:
4859 < break
5619 > ac_cv_lib_m_asin=no
5620   fi
5621 < rm -f conftest.err conftest.$ac_ext
5622 <
5623 < 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
5621 > rm -f conftest.err conftest.$ac_objext \
5622 >      conftest$ac_exeext conftest.$ac_ext
5623 > LIBS=$ac_check_lib_save_LIBS
5624   fi
5625 + echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5626 + echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5627 + if test $ac_cv_lib_m_asin = yes; then
5628 +  cat >>confdefs.h <<_ACEOF
5629 + #define HAVE_LIBM 1
5630 + _ACEOF
5631  
5632 <    done
4871 <    ac_cv_prog_CXXCPP=$CXXCPP
5632 >  LIBS="-lm $LIBS"
5633  
4873 fi
4874  CXXCPP=$ac_cv_prog_CXXCPP
5634   else
5635 <  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
5635 >  exit
5636   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
5637  
4925  # Broken: fails on valid input.
4926 continue
4927 fi
4928 rm -f conftest.err conftest.$ac_ext
5638  
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
5639   echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5640   echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5641   if test "${ac_cv_header_stdc+set}" = set; then
# Line 5003 | Line 5652 | cat >>conftest.$ac_ext <<_ACEOF
5652   #include <string.h>
5653   #include <float.h>
5654  
5655 + #ifdef FC_DUMMY_MAIN
5656 + #ifndef FC_DUMMY_MAIN_EQ_F77
5657 + #  ifdef __cplusplus
5658 +     extern "C"
5659 + #  endif
5660 +   int FC_DUMMY_MAIN() { return 1; }
5661 + #endif
5662 + #endif
5663   int
5664   main ()
5665   {
# Line 5020 | Line 5677 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5677    cat conftest.err >&5
5678    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5679    (exit $ac_status); } &&
5680 <         { ac_try='test -z "$ac_cxx_werror_flag"
5680 >         { ac_try='test -z "$ac_c_werror_flag"
5681                           || test ! -s conftest.err'
5682    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5683    (eval $ac_try) 2>&5
# Line 5149 | Line 5806 | cat >>confdefs.h <<\_ACEOF
5806  
5807   cat >>confdefs.h <<\_ACEOF
5808   #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
5809   _ACEOF
5810  
5811   fi
# Line 5267 | Line 5848 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5848    cat conftest.err >&5
5849    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5850    (exit $ac_status); } &&
5851 <         { ac_try='test -z "$ac_cxx_werror_flag"
5851 >         { ac_try='test -z "$ac_c_werror_flag"
5852                           || test ! -s conftest.err'
5853    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5854    (eval $ac_try) 2>&5
# Line 5301 | Line 5882 | done
5882   done
5883  
5884  
5885 < echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
5886 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
5887 < if test "${ac_cv_cxx_have_stl+set}" = set; then
5888 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5885 > #
5886 > # Handle user hints
5887 > #
5888 >
5889 > # Check whether --with-zlib or --without-zlib was given.
5890 > if test "${with_zlib+set}" = set; then
5891 >  withval="$with_zlib"
5892 >  zlib_dir="$withval"
5893   else
5894 +                zlib_dir="not_set"
5895 + fi;
5896 + if test "$zlib_dir" != "no"; then
5897  
5898 + if test "$zlib_dir" != "not_set" ; then
5899 +  if test -d "$zlib_dir"
5900 +  then
5901 +    ZLIB_HOME="$zlib_dir"
5902 +  else
5903 +    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5904 + echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5905 +  fi
5906 + fi
5907  
5908 + ZLIB_HOME=/usr/local
5909 + if test ! -f "${ZLIB_HOME}/include/zlib.h"
5910 + then
5911 +        ZLIB_HOME=/usr
5912 + fi
5913  
5914 < ac_ext=cc
5915 < ac_cpp='$CXXCPP $CPPFLAGS'
5916 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5917 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5918 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5914 > #
5915 > # Locate zlib, if wanted
5916 > #
5917 > if test -n "${ZLIB_HOME}"
5918 > then
5919 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5920 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5921 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5922 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5923  
5924 < cat >conftest.$ac_ext <<_ACEOF
5924 >
5925 >        ac_ext=c
5926 > ac_cpp='$CPP $CPPFLAGS'
5927 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5928 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5929 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5930 >
5931 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5932 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5933 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5934 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5935 > else
5936 >  ac_check_lib_save_LIBS=$LIBS
5937 > LIBS="-lz  $LIBS"
5938 > cat >conftest.$ac_ext <<_ACEOF
5939   /* confdefs.h.  */
5940   _ACEOF
5941   cat confdefs.h >>conftest.$ac_ext
5942   cat >>conftest.$ac_ext <<_ACEOF
5943   /* end confdefs.h.  */
5944 < #include <list>
5945 < #include <deque>
5946 < #ifdef HAVE_NAMESPACES
5947 < using namespace std;
5944 >
5945 > /* Override any gcc2 internal prototype to avoid an error.  */
5946 > #ifdef __cplusplus
5947 > extern "C"
5948   #endif
5949 + /* We use char because int might match the return type of a gcc2
5950 +   builtin and then its argument prototype would still apply.  */
5951 + char inflateEnd ();
5952 + #ifdef FC_DUMMY_MAIN
5953 + #ifndef FC_DUMMY_MAIN_EQ_F77
5954 + #  ifdef __cplusplus
5955 +     extern "C"
5956 + #  endif
5957 +   int FC_DUMMY_MAIN() { return 1; }
5958 + #endif
5959 + #endif
5960   int
5961   main ()
5962   {
5963 < list<int> x; x.push_back(5);
5333 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
5963 > inflateEnd ();
5964    ;
5965    return 0;
5966   }
5967   _ACEOF
5968 < rm -f conftest.$ac_objext
5969 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5970 <  (eval $ac_compile) 2>conftest.er1
5968 > rm -f conftest.$ac_objext conftest$ac_exeext
5969 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5970 >  (eval $ac_link) 2>conftest.er1
5971    ac_status=$?
5972    grep -v '^ *+' conftest.er1 >conftest.err
5973    rm -f conftest.er1
5974    cat conftest.err >&5
5975    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5976    (exit $ac_status); } &&
5977 <         { ac_try='test -z "$ac_cxx_werror_flag"
5977 >         { ac_try='test -z "$ac_c_werror_flag"
5978                           || test ! -s conftest.err'
5979    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5980    (eval $ac_try) 2>&5
5981    ac_status=$?
5982    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5983    (exit $ac_status); }; } &&
5984 <         { ac_try='test -s conftest.$ac_objext'
5984 >         { ac_try='test -s conftest$ac_exeext'
5985    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5986    (eval $ac_try) 2>&5
5987    ac_status=$?
5988    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5989    (exit $ac_status); }; }; then
5990 <  ac_cv_cxx_have_stl=yes
5990 >  ac_cv_lib_z_inflateEnd=yes
5991   else
5992    echo "$as_me: failed program was:" >&5
5993   sed 's/^/| /' conftest.$ac_ext >&5
5994  
5995 < 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
5373 <
5374 <
5995 > ac_cv_lib_z_inflateEnd=no
5996   fi
5997 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
5998 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
5999 < if test "$ac_cv_cxx_have_stl" = yes; then
5379 <
5380 < cat >>confdefs.h <<\_ACEOF
5381 < #define HAVE_STL
5382 < _ACEOF
5383 <
5997 > rm -f conftest.err conftest.$ac_objext \
5998 >      conftest$ac_exeext conftest.$ac_ext
5999 > LIBS=$ac_check_lib_save_LIBS
6000   fi
6001 + echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6002 + echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6003 + if test $ac_cv_lib_z_inflateEnd = yes; then
6004 +  zlib_cv_libz=yes
6005 + else
6006 +  zlib_cv_libz=no
6007 + fi
6008  
6009 <
6010 <
6011 <  if test "${ac_cv_header_iostream+set}" = set; then
6012 <  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
6009 >        if test "${ac_cv_header_zlib_h+set}" = set; then
6010 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
6011 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6012 > if test "${ac_cv_header_zlib_h+set}" = set; then
6013    echo $ECHO_N "(cached) $ECHO_C" >&6
6014   fi
6015 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6016 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
6015 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6016 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6017   else
6018    # Is the header compilable?
6019 < echo "$as_me:$LINENO: checking iostream usability" >&5
6020 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
6019 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
6020 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
6021   cat >conftest.$ac_ext <<_ACEOF
6022   /* confdefs.h.  */
6023   _ACEOF
# Line 5404 | Line 6025 | $ac_includes_default
6025   cat >>conftest.$ac_ext <<_ACEOF
6026   /* end confdefs.h.  */
6027   $ac_includes_default
6028 < #include <iostream>
6028 > #include <zlib.h>
6029   _ACEOF
6030   rm -f conftest.$ac_objext
6031   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5415 | Line 6036 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6036    cat conftest.err >&5
6037    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6038    (exit $ac_status); } &&
6039 <         { ac_try='test -z "$ac_cxx_werror_flag"
6039 >         { ac_try='test -z "$ac_c_werror_flag"
6040                           || test ! -s conftest.err'
6041    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6042    (eval $ac_try) 2>&5
# Line 5440 | Line 6061 | echo "${ECHO_T}$ac_header_compiler" >&6
6061   echo "${ECHO_T}$ac_header_compiler" >&6
6062  
6063   # Is the header present?
6064 < echo "$as_me:$LINENO: checking iostream presence" >&5
6065 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
6064 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
6065 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6066   cat >conftest.$ac_ext <<_ACEOF
6067   /* confdefs.h.  */
6068   _ACEOF
6069   cat confdefs.h >>conftest.$ac_ext
6070   cat >>conftest.$ac_ext <<_ACEOF
6071   /* end confdefs.h.  */
6072 < #include <iostream>
6072 > #include <zlib.h>
6073   _ACEOF
6074   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6075    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5459 | Line 6080 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6080    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6081    (exit $ac_status); } >/dev/null; then
6082    if test -s conftest.err; then
6083 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6084 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6083 >    ac_cpp_err=$ac_c_preproc_warn_flag
6084 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6085    else
6086      ac_cpp_err=
6087    fi
# Line 5480 | Line 6101 | echo "${ECHO_T}$ac_header_preproc" >&6
6101   echo "${ECHO_T}$ac_header_preproc" >&6
6102  
6103   # So?  What about this header?
6104 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6104 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6105    yes:no: )
6106 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
6107 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
6108 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
6109 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
6106 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6107 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6108 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6109 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6110      ac_header_preproc=yes
6111      ;;
6112    no:yes:* )
6113 <    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
6114 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
6115 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
6116 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
6117 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
6118 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
6119 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
6120 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
6121 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
6122 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
6123 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
6124 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
6113 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6114 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6115 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6116 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6117 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6118 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6119 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6120 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6121 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6122 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6123 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6124 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6125      (
6126        cat <<\_ASBOX
6127   ## ------------------------------ ##
# Line 5511 | Line 6132 | esac
6132        sed "s/^/$as_me: WARNING:     /" >&2
6133      ;;
6134   esac
6135 < echo "$as_me:$LINENO: checking for iostream" >&5
6136 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
6137 < if test "${ac_cv_header_iostream+set}" = set; then
6135 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6136 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6137 > if test "${ac_cv_header_zlib_h+set}" = set; then
6138    echo $ECHO_N "(cached) $ECHO_C" >&6
6139   else
6140 <  ac_cv_header_iostream=$ac_header_preproc
6140 >  ac_cv_header_zlib_h=$ac_header_preproc
6141   fi
6142 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6143 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
6142 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6143 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6144  
6145   fi
6146 < if test $ac_cv_header_iostream = yes; then
6146 > if test $ac_cv_header_zlib_h = yes; then
6147 >  zlib_cv_zlib_h=yes
6148 > else
6149 >  zlib_cv_zlib_h=no
6150 > fi
6151  
6152  
6153 +        ac_ext=c
6154 + ac_cpp='$CPP $CPPFLAGS'
6155 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6156 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6157 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
6158 +
6159 +
6160 +        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6161 +
6162   cat >>confdefs.h <<\_ACEOF
6163 < #define HAVE_IOSTREAM 1
6163 > #define HAVE_ZLIB_H 1
6164   _ACEOF
6165  
6166  
6167 + cat >>confdefs.h <<\_ACEOF
6168 + #define HAVE_LIBZ 1
6169 + _ACEOF
6170 +
6171 +                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6172 +                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6173 +                ZLIB="-lz"
6174 +        else
6175 +                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6176 + echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6177 +                ZLIB_INC_DIR=
6178 +                ZLIB_LIB_DIR=
6179 +                ZLIB=
6180 +                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6181 +                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6182 +                echo "$as_me:$LINENO: result: failed" >&5
6183 + echo "${ECHO_T}failed" >&6
6184 +                echo ""
6185 +                echo "*********************************************************"
6186 +                echo "* WARNING: Could not find a working zlib installation   *"
6187 +                echo "* If you need OOPSE to be able to deal with compressed  *"
6188 +                echo "* trajectory dump files be sure to specify a valid zlib *"
6189 +                echo "* installation with --with-zlib=DIR                     *"
6190 +                echo "*                                                       *"
6191 +                echo "* OOPSE will still work without zlib installed.         *"
6192 +                echo "*********************************************************"
6193 +                echo ""
6194 +        fi
6195 +
6196 +
6197 +
6198 + fi
6199 + fi
6200 +
6201 + #
6202 + # Handle user hints
6203 + #
6204 +
6205 + # Check whether --with-fftw or --without-fftw was given.
6206 + if test "${with_fftw+set}" = set; then
6207 +  withval="$with_fftw"
6208 +  fftw_dir="$withval"
6209   else
6210 +             fftw_dir="not_set"
6211 + fi;
6212 + if test "$fftw_dir" != "no"; then
6213 +  if test "$fftw_dir" != "not_set" ; then
6214 +    if test -d "$fftw_dir"; then
6215 +      FFTW_HOME="$fftw_dir"
6216 +    else
6217 +      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6218 + echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6219 +      FFTW_HOME=/usr/local
6220 +      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6221 +        FFTW_HOME=/usr
6222 +      fi
6223 +    fi
6224 +    #
6225 +    # Locate fftw, if wanted
6226 +    #
6227 +    if test -n "${FFTW_HOME}"; then
6228 +      FFTW_OLD_LDFLAGS=$LDFLAGS
6229 +      FFTW_OLD_CPPFLAGS=$LDFLAGS
6230 +      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6231 +      CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6232  
6233  
6234 < for ac_header in iostream.h
6235 < do
6236 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6237 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6238 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6239 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6240 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6234 >      ac_ext=c
6235 > ac_cpp='$CPP $CPPFLAGS'
6236 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6237 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6238 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6239 >
6240 >      echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6241 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6242 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6243    echo $ECHO_N "(cached) $ECHO_C" >&6
6244 + else
6245 +  ac_check_lib_save_LIBS=$LIBS
6246 + LIBS="-lfftw3  $LIBS"
6247 + cat >conftest.$ac_ext <<_ACEOF
6248 + /* confdefs.h.  */
6249 + _ACEOF
6250 + cat confdefs.h >>conftest.$ac_ext
6251 + cat >>conftest.$ac_ext <<_ACEOF
6252 + /* end confdefs.h.  */
6253 +
6254 + /* Override any gcc2 internal prototype to avoid an error.  */
6255 + #ifdef __cplusplus
6256 + extern "C"
6257 + #endif
6258 + /* We use char because int might match the return type of a gcc2
6259 +   builtin and then its argument prototype would still apply.  */
6260 + char fftw_execute ();
6261 + #ifdef FC_DUMMY_MAIN
6262 + #ifndef FC_DUMMY_MAIN_EQ_F77
6263 + #  ifdef __cplusplus
6264 +     extern "C"
6265 + #  endif
6266 +   int FC_DUMMY_MAIN() { return 1; }
6267 + #endif
6268 + #endif
6269 + int
6270 + main ()
6271 + {
6272 + fftw_execute ();
6273 +  ;
6274 +  return 0;
6275 + }
6276 + _ACEOF
6277 + rm -f conftest.$ac_objext conftest$ac_exeext
6278 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6279 +  (eval $ac_link) 2>conftest.er1
6280 +  ac_status=$?
6281 +  grep -v '^ *+' conftest.er1 >conftest.err
6282 +  rm -f conftest.er1
6283 +  cat conftest.err >&5
6284 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6285 +  (exit $ac_status); } &&
6286 +         { ac_try='test -z "$ac_c_werror_flag"
6287 +                         || test ! -s conftest.err'
6288 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6289 +  (eval $ac_try) 2>&5
6290 +  ac_status=$?
6291 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6292 +  (exit $ac_status); }; } &&
6293 +         { ac_try='test -s conftest$ac_exeext'
6294 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6295 +  (eval $ac_try) 2>&5
6296 +  ac_status=$?
6297 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6298 +  (exit $ac_status); }; }; then
6299 +  ac_cv_lib_fftw3_fftw_execute=yes
6300 + else
6301 +  echo "$as_me: failed program was:" >&5
6302 + sed 's/^/| /' conftest.$ac_ext >&5
6303 +
6304 + ac_cv_lib_fftw3_fftw_execute=no
6305   fi
6306 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6307 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6306 > rm -f conftest.err conftest.$ac_objext \
6307 >      conftest$ac_exeext conftest.$ac_ext
6308 > LIBS=$ac_check_lib_save_LIBS
6309 > fi
6310 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6311 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6312 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6313 >  fftw_cv_libfftw3=yes
6314   else
6315 +  fftw_cv_libfftw3=no
6316 + fi
6317 +
6318 +      if test "${ac_cv_header_fftw3_h+set}" = set; then
6319 +  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6320 + echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6321 + if test "${ac_cv_header_fftw3_h+set}" = set; then
6322 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6323 + fi
6324 + echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6325 + echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6326 + else
6327    # Is the header compilable?
6328 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6329 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6328 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6329 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6330   cat >conftest.$ac_ext <<_ACEOF
6331   /* confdefs.h.  */
6332   _ACEOF
# Line 5555 | Line 6334 | $ac_includes_default
6334   cat >>conftest.$ac_ext <<_ACEOF
6335   /* end confdefs.h.  */
6336   $ac_includes_default
6337 < #include <$ac_header>
6337 > #include <fftw3.h>
6338   _ACEOF
6339   rm -f conftest.$ac_objext
6340   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5566 | Line 6345 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6345    cat conftest.err >&5
6346    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6347    (exit $ac_status); } &&
6348 <         { ac_try='test -z "$ac_cxx_werror_flag"
6348 >         { ac_try='test -z "$ac_c_werror_flag"
6349                           || test ! -s conftest.err'
6350    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6351    (eval $ac_try) 2>&5
# Line 5591 | Line 6370 | echo "${ECHO_T}$ac_header_compiler" >&6
6370   echo "${ECHO_T}$ac_header_compiler" >&6
6371  
6372   # Is the header present?
6373 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6374 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6373 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6374 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6375   cat >conftest.$ac_ext <<_ACEOF
6376   /* confdefs.h.  */
6377   _ACEOF
6378   cat confdefs.h >>conftest.$ac_ext
6379   cat >>conftest.$ac_ext <<_ACEOF
6380   /* end confdefs.h.  */
6381 < #include <$ac_header>
6381 > #include <fftw3.h>
6382   _ACEOF
6383   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6384    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5610 | Line 6389 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6389    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6390    (exit $ac_status); } >/dev/null; then
6391    if test -s conftest.err; then
6392 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6393 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6392 >    ac_cpp_err=$ac_c_preproc_warn_flag
6393 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6394    else
6395      ac_cpp_err=
6396    fi
# Line 5631 | Line 6410 | echo "${ECHO_T}$ac_header_preproc" >&6
6410   echo "${ECHO_T}$ac_header_preproc" >&6
6411  
6412   # So?  What about this header?
6413 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6413 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6414    yes:no: )
6415 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6416 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6417 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6418 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6415 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6416 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6417 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6418 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6419      ac_header_preproc=yes
6420      ;;
6421    no:yes:* )
6422 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6423 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6424 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6425 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6426 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6427 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6428 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6429 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6430 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6431 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6432 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6433 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6422 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6423 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6424 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6425 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6426 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6427 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6428 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6429 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6430 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6431 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6432 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6433 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6434      (
6435        cat <<\_ASBOX
6436   ## ------------------------------ ##
# Line 5662 | Line 6441 | esac
6441        sed "s/^/$as_me: WARNING:     /" >&2
6442      ;;
6443   esac
6444 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6445 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6446 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6444 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6445 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6446 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6447    echo $ECHO_N "(cached) $ECHO_C" >&6
6448   else
6449 <  eval "$as_ac_Header=\$ac_header_preproc"
6449 >  ac_cv_header_fftw3_h=$ac_header_preproc
6450   fi
6451 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6452 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6451 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6452 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6453  
6454   fi
6455 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6456 <  cat >>confdefs.h <<_ACEOF
6457 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6458 < _ACEOF
5680 <
6455 > if test $ac_cv_header_fftw3_h = yes; then
6456 >  fftw_cv_fftw3_h=yes
6457 > else
6458 >  fftw_cv_fftw3_h=no
6459   fi
6460  
5683 done
6461  
6462 +      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6463 +        echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6464 + echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6465 + if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6466 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6467 + else
6468 +  ac_check_lib_save_LIBS=$LIBS
6469 + LIBS="-lfftw  $LIBS"
6470 + cat >conftest.$ac_ext <<_ACEOF
6471 + /* confdefs.h.  */
6472 + _ACEOF
6473 + cat confdefs.h >>conftest.$ac_ext
6474 + cat >>conftest.$ac_ext <<_ACEOF
6475 + /* end confdefs.h.  */
6476  
6477 < fi
6478 <
6479 <
6477 > /* Override any gcc2 internal prototype to avoid an error.  */
6478 > #ifdef __cplusplus
6479 > extern "C"
6480 > #endif
6481 > /* We use char because int might match the return type of a gcc2
6482 >   builtin and then its argument prototype would still apply.  */
6483 > char fftwnd_one ();
6484 > #ifdef FC_DUMMY_MAIN
6485 > #ifndef FC_DUMMY_MAIN_EQ_F77
6486 > #  ifdef __cplusplus
6487 >     extern "C"
6488 > #  endif
6489 >   int FC_DUMMY_MAIN() { return 1; }
6490 > #endif
6491 > #endif
6492 > int
6493 > main ()
6494 > {
6495 > fftwnd_one ();
6496 >  ;
6497 >  return 0;
6498 > }
6499 > _ACEOF
6500 > rm -f conftest.$ac_objext conftest$ac_exeext
6501 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6502 >  (eval $ac_link) 2>conftest.er1
6503 >  ac_status=$?
6504 >  grep -v '^ *+' conftest.er1 >conftest.err
6505 >  rm -f conftest.er1
6506 >  cat conftest.err >&5
6507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508 >  (exit $ac_status); } &&
6509 >         { ac_try='test -z "$ac_c_werror_flag"
6510 >                         || test ! -s conftest.err'
6511 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6512 >  (eval $ac_try) 2>&5
6513 >  ac_status=$?
6514 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6515 >  (exit $ac_status); }; } &&
6516 >         { ac_try='test -s conftest$ac_exeext'
6517 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6518 >  (eval $ac_try) 2>&5
6519 >  ac_status=$?
6520 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6521 >  (exit $ac_status); }; }; then
6522 >  ac_cv_lib_fftw_fftwnd_one=yes
6523 > else
6524 >  echo "$as_me: failed program was:" >&5
6525 > sed 's/^/| /' conftest.$ac_ext >&5
6526  
6527 + ac_cv_lib_fftw_fftwnd_one=no
6528 + fi
6529 + rm -f conftest.err conftest.$ac_objext \
6530 +      conftest$ac_exeext conftest.$ac_ext
6531 + LIBS=$ac_check_lib_save_LIBS
6532 + fi
6533 + echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6534 + echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6535 + if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6536 +  fftw_cv_libfftw=yes
6537 + else
6538 +  fftw_cv_libfftw=no
6539 + fi
6540  
6541 <  if test "${ac_cv_header_iomanip+set}" = set; then
6542 <  echo "$as_me:$LINENO: checking for iomanip" >&5
6543 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
6544 < if test "${ac_cv_header_iomanip+set}" = set; then
6541 >        if test "${ac_cv_header_fftw_h+set}" = set; then
6542 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6543 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6544 > if test "${ac_cv_header_fftw_h+set}" = set; then
6545    echo $ECHO_N "(cached) $ECHO_C" >&6
6546   fi
6547 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
6548 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6547 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6548 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6549   else
6550    # Is the header compilable?
6551 < echo "$as_me:$LINENO: checking iomanip usability" >&5
6552 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
6551 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6552 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6553   cat >conftest.$ac_ext <<_ACEOF
6554   /* confdefs.h.  */
6555   _ACEOF
# Line 5707 | Line 6557 | $ac_includes_default
6557   cat >>conftest.$ac_ext <<_ACEOF
6558   /* end confdefs.h.  */
6559   $ac_includes_default
6560 < #include <iomanip>
6560 > #include <fftw.h>
6561   _ACEOF
6562   rm -f conftest.$ac_objext
6563   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5718 | Line 6568 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6568    cat conftest.err >&5
6569    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6570    (exit $ac_status); } &&
6571 <         { ac_try='test -z "$ac_cxx_werror_flag"
6571 >         { ac_try='test -z "$ac_c_werror_flag"
6572                           || test ! -s conftest.err'
6573    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6574    (eval $ac_try) 2>&5
# Line 5743 | Line 6593 | echo "${ECHO_T}$ac_header_compiler" >&6
6593   echo "${ECHO_T}$ac_header_compiler" >&6
6594  
6595   # Is the header present?
6596 < echo "$as_me:$LINENO: checking iomanip presence" >&5
6597 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
6596 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6597 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6598   cat >conftest.$ac_ext <<_ACEOF
6599   /* confdefs.h.  */
6600   _ACEOF
6601   cat confdefs.h >>conftest.$ac_ext
6602   cat >>conftest.$ac_ext <<_ACEOF
6603   /* end confdefs.h.  */
6604 < #include <iomanip>
6604 > #include <fftw.h>
6605   _ACEOF
6606   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6607    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5762 | Line 6612 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6612    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6613    (exit $ac_status); } >/dev/null; then
6614    if test -s conftest.err; then
6615 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6616 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6615 >    ac_cpp_err=$ac_c_preproc_warn_flag
6616 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6617    else
6618      ac_cpp_err=
6619    fi
# Line 5783 | Line 6633 | echo "${ECHO_T}$ac_header_preproc" >&6
6633   echo "${ECHO_T}$ac_header_preproc" >&6
6634  
6635   # So?  What about this header?
6636 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6636 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6637    yes:no: )
6638 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
6639 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
6640 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
6641 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
6638 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6639 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6640 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6641 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6642      ac_header_preproc=yes
6643      ;;
6644    no:yes:* )
6645 <    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
6646 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
6647 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
6648 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
6649 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
6650 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
6651 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
6652 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
6653 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
6654 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
6655 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
6656 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
6645 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6646 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6647 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6648 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6649 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6650 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6651 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6652 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6653 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6654 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6655 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6656 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6657      (
6658        cat <<\_ASBOX
6659   ## ------------------------------ ##
# Line 5814 | Line 6664 | esac
6664        sed "s/^/$as_me: WARNING:     /" >&2
6665      ;;
6666   esac
6667 < echo "$as_me:$LINENO: checking for iomanip" >&5
6668 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
6669 < if test "${ac_cv_header_iomanip+set}" = set; then
6667 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6668 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6669 > if test "${ac_cv_header_fftw_h+set}" = set; then
6670    echo $ECHO_N "(cached) $ECHO_C" >&6
6671   else
6672 <  ac_cv_header_iomanip=$ac_header_preproc
6673 < fi
6674 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
6675 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
6672 >  ac_cv_header_fftw_h=$ac_header_preproc
6673 > fi
6674 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6675 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6676  
6677   fi
6678 < if test $ac_cv_header_iomanip = yes; then
6678 > if test $ac_cv_header_fftw_h = yes; then
6679 >  fftw_cv_fftw_h=yes
6680 > else
6681 >  fftw_cv_fftw_h=no
6682 > fi
6683  
6684  
6685 < cat >>confdefs.h <<\_ACEOF
6686 < #define HAVE_IOMANIP 1
6685 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6686 >          echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6687 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6688 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6689 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6690 > else
6691 >  ac_check_lib_save_LIBS=$LIBS
6692 > LIBS="-ldfftw  $LIBS"
6693 > cat >conftest.$ac_ext <<_ACEOF
6694 > /* confdefs.h.  */
6695   _ACEOF
6696 + cat confdefs.h >>conftest.$ac_ext
6697 + cat >>conftest.$ac_ext <<_ACEOF
6698 + /* end confdefs.h.  */
6699  
6700 + /* Override any gcc2 internal prototype to avoid an error.  */
6701 + #ifdef __cplusplus
6702 + extern "C"
6703 + #endif
6704 + /* We use char because int might match the return type of a gcc2
6705 +   builtin and then its argument prototype would still apply.  */
6706 + char fftwnd_one ();
6707 + #ifdef FC_DUMMY_MAIN
6708 + #ifndef FC_DUMMY_MAIN_EQ_F77
6709 + #  ifdef __cplusplus
6710 +     extern "C"
6711 + #  endif
6712 +   int FC_DUMMY_MAIN() { return 1; }
6713 + #endif
6714 + #endif
6715 + int
6716 + main ()
6717 + {
6718 + fftwnd_one ();
6719 +  ;
6720 +  return 0;
6721 + }
6722 + _ACEOF
6723 + rm -f conftest.$ac_objext conftest$ac_exeext
6724 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6725 +  (eval $ac_link) 2>conftest.er1
6726 +  ac_status=$?
6727 +  grep -v '^ *+' conftest.er1 >conftest.err
6728 +  rm -f conftest.er1
6729 +  cat conftest.err >&5
6730 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6731 +  (exit $ac_status); } &&
6732 +         { ac_try='test -z "$ac_c_werror_flag"
6733 +                         || test ! -s conftest.err'
6734 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6735 +  (eval $ac_try) 2>&5
6736 +  ac_status=$?
6737 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738 +  (exit $ac_status); }; } &&
6739 +         { ac_try='test -s conftest$ac_exeext'
6740 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6741 +  (eval $ac_try) 2>&5
6742 +  ac_status=$?
6743 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6744 +  (exit $ac_status); }; }; then
6745 +  ac_cv_lib_dfftw_fftwnd_one=yes
6746 + else
6747 +  echo "$as_me: failed program was:" >&5
6748 + sed 's/^/| /' conftest.$ac_ext >&5
6749  
6750 + ac_cv_lib_dfftw_fftwnd_one=no
6751 + fi
6752 + rm -f conftest.err conftest.$ac_objext \
6753 +      conftest$ac_exeext conftest.$ac_ext
6754 + LIBS=$ac_check_lib_save_LIBS
6755 + fi
6756 + echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6757 + echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6758 + if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6759 +  fftw_cv_libdfftw=yes
6760   else
6761 +  fftw_cv_libdfftw=no
6762 + fi
6763  
6764 <
6765 < for ac_header in iomanip.h
6766 < do
6767 < 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
6764 >          if test "${ac_cv_header_dfftw_h+set}" = set; then
6765 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6766 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6767 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6768    echo $ECHO_N "(cached) $ECHO_C" >&6
6769   fi
6770 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6771 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6770 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6771 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6772   else
6773    # Is the header compilable?
6774 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6775 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6774 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6775 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6776   cat >conftest.$ac_ext <<_ACEOF
6777   /* confdefs.h.  */
6778   _ACEOF
# Line 5858 | Line 6780 | $ac_includes_default
6780   cat >>conftest.$ac_ext <<_ACEOF
6781   /* end confdefs.h.  */
6782   $ac_includes_default
6783 < #include <$ac_header>
6783 > #include <dfftw.h>
6784   _ACEOF
6785   rm -f conftest.$ac_objext
6786   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5869 | Line 6791 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791    cat conftest.err >&5
6792    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6793    (exit $ac_status); } &&
6794 <         { ac_try='test -z "$ac_cxx_werror_flag"
6794 >         { ac_try='test -z "$ac_c_werror_flag"
6795                           || test ! -s conftest.err'
6796    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6797    (eval $ac_try) 2>&5
# Line 5894 | Line 6816 | echo "${ECHO_T}$ac_header_compiler" >&6
6816   echo "${ECHO_T}$ac_header_compiler" >&6
6817  
6818   # Is the header present?
6819 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6820 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6819 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6820 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6821   cat >conftest.$ac_ext <<_ACEOF
6822   /* confdefs.h.  */
6823   _ACEOF
6824   cat confdefs.h >>conftest.$ac_ext
6825   cat >>conftest.$ac_ext <<_ACEOF
6826   /* end confdefs.h.  */
6827 < #include <$ac_header>
6827 > #include <dfftw.h>
6828   _ACEOF
6829   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6830    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5913 | Line 6835 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6835    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6836    (exit $ac_status); } >/dev/null; then
6837    if test -s conftest.err; then
6838 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6839 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6838 >    ac_cpp_err=$ac_c_preproc_warn_flag
6839 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6840    else
6841      ac_cpp_err=
6842    fi
# Line 5934 | Line 6856 | echo "${ECHO_T}$ac_header_preproc" >&6
6856   echo "${ECHO_T}$ac_header_preproc" >&6
6857  
6858   # So?  What about this header?
6859 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6859 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6860    yes:no: )
6861 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6862 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6863 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6864 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6861 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6862 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6863 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6864 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6865      ac_header_preproc=yes
6866      ;;
6867    no:yes:* )
6868 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6869 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6870 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6871 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6872 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6873 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6874 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6875 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6876 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6877 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6878 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6879 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6868 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6869 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6870 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6871 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6872 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6873 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6874 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6875 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6876 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6877 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6878 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6879 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6880      (
6881        cat <<\_ASBOX
6882   ## ------------------------------ ##
# Line 5965 | Line 6887 | esac
6887        sed "s/^/$as_me: WARNING:     /" >&2
6888      ;;
6889   esac
6890 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6891 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6892 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6890 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6891 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6892 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6893    echo $ECHO_N "(cached) $ECHO_C" >&6
6894   else
6895 <  eval "$as_ac_Header=\$ac_header_preproc"
6895 >  ac_cv_header_dfftw_h=$ac_header_preproc
6896   fi
6897 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6898 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6897 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6898 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6899  
6900   fi
6901 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6902 <  cat >>confdefs.h <<_ACEOF
6903 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6901 > if test $ac_cv_header_dfftw_h = yes; then
6902 >  fftw_cv_dfftw_h=yes
6903 > else
6904 >  fftw_cv_dfftw_h=no
6905 > fi
6906 >
6907 >
6908 >        fi
6909 >      fi
6910 >      ac_ext=c
6911 > ac_cpp='$CPP $CPPFLAGS'
6912 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6913 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6914 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6915 >
6916 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6917 >
6918 > cat >>confdefs.h <<\_ACEOF
6919 > #define HAVE_FFTW3_H 1
6920   _ACEOF
6921  
6922 +        FFTW_INC_DIR="${FFTW_HOME}/include"
6923 +        FFTW_LIB_DIR="${FFTW_HOME}/lib"
6924 +        FFTW_LIBS="-lfftw3"
6925 +      else
6926 +        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6927 +
6928 + cat >>confdefs.h <<\_ACEOF
6929 + #define HAVE_FFTW_H 1
6930 + _ACEOF
6931 +
6932 +          FFTW_INC_DIR="${FFTW_HOME}/include"
6933 +          FFTW_LIB_DIR="${FFTW_HOME}/lib"
6934 +          FFTW_LIBS="-lfftw"
6935 +        else
6936 +          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6937 +
6938 + cat >>confdefs.h <<\_ACEOF
6939 + #define HAVE_DFFTW_H 1
6940 + _ACEOF
6941 +
6942 +            FFTW_INC_DIR="${FFTW_HOME}/include"
6943 +            FFTW_LIB_DIR="${FFTW_HOME}/lib"
6944 +            FFTW_LIBS="-ldfftw"
6945 +          else
6946 +            echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6947 + echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6948 +            FFTW_INC_DIR=
6949 +            FFTW_LIB_DIR=
6950 +            FFTW_LIBS=
6951 +            LDFLAGS="$FFTW_OLD_LDFLAGS"
6952 +            CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6953 +            echo "$as_me:$LINENO: result: failed" >&5
6954 + echo "${ECHO_T}failed" >&6
6955 +            echo ""
6956 +            echo "*********************************************************"
6957 +            echo "* WARNING: Could not find a working FFTW installation   *"
6958 +            echo "* If you need the staticProps program to be able to     *"
6959 +            echo "* compute undulation spectra, be sure to specify a      *"
6960 +            echo "* valid fftw installation with --with-fftw=DIR          *"
6961 +            echo "*                                                       *"
6962 +            echo "* OOPSE will still work without fftw installed.         *"
6963 +            echo "*********************************************************"
6964 +            echo ""
6965 +          fi
6966 +        fi
6967 +      fi
6968 +
6969 +
6970 +
6971 +    fi
6972 +  fi
6973   fi
6974  
5986 done
6975  
6976  
6977 + # Checks for header files.
6978 + echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6979 + echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6980 + if test "${ac_cv_header_stdc+set}" = set; then
6981 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6982 + else
6983 +  cat >conftest.$ac_ext <<_ACEOF
6984 + /* confdefs.h.  */
6985 + _ACEOF
6986 + cat confdefs.h >>conftest.$ac_ext
6987 + cat >>conftest.$ac_ext <<_ACEOF
6988 + /* end confdefs.h.  */
6989 + #include <stdlib.h>
6990 + #include <stdarg.h>
6991 + #include <string.h>
6992 + #include <float.h>
6993 +
6994 + #ifdef FC_DUMMY_MAIN
6995 + #ifndef FC_DUMMY_MAIN_EQ_F77
6996 + #  ifdef __cplusplus
6997 +     extern "C"
6998 + #  endif
6999 +   int FC_DUMMY_MAIN() { return 1; }
7000 + #endif
7001 + #endif
7002 + int
7003 + main ()
7004 + {
7005 +
7006 +  ;
7007 +  return 0;
7008 + }
7009 + _ACEOF
7010 + rm -f conftest.$ac_objext
7011 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7012 +  (eval $ac_compile) 2>conftest.er1
7013 +  ac_status=$?
7014 +  grep -v '^ *+' conftest.er1 >conftest.err
7015 +  rm -f conftest.er1
7016 +  cat conftest.err >&5
7017 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7018 +  (exit $ac_status); } &&
7019 +         { ac_try='test -z "$ac_c_werror_flag"
7020 +                         || test ! -s conftest.err'
7021 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7022 +  (eval $ac_try) 2>&5
7023 +  ac_status=$?
7024 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7025 +  (exit $ac_status); }; } &&
7026 +         { ac_try='test -s conftest.$ac_objext'
7027 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7028 +  (eval $ac_try) 2>&5
7029 +  ac_status=$?
7030 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7031 +  (exit $ac_status); }; }; then
7032 +  ac_cv_header_stdc=yes
7033 + else
7034 +  echo "$as_me: failed program was:" >&5
7035 + sed 's/^/| /' conftest.$ac_ext >&5
7036 +
7037 + ac_cv_header_stdc=no
7038   fi
7039 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7040  
7041 + if test $ac_cv_header_stdc = yes; then
7042 +  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7043 +  cat >conftest.$ac_ext <<_ACEOF
7044 + /* confdefs.h.  */
7045 + _ACEOF
7046 + cat confdefs.h >>conftest.$ac_ext
7047 + cat >>conftest.$ac_ext <<_ACEOF
7048 + /* end confdefs.h.  */
7049 + #include <string.h>
7050  
7051 + _ACEOF
7052 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7053 +  $EGREP "memchr" >/dev/null 2>&1; then
7054 +  :
7055 + else
7056 +  ac_cv_header_stdc=no
7057 + fi
7058 + rm -f conftest*
7059  
7060 + fi
7061  
7062 < for ac_header in cmath
7062 > if test $ac_cv_header_stdc = yes; then
7063 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7064 >  cat >conftest.$ac_ext <<_ACEOF
7065 > /* confdefs.h.  */
7066 > _ACEOF
7067 > cat confdefs.h >>conftest.$ac_ext
7068 > cat >>conftest.$ac_ext <<_ACEOF
7069 > /* end confdefs.h.  */
7070 > #include <stdlib.h>
7071 >
7072 > _ACEOF
7073 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7074 >  $EGREP "free" >/dev/null 2>&1; then
7075 >  :
7076 > else
7077 >  ac_cv_header_stdc=no
7078 > fi
7079 > rm -f conftest*
7080 >
7081 > fi
7082 >
7083 > if test $ac_cv_header_stdc = yes; then
7084 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7085 >  if test "$cross_compiling" = yes; then
7086 >  :
7087 > else
7088 >  cat >conftest.$ac_ext <<_ACEOF
7089 > /* confdefs.h.  */
7090 > _ACEOF
7091 > cat confdefs.h >>conftest.$ac_ext
7092 > cat >>conftest.$ac_ext <<_ACEOF
7093 > /* end confdefs.h.  */
7094 > #include <ctype.h>
7095 > #if ((' ' & 0x0FF) == 0x020)
7096 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7097 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7098 > #else
7099 > # define ISLOWER(c) \
7100 >                   (('a' <= (c) && (c) <= 'i') \
7101 >                     || ('j' <= (c) && (c) <= 'r') \
7102 >                     || ('s' <= (c) && (c) <= 'z'))
7103 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7104 > #endif
7105 >
7106 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7107 > int
7108 > main ()
7109 > {
7110 >  int i;
7111 >  for (i = 0; i < 256; i++)
7112 >    if (XOR (islower (i), ISLOWER (i))
7113 >        || toupper (i) != TOUPPER (i))
7114 >      exit(2);
7115 >  exit (0);
7116 > }
7117 > _ACEOF
7118 > rm -f conftest$ac_exeext
7119 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7120 >  (eval $ac_link) 2>&5
7121 >  ac_status=$?
7122 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7123 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7124 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7125 >  (eval $ac_try) 2>&5
7126 >  ac_status=$?
7127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7128 >  (exit $ac_status); }; }; then
7129 >  :
7130 > else
7131 >  echo "$as_me: program exited with status $ac_status" >&5
7132 > echo "$as_me: failed program was:" >&5
7133 > sed 's/^/| /' conftest.$ac_ext >&5
7134 >
7135 > ( exit $ac_status )
7136 > ac_cv_header_stdc=no
7137 > fi
7138 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7139 > fi
7140 > fi
7141 > fi
7142 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7143 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7144 > if test $ac_cv_header_stdc = yes; then
7145 >
7146 > cat >>confdefs.h <<\_ACEOF
7147 > #define STDC_HEADERS 1
7148 > _ACEOF
7149 >
7150 > fi
7151 >
7152 >
7153 >
7154 >
7155 >
7156 >
7157 >
7158 >
7159 >
7160 >
7161 >
7162 >
7163 >
7164 >
7165 >
7166 >
7167 >
7168 >
7169 >
7170 >
7171 >
7172 >
7173 >
7174 >
7175 >
7176 >
7177 > 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
7178   do
7179   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7180   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6024 | Line 7207 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7207    cat conftest.err >&5
7208    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7209    (exit $ac_status); } &&
7210 <         { ac_try='test -z "$ac_cxx_werror_flag"
7210 >         { ac_try='test -z "$ac_c_werror_flag"
7211                           || test ! -s conftest.err'
7212    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7213    (eval $ac_try) 2>&5
# Line 6068 | Line 7251 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
7251    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7252    (exit $ac_status); } >/dev/null; then
7253    if test -s conftest.err; then
7254 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
7255 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7254 >    ac_cpp_err=$ac_c_preproc_warn_flag
7255 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7256    else
7257      ac_cpp_err=
7258    fi
# Line 6089 | Line 7272 | echo "${ECHO_T}$ac_header_preproc" >&6
7272   echo "${ECHO_T}$ac_header_preproc" >&6
7273  
7274   # So?  What about this header?
7275 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
7275 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7276    yes:no: )
7277      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7278   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6141 | Line 7324 | done
7324   done
7325  
7326  
7327 <
7328 <
7329 <  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
7330 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
6148 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
7327 > # Checks for typedefs, structures, and compiler characteristics.
7328 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7329 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7330 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7331    echo $ECHO_N "(cached) $ECHO_C" >&6
7332   else
7333 <
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
7333 >  cat >conftest.$ac_ext <<_ACEOF
7334   /* confdefs.h.  */
7335   _ACEOF
7336   cat confdefs.h >>conftest.$ac_ext
7337   cat >>conftest.$ac_ext <<_ACEOF
7338   /* end confdefs.h.  */
7339  
7340 < #ifdef HAVE_IOSTREAM
7341 < #include <iostream>
7342 < #else
6173 < #include <iostream.h>
7340 > #include <stdbool.h>
7341 > #ifndef bool
7342 > # error bool is not defined
7343   #endif
7344 + #ifndef false
7345 + # error false is not defined
7346 + #endif
7347 + #if false
7348 + # error false is not 0
7349 + #endif
7350 + #ifndef true
7351 + # error true is not defined
7352 + #endif
7353 + #if true != 1
7354 + # error true is not 1
7355 + #endif
7356 + #ifndef __bool_true_false_are_defined
7357 + # error __bool_true_false_are_defined is not defined
7358 + #endif
7359  
7360 +        struct s { _Bool s: 1; _Bool t; } s;
7361 +
7362 +        char a[true == 1 ? 1 : -1];
7363 +        char b[false == 0 ? 1 : -1];
7364 +        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7365 +        char d[(bool) -0.5 == true ? 1 : -1];
7366 +        bool e = &s;
7367 +        char f[(_Bool) -0.0 == false ? 1 : -1];
7368 +        char g[true];
7369 +        char h[sizeof (_Bool)];
7370 +        char i[sizeof s.t];
7371 +
7372 + #ifdef FC_DUMMY_MAIN
7373 + #ifndef FC_DUMMY_MAIN_EQ_F77
7374 + #  ifdef __cplusplus
7375 +     extern "C"
7376 + #  endif
7377 +   int FC_DUMMY_MAIN() { return 1; }
7378 + #endif
7379 + #endif
7380   int
7381   main ()
7382   {
7383 < std::cout<<"Hello World"<<std::endl;return 0;
7383 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7384    ;
7385    return 0;
7386   }
# Line 6190 | Line 7394 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7394    cat conftest.err >&5
7395    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7396    (exit $ac_status); } &&
7397 <         { ac_try='test -z "$ac_cxx_werror_flag"
7397 >         { ac_try='test -z "$ac_c_werror_flag"
7398                           || test ! -s conftest.err'
7399    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7400    (eval $ac_try) 2>&5
# Line 6203 | Line 7407 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7407    ac_status=$?
7408    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7409    (exit $ac_status); }; }; then
7410 <  ac_cv_cxx_have_std_iostream=yes
7410 >  ac_cv_header_stdbool_h=yes
7411   else
7412    echo "$as_me: failed program was:" >&5
7413   sed 's/^/| /' conftest.$ac_ext >&5
7414  
7415 + ac_cv_header_stdbool_h=no
7416   fi
7417   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7418 <        cat >conftest.$ac_ext <<_ACEOF
7418 > fi
7419 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7420 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7421 > echo "$as_me:$LINENO: checking for _Bool" >&5
7422 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7423 > if test "${ac_cv_type__Bool+set}" = set; then
7424 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7425 > else
7426 >  cat >conftest.$ac_ext <<_ACEOF
7427   /* confdefs.h.  */
7428   _ACEOF
7429   cat confdefs.h >>conftest.$ac_ext
7430   cat >>conftest.$ac_ext <<_ACEOF
7431   /* end confdefs.h.  */
7432 <
7433 < #define __USE_STD_IOSTREAM 1
7434 < #ifdef HAVE_IOSTREAM
7435 < #include <iostream>
7436 < #else
7437 < #include <iostream.h>
7432 > $ac_includes_default
7433 > #ifdef FC_DUMMY_MAIN
7434 > #ifndef FC_DUMMY_MAIN_EQ_F77
7435 > #  ifdef __cplusplus
7436 >     extern "C"
7437 > #  endif
7438 >   int FC_DUMMY_MAIN() { return 1; }
7439   #endif
7440 <
7440 > #endif
7441   int
7442   main ()
7443   {
7444 < std::cout<<"Hello World"<<std::endl;return 0;
7444 > if ((_Bool *) 0)
7445 >  return 0;
7446 > if (sizeof (_Bool))
7447 >  return 0;
7448    ;
7449    return 0;
7450   }
# Line 6241 | Line 7458 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7458    cat conftest.err >&5
7459    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7460    (exit $ac_status); } &&
7461 <         { ac_try='test -z "$ac_cxx_werror_flag"
7461 >         { ac_try='test -z "$ac_c_werror_flag"
7462                           || test ! -s conftest.err'
7463    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7464    (eval $ac_try) 2>&5
# Line 6254 | Line 7471 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7471    ac_status=$?
7472    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7473    (exit $ac_status); }; }; then
7474 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
7474 >  ac_cv_type__Bool=yes
7475   else
7476    echo "$as_me: failed program was:" >&5
7477   sed 's/^/| /' conftest.$ac_ext >&5
7478  
7479 + ac_cv_type__Bool=no
7480   fi
7481   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6264        ac_ext=cc
6265 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
7482   fi
7483 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
7484 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
7485 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
7483 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7484 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7485 > if test $ac_cv_type__Bool = yes; then
7486  
7487 < cat >>confdefs.h <<\_ACEOF
7488 < #define HAVE_STD_IOSTREAM 1
7487 > cat >>confdefs.h <<_ACEOF
7488 > #define HAVE__BOOL 1
7489   _ACEOF
7490  
6281  fi
6282  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
7491  
7492 + fi
7493 +
7494 + if test $ac_cv_header_stdbool_h = yes; then
7495 +
7496   cat >>confdefs.h <<\_ACEOF
7497 < #define __USE_STD_IOSTREAM 1
7497 > #define HAVE_STDBOOL_H 1
7498   _ACEOF
7499  
7500 <  fi
7500 > fi
7501  
7502 <
7503 <
7504 <
6293 <  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
6294 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
6295 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
7502 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7503 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7504 > if test "${ac_cv_c_const+set}" = set; then
7505    echo $ECHO_N "(cached) $ECHO_C" >&6
7506   else
7507 <
6299 <      ac_cv_cxx_have_std_stl=no
6300 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6301 <
6302 <
6303 <        ac_ext=cc
6304 < ac_cpp='$CXXCPP $CPPFLAGS'
6305 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6306 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6307 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6308 <
6309 <        cat >conftest.$ac_ext <<_ACEOF
7507 >  cat >conftest.$ac_ext <<_ACEOF
7508   /* confdefs.h.  */
7509   _ACEOF
7510   cat confdefs.h >>conftest.$ac_ext
7511   cat >>conftest.$ac_ext <<_ACEOF
7512   /* end confdefs.h.  */
6315 #include <list>
7513  
7514 + #ifdef FC_DUMMY_MAIN
7515 + #ifndef FC_DUMMY_MAIN_EQ_F77
7516 + #  ifdef __cplusplus
7517 +     extern "C"
7518 + #  endif
7519 +   int FC_DUMMY_MAIN() { return 1; }
7520 + #endif
7521 + #endif
7522   int
7523   main ()
7524   {
7525 < std::list<int> foo;return 0;
7525 > /* FIXME: Include the comments suggested by Paul. */
7526 > #ifndef __cplusplus
7527 >  /* Ultrix mips cc rejects this.  */
7528 >  typedef int charset[2];
7529 >  const charset x;
7530 >  /* SunOS 4.1.1 cc rejects this.  */
7531 >  char const *const *ccp;
7532 >  char **p;
7533 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7534 >  struct point {int x, y;};
7535 >  static struct point const zero = {0,0};
7536 >  /* AIX XL C 1.02.0.0 rejects this.
7537 >     It does not let you subtract one const X* pointer from another in
7538 >     an arm of an if-expression whose if-part is not a constant
7539 >     expression */
7540 >  const char *g = "string";
7541 >  ccp = &g + (g ? g-g : 0);
7542 >  /* HPUX 7.0 cc rejects these. */
7543 >  ++ccp;
7544 >  p = (char**) ccp;
7545 >  ccp = (char const *const *) p;
7546 >  { /* SCO 3.2v4 cc rejects this.  */
7547 >    char *t;
7548 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7549 >
7550 >    *t++ = 0;
7551 >  }
7552 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7553 >    int x[] = {25, 17};
7554 >    const int *foo = &x[0];
7555 >    ++foo;
7556 >  }
7557 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7558 >    typedef const int *iptr;
7559 >    iptr p = 0;
7560 >    ++p;
7561 >  }
7562 >  { /* AIX XL C 1.02.0.0 rejects this saying
7563 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7564 >    struct s { int j; const int *ap[3]; };
7565 >    struct s *b; b->j = 5;
7566 >  }
7567 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7568 >    const int foo = 10;
7569 >  }
7570 > #endif
7571 >
7572    ;
7573    return 0;
7574   }
# Line 6331 | Line 7582 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7582    cat conftest.err >&5
7583    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7584    (exit $ac_status); } &&
7585 <         { ac_try='test -z "$ac_cxx_werror_flag"
7585 >         { ac_try='test -z "$ac_c_werror_flag"
7586                           || test ! -s conftest.err'
7587    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7588    (eval $ac_try) 2>&5
# Line 6344 | Line 7595 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7595    ac_status=$?
7596    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7597    (exit $ac_status); }; }; then
7598 <  ac_cv_cxx_have_std_stl=yes
7598 >  ac_cv_c_const=yes
7599   else
7600    echo "$as_me: failed program was:" >&5
7601   sed 's/^/| /' conftest.$ac_ext >&5
7602  
7603 + ac_cv_c_const=no
7604   fi
7605   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6354        ac_ext=cc
6355 ac_cpp='$CXXCPP $CPPFLAGS'
6356 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6357 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6358 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6359
6360      fi
6361
7606   fi
7607 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
7608 < echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
7609 <  if test "$ac_cv_cxx_have_std_stl" = yes; then
7607 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7608 > echo "${ECHO_T}$ac_cv_c_const" >&6
7609 > if test $ac_cv_c_const = no; then
7610  
7611   cat >>confdefs.h <<\_ACEOF
7612 < #define HAVE_STD_STL 1
7612 > #define const
7613   _ACEOF
7614  
7615 <  fi
7615 > fi
7616  
7617 <
7618 <
7619 <  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
7617 > echo "$as_me:$LINENO: checking for inline" >&5
7618 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7619 > if test "${ac_cv_c_inline+set}" = set; then
7620    echo $ECHO_N "(cached) $ECHO_C" >&6
7621   else
7622 <
7623 <    ac_cv_cxx_have_fstream_attach=no
7624 <
6383 <
6384 <    ac_ext=cc
6385 < ac_cpp='$CXXCPP $CPPFLAGS'
6386 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6387 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6388 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6389 <
6390 <    cat >conftest.$ac_ext <<_ACEOF
7622 >  ac_cv_c_inline=no
7623 > for ac_kw in inline __inline__ __inline; do
7624 >  cat >conftest.$ac_ext <<_ACEOF
7625   /* confdefs.h.  */
7626   _ACEOF
7627   cat confdefs.h >>conftest.$ac_ext
7628   cat >>conftest.$ac_ext <<_ACEOF
7629   /* end confdefs.h.  */
7630 <
7631 < #ifdef HAVE_IOSTREAM
7632 < #include <fstream>
7633 < #else
6400 < #include <fstream.h>
7630 > #ifndef __cplusplus
7631 > typedef int foo_t;
7632 > static $ac_kw foo_t static_foo () {return 0; }
7633 > $ac_kw foo_t foo () {return 0; }
7634   #endif
6402 #ifdef HAVE_STD_IOSTREAM
6403 using namespace std;
6404 #endif
7635  
6406 int
6407 main ()
6408 {
6409 int fd=0;ofstream s;s.attach(fd);
6410  ;
6411  return 0;
6412 }
7636   _ACEOF
7637   rm -f conftest.$ac_objext
7638   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6420 | Line 7643 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7643    cat conftest.err >&5
7644    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7645    (exit $ac_status); } &&
7646 <         { ac_try='test -z "$ac_cxx_werror_flag"
7646 >         { ac_try='test -z "$ac_c_werror_flag"
7647                           || test ! -s conftest.err'
7648    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7649    (eval $ac_try) 2>&5
# Line 6433 | Line 7656 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7656    ac_status=$?
7657    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7658    (exit $ac_status); }; }; then
7659 <  ac_cv_cxx_have_fstream_attach=yes
7659 >  ac_cv_c_inline=$ac_kw; break
7660   else
7661    echo "$as_me: failed program was:" >&5
7662   sed 's/^/| /' conftest.$ac_ext >&5
7663  
7664   fi
7665   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666 <    ac_ext=cc
6444 < ac_cpp='$CXXCPP $CPPFLAGS'
6445 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6446 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6447 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7666 > done
7667  
6449
7668   fi
7669 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
7670 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
6453 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
7669 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7670 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7671  
7672 < cat >>confdefs.h <<\_ACEOF
7673 < #define HAVE_FSTREAM_ATTACH 1
7672 >
7673 > case $ac_cv_c_inline in
7674 >  inline | yes) ;;
7675 >  *)
7676 >    case $ac_cv_c_inline in
7677 >      no) ac_val=;;
7678 >      *) ac_val=$ac_cv_c_inline;;
7679 >    esac
7680 >    cat >>confdefs.h <<_ACEOF
7681 > #ifndef __cplusplus
7682 > #define inline $ac_val
7683 > #endif
7684   _ACEOF
7685 +    ;;
7686 + esac
7687  
7688 <  fi
7688 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7689 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7690 > if test "${ac_cv_c_restrict+set}" = set; then
7691 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7692 > else
7693 >  ac_cv_c_restrict=no
7694 >   # Try the official restrict keyword, then gcc's __restrict, and
7695 >   # the less common variants.
7696 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7697 >     cat >conftest.$ac_ext <<_ACEOF
7698 > /* confdefs.h.  */
7699 > _ACEOF
7700 > cat confdefs.h >>conftest.$ac_ext
7701 > cat >>conftest.$ac_ext <<_ACEOF
7702 > /* end confdefs.h.  */
7703 > float * $ac_kw x;
7704 > _ACEOF
7705 > rm -f conftest.$ac_objext
7706 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7707 >  (eval $ac_compile) 2>conftest.er1
7708 >  ac_status=$?
7709 >  grep -v '^ *+' conftest.er1 >conftest.err
7710 >  rm -f conftest.er1
7711 >  cat conftest.err >&5
7712 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7713 >  (exit $ac_status); } &&
7714 >         { ac_try='test -z "$ac_c_werror_flag"
7715 >                         || test ! -s conftest.err'
7716 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7717 >  (eval $ac_try) 2>&5
7718 >  ac_status=$?
7719 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720 >  (exit $ac_status); }; } &&
7721 >         { ac_try='test -s conftest.$ac_objext'
7722 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7723 >  (eval $ac_try) 2>&5
7724 >  ac_status=$?
7725 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7726 >  (exit $ac_status); }; }; then
7727 >  ac_cv_c_restrict=$ac_kw; break
7728 > else
7729 >  echo "$as_me: failed program was:" >&5
7730 > sed 's/^/| /' conftest.$ac_ext >&5
7731  
7732 + fi
7733 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7734 +   done
7735  
7736 + fi
7737 + echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7738 + echo "${ECHO_T}$ac_cv_c_restrict" >&6
7739 + case $ac_cv_c_restrict in
7740 +   restrict) ;;
7741 +   no)
7742 + cat >>confdefs.h <<\_ACEOF
7743 + #define restrict
7744 + _ACEOF
7745 + ;;
7746 +   *)  cat >>confdefs.h <<_ACEOF
7747 + #define restrict $ac_cv_c_restrict
7748 + _ACEOF
7749 + ;;
7750 + esac
7751  
7752 <  echo "$as_me:$LINENO: checking for fstream::open()" >&5
7753 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
7754 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
7752 > echo "$as_me:$LINENO: checking for size_t" >&5
7753 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7754 > if test "${ac_cv_type_size_t+set}" = set; then
7755    echo $ECHO_N "(cached) $ECHO_C" >&6
7756   else
7757 <
6469 <    ac_cv_cxx_have_fstream_open=no
6470 <    ac_cv_cxx_fstream_open_prot=no
6471 <
6472 <
6473 <    ac_ext=cc
6474 < ac_cpp='$CXXCPP $CPPFLAGS'
6475 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6476 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6477 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6478 <
6479 <    # Try with 2 parameters
6480 <    cat >conftest.$ac_ext <<_ACEOF
7757 >  cat >conftest.$ac_ext <<_ACEOF
7758   /* confdefs.h.  */
7759   _ACEOF
7760   cat confdefs.h >>conftest.$ac_ext
7761   cat >>conftest.$ac_ext <<_ACEOF
7762   /* end confdefs.h.  */
7763 <
7764 < #ifdef HAVE_IOSTREAM
7765 < #include <fstream>
7766 < #else
7767 < #include <fstream.h>
7763 > $ac_includes_default
7764 > #ifdef FC_DUMMY_MAIN
7765 > #ifndef FC_DUMMY_MAIN_EQ_F77
7766 > #  ifdef __cplusplus
7767 >     extern "C"
7768 > #  endif
7769 >   int FC_DUMMY_MAIN() { return 1; }
7770   #endif
6492 #ifdef HAVE_STD_IOSTREAM
6493 using namespace std;
7771   #endif
6495
7772   int
7773   main ()
7774   {
7775 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
7775 > if ((size_t *) 0)
7776 >  return 0;
7777 > if (sizeof (size_t))
7778 >  return 0;
7779    ;
7780    return 0;
7781   }
# Line 6510 | Line 7789 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7789    cat conftest.err >&5
7790    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7791    (exit $ac_status); } &&
7792 <         { ac_try='test -z "$ac_cxx_werror_flag"
7792 >         { ac_try='test -z "$ac_c_werror_flag"
7793                           || test ! -s conftest.err'
7794    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7795    (eval $ac_try) 2>&5
# Line 6523 | Line 7802 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7802    ac_status=$?
7803    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7804    (exit $ac_status); }; }; then
7805 <  ac_cv_cxx_have_fstream_open=yes
7805 >  ac_cv_type_size_t=yes
7806   else
7807    echo "$as_me: failed program was:" >&5
7808   sed 's/^/| /' conftest.$ac_ext >&5
7809  
7810 + ac_cv_type_size_t=no
7811   fi
7812   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7813 <    # Try with mode parameter
7814 <    cat >conftest.$ac_ext <<_ACEOF
7813 > fi
7814 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7815 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7816 > if test $ac_cv_type_size_t = yes; then
7817 >  :
7818 > else
7819 >
7820 > cat >>confdefs.h <<_ACEOF
7821 > #define size_t unsigned
7822 > _ACEOF
7823 >
7824 > fi
7825 >
7826 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7827 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7828 > if test "${ac_cv_header_time+set}" = set; then
7829 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7830 > else
7831 >  cat >conftest.$ac_ext <<_ACEOF
7832   /* confdefs.h.  */
7833   _ACEOF
7834   cat confdefs.h >>conftest.$ac_ext
7835   cat >>conftest.$ac_ext <<_ACEOF
7836   /* end confdefs.h.  */
7837 + #include <sys/types.h>
7838 + #include <sys/time.h>
7839 + #include <time.h>
7840  
7841 < #ifdef HAVE_IOSTREAM
7842 < #include <fstream>
7843 < #else
7844 < #include <fstream.h>
7841 > #ifdef FC_DUMMY_MAIN
7842 > #ifndef FC_DUMMY_MAIN_EQ_F77
7843 > #  ifdef __cplusplus
7844 >     extern "C"
7845 > #  endif
7846 >   int FC_DUMMY_MAIN() { return 1; }
7847   #endif
6546 #ifdef HAVE_STD_IOSTREAM
6547 using namespace std;
7848   #endif
6549
7849   int
7850   main ()
7851   {
7852 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
7852 > if ((struct tm *) 0)
7853 > return 0;
7854    ;
7855    return 0;
7856   }
# Line 6564 | Line 7864 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7864    cat conftest.err >&5
7865    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7866    (exit $ac_status); } &&
7867 <         { ac_try='test -z "$ac_cxx_werror_flag"
7867 >         { ac_try='test -z "$ac_c_werror_flag"
7868                           || test ! -s conftest.err'
7869    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7870    (eval $ac_try) 2>&5
# Line 6577 | Line 7877 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7877    ac_status=$?
7878    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879    (exit $ac_status); }; }; then
7880 <  ac_cv_cxx_fstream_open_prot=yes
7880 >  ac_cv_header_time=yes
7881   else
7882    echo "$as_me: failed program was:" >&5
7883   sed 's/^/| /' conftest.$ac_ext >&5
7884  
7885 + ac_cv_header_time=no
7886   fi
7887   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6587    ac_ext=cc
6588 ac_cpp='$CXXCPP $CPPFLAGS'
6589 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6590 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6591 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6592
6593
7888   fi
7889 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
7890 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
7891 <  if test "$ac_cv_cxx_have_fstream_open" = yes; then
7889 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7890 > echo "${ECHO_T}$ac_cv_header_time" >&6
7891 > if test $ac_cv_header_time = yes; then
7892  
7893   cat >>confdefs.h <<\_ACEOF
7894 < #define HAVE_FSTREAM_OPEN 1
7894 > #define TIME_WITH_SYS_TIME 1
7895   _ACEOF
7896  
7897 <  fi
6604 <  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
7897 > fi
7898  
7899 < cat >>confdefs.h <<\_ACEOF
7900 < #define FSTREAM_OPEN_PROT 1
7901 < _ACEOF
6609 <
6610 <  fi
6611 <
6612 <
6613 <
6614 <
6615 < 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
7899 > echo "$as_me:$LINENO: checking for clock_t" >&5
7900 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7901 > if test "${ac_cv_type_clock_t+set}" = set; then
7902    echo $ECHO_N "(cached) $ECHO_C" >&6
7903   else
7904 <  ac_check_lib_save_LIBS=$LIBS
6621 < LIBS="-lm  $LIBS"
6622 < cat >conftest.$ac_ext <<_ACEOF
7904 >  cat >conftest.$ac_ext <<_ACEOF
7905   /* confdefs.h.  */
7906   _ACEOF
7907   cat confdefs.h >>conftest.$ac_ext
7908   cat >>conftest.$ac_ext <<_ACEOF
7909   /* end confdefs.h.  */
7910 <
7911 < /* Override any gcc2 internal prototype to avoid an error.  */
7912 < #ifdef __cplusplus
7913 < extern "C"
7910 > $ac_includes_default
7911 > #ifdef FC_DUMMY_MAIN
7912 > #ifndef FC_DUMMY_MAIN_EQ_F77
7913 > #  ifdef __cplusplus
7914 >     extern "C"
7915 > #  endif
7916 >   int FC_DUMMY_MAIN() { return 1; }
7917   #endif
7918 < /* 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 ();
7918 > #endif
7919   int
7920   main ()
7921   {
7922 < asin ();
7922 > if ((clock_t *) 0)
7923 >  return 0;
7924 > if (sizeof (clock_t))
7925 >  return 0;
7926    ;
7927    return 0;
7928   }
7929   _ACEOF
7930 < rm -f conftest.$ac_objext conftest$ac_exeext
7931 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7932 <  (eval $ac_link) 2>conftest.er1
7930 > rm -f conftest.$ac_objext
7931 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7932 >  (eval $ac_compile) 2>conftest.er1
7933    ac_status=$?
7934    grep -v '^ *+' conftest.er1 >conftest.err
7935    rm -f conftest.er1
7936    cat conftest.err >&5
7937    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7938    (exit $ac_status); } &&
7939 <         { ac_try='test -z "$ac_cxx_werror_flag"
7939 >         { ac_try='test -z "$ac_c_werror_flag"
7940                           || test ! -s conftest.err'
7941    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7942    (eval $ac_try) 2>&5
7943    ac_status=$?
7944    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7945    (exit $ac_status); }; } &&
7946 <         { ac_try='test -s conftest$ac_exeext'
7946 >         { ac_try='test -s conftest.$ac_objext'
7947    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7948    (eval $ac_try) 2>&5
7949    ac_status=$?
7950    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7951    (exit $ac_status); }; }; then
7952 <  ac_cv_lib_m_asin=yes
7952 >  ac_cv_type_clock_t=yes
7953   else
7954    echo "$as_me: failed program was:" >&5
7955   sed 's/^/| /' conftest.$ac_ext >&5
7956  
7957 < ac_cv_lib_m_asin=no
7957 > ac_cv_type_clock_t=no
7958   fi
7959 < rm -f conftest.err conftest.$ac_objext \
6674 <      conftest$ac_exeext conftest.$ac_ext
6675 < LIBS=$ac_check_lib_save_LIBS
7959 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7960   fi
7961 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
7962 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
7963 < if test $ac_cv_lib_m_asin = yes; then
7964 <  cat >>confdefs.h <<_ACEOF
7965 < #define HAVE_LIBM 1
7961 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7962 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7963 > if test $ac_cv_type_clock_t = yes; then
7964 >
7965 > cat >>confdefs.h <<_ACEOF
7966 > #define HAVE_CLOCK_T 1
7967   _ACEOF
7968  
6684  LIBS="-lm $LIBS"
7969  
6686 else
6687  exit
7970   fi
7971  
7972 <
7973 < ac_ext=c
7974 < ac_cpp='$CPP $CPPFLAGS'
6693 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6694 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6695 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6696 <
6697 <
6698 < #
6699 < # Handle user hints
6700 < #
6701 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
6702 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
6703 <
6704 < # Check whether --with-zlib or --without-zlib was given.
6705 < if test "${with_zlib+set}" = set; then
6706 <  withval="$with_zlib"
6707 <  if test "$withval" != no ; then
6708 <  echo "$as_me:$LINENO: result: yes" >&5
6709 < echo "${ECHO_T}yes" >&6
6710 <  if test -d "$withval"
6711 <  then
6712 <    ZLIB_HOME="$withval"
6713 <  else
6714 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
6715 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
6716 <  fi
6717 < else
6718 <  echo "$as_me:$LINENO: result: no" >&5
6719 < echo "${ECHO_T}no" >&6
6720 < fi
6721 < fi;
6722 <
6723 < ZLIB_HOME=/usr/local
6724 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
6725 < then
6726 <        ZLIB_HOME=/usr
6727 < fi
6728 <
6729 < #
6730 < # Locate zlib, if wanted
6731 < #
6732 < if test -n "${ZLIB_HOME}"
6733 < then
6734 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
6735 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
6736 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
6737 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
6738 <
6739 <
6740 <        ac_ext=c
6741 < ac_cpp='$CPP $CPPFLAGS'
6742 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6743 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6744 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6745 <
6746 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6747 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6748 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
7972 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7973 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7974 > if test "${ac_cv_c_const+set}" = set; then
7975    echo $ECHO_N "(cached) $ECHO_C" >&6
7976   else
7977 <  ac_check_lib_save_LIBS=$LIBS
6752 < LIBS="-lz  $LIBS"
6753 < cat >conftest.$ac_ext <<_ACEOF
7977 >  cat >conftest.$ac_ext <<_ACEOF
7978   /* confdefs.h.  */
7979   _ACEOF
7980   cat confdefs.h >>conftest.$ac_ext
7981   cat >>conftest.$ac_ext <<_ACEOF
7982   /* end confdefs.h.  */
7983  
7984 < /* Override any gcc2 internal prototype to avoid an error.  */
7985 < #ifdef __cplusplus
7986 < extern "C"
7984 > #ifdef FC_DUMMY_MAIN
7985 > #ifndef FC_DUMMY_MAIN_EQ_F77
7986 > #  ifdef __cplusplus
7987 >     extern "C"
7988 > #  endif
7989 >   int FC_DUMMY_MAIN() { return 1; }
7990   #endif
7991 < /* We use char because int might match the return type of a gcc2
6765 <   builtin and then its argument prototype would still apply.  */
6766 < char inflateEnd ();
7991 > #endif
7992   int
7993   main ()
7994   {
7995 < inflateEnd ();
7995 > /* FIXME: Include the comments suggested by Paul. */
7996 > #ifndef __cplusplus
7997 >  /* Ultrix mips cc rejects this.  */
7998 >  typedef int charset[2];
7999 >  const charset x;
8000 >  /* SunOS 4.1.1 cc rejects this.  */
8001 >  char const *const *ccp;
8002 >  char **p;
8003 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8004 >  struct point {int x, y;};
8005 >  static struct point const zero = {0,0};
8006 >  /* AIX XL C 1.02.0.0 rejects this.
8007 >     It does not let you subtract one const X* pointer from another in
8008 >     an arm of an if-expression whose if-part is not a constant
8009 >     expression */
8010 >  const char *g = "string";
8011 >  ccp = &g + (g ? g-g : 0);
8012 >  /* HPUX 7.0 cc rejects these. */
8013 >  ++ccp;
8014 >  p = (char**) ccp;
8015 >  ccp = (char const *const *) p;
8016 >  { /* SCO 3.2v4 cc rejects this.  */
8017 >    char *t;
8018 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8019 >
8020 >    *t++ = 0;
8021 >  }
8022 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8023 >    int x[] = {25, 17};
8024 >    const int *foo = &x[0];
8025 >    ++foo;
8026 >  }
8027 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8028 >    typedef const int *iptr;
8029 >    iptr p = 0;
8030 >    ++p;
8031 >  }
8032 >  { /* AIX XL C 1.02.0.0 rejects this saying
8033 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8034 >    struct s { int j; const int *ap[3]; };
8035 >    struct s *b; b->j = 5;
8036 >  }
8037 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8038 >    const int foo = 10;
8039 >  }
8040 > #endif
8041 >
8042    ;
8043    return 0;
8044   }
8045   _ACEOF
8046 < rm -f conftest.$ac_objext conftest$ac_exeext
8047 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8048 <  (eval $ac_link) 2>conftest.er1
8046 > rm -f conftest.$ac_objext
8047 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8048 >  (eval $ac_compile) 2>conftest.er1
8049    ac_status=$?
8050    grep -v '^ *+' conftest.er1 >conftest.err
8051    rm -f conftest.er1
# Line 6788 | Line 8059 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8059    ac_status=$?
8060    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8061    (exit $ac_status); }; } &&
8062 <         { ac_try='test -s conftest$ac_exeext'
8062 >         { ac_try='test -s conftest.$ac_objext'
8063    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8064    (eval $ac_try) 2>&5
8065    ac_status=$?
8066    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8067    (exit $ac_status); }; }; then
8068 <  ac_cv_lib_z_inflateEnd=yes
8068 >  ac_cv_c_const=yes
8069   else
8070    echo "$as_me: failed program was:" >&5
8071   sed 's/^/| /' conftest.$ac_ext >&5
8072  
8073 < ac_cv_lib_z_inflateEnd=no
8073 > ac_cv_c_const=no
8074   fi
8075 < rm -f conftest.err conftest.$ac_objext \
6805 <      conftest$ac_exeext conftest.$ac_ext
6806 < LIBS=$ac_check_lib_save_LIBS
8075 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8076   fi
8077 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
8078 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
8079 < if test $ac_cv_lib_z_inflateEnd = yes; then
8080 <  zlib_cv_libz=yes
8077 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8078 > echo "${ECHO_T}$ac_cv_c_const" >&6
8079 > if test $ac_cv_c_const = no; then
8080 >
8081 > cat >>confdefs.h <<\_ACEOF
8082 > #define const
8083 > _ACEOF
8084 >
8085 > fi
8086 >
8087 > echo "$as_me:$LINENO: checking for inline" >&5
8088 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8089 > if test "${ac_cv_c_inline+set}" = set; then
8090 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8091   else
8092 <  zlib_cv_libz=no
8092 >  ac_cv_c_inline=no
8093 > for ac_kw in inline __inline__ __inline; do
8094 >  cat >conftest.$ac_ext <<_ACEOF
8095 > /* confdefs.h.  */
8096 > _ACEOF
8097 > cat confdefs.h >>conftest.$ac_ext
8098 > cat >>conftest.$ac_ext <<_ACEOF
8099 > /* end confdefs.h.  */
8100 > #ifndef __cplusplus
8101 > typedef int foo_t;
8102 > static $ac_kw foo_t static_foo () {return 0; }
8103 > $ac_kw foo_t foo () {return 0; }
8104 > #endif
8105 >
8106 > _ACEOF
8107 > rm -f conftest.$ac_objext
8108 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8109 >  (eval $ac_compile) 2>conftest.er1
8110 >  ac_status=$?
8111 >  grep -v '^ *+' conftest.er1 >conftest.err
8112 >  rm -f conftest.er1
8113 >  cat conftest.err >&5
8114 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8115 >  (exit $ac_status); } &&
8116 >         { ac_try='test -z "$ac_c_werror_flag"
8117 >                         || test ! -s conftest.err'
8118 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8119 >  (eval $ac_try) 2>&5
8120 >  ac_status=$?
8121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122 >  (exit $ac_status); }; } &&
8123 >         { ac_try='test -s conftest.$ac_objext'
8124 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8125 >  (eval $ac_try) 2>&5
8126 >  ac_status=$?
8127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8128 >  (exit $ac_status); }; }; then
8129 >  ac_cv_c_inline=$ac_kw; break
8130 > else
8131 >  echo "$as_me: failed program was:" >&5
8132 > sed 's/^/| /' conftest.$ac_ext >&5
8133 >
8134   fi
8135 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136 + done
8137  
8138 <        if test "${ac_cv_header_zlib_h+set}" = set; then
8139 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
8140 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
8141 < if test "${ac_cv_header_zlib_h+set}" = set; then
8138 > fi
8139 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8140 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8141 >
8142 >
8143 > case $ac_cv_c_inline in
8144 >  inline | yes) ;;
8145 >  *)
8146 >    case $ac_cv_c_inline in
8147 >      no) ac_val=;;
8148 >      *) ac_val=$ac_cv_c_inline;;
8149 >    esac
8150 >    cat >>confdefs.h <<_ACEOF
8151 > #ifndef __cplusplus
8152 > #define inline $ac_val
8153 > #endif
8154 > _ACEOF
8155 >    ;;
8156 > esac
8157 >
8158 >
8159 > # Checks for library functions.
8160 >
8161 > for ac_header in stdlib.h
8162 > do
8163 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8164 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8165 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8166 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8167 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8168    echo $ECHO_N "(cached) $ECHO_C" >&6
8169   fi
8170 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8171 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
8170 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8171 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8172   else
8173    # Is the header compilable?
8174 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
8175 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
8174 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8175 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8176   cat >conftest.$ac_ext <<_ACEOF
8177   /* confdefs.h.  */
8178   _ACEOF
# Line 6832 | Line 8180 | $ac_includes_default
8180   cat >>conftest.$ac_ext <<_ACEOF
8181   /* end confdefs.h.  */
8182   $ac_includes_default
8183 < #include <zlib.h>
8183 > #include <$ac_header>
8184   _ACEOF
8185   rm -f conftest.$ac_objext
8186   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6868 | Line 8216 | echo "${ECHO_T}$ac_header_compiler" >&6
8216   echo "${ECHO_T}$ac_header_compiler" >&6
8217  
8218   # Is the header present?
8219 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
8220 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
8219 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8220 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8221   cat >conftest.$ac_ext <<_ACEOF
8222   /* confdefs.h.  */
8223   _ACEOF
8224   cat confdefs.h >>conftest.$ac_ext
8225   cat >>conftest.$ac_ext <<_ACEOF
8226   /* end confdefs.h.  */
8227 < #include <zlib.h>
8227 > #include <$ac_header>
8228   _ACEOF
8229   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8230    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6910 | Line 8258 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
8258   # So?  What about this header?
8259   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8260    yes:no: )
8261 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
8262 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8263 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
8264 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
8261 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8262 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8263 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8264 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8265      ac_header_preproc=yes
8266      ;;
8267    no:yes:* )
8268 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
8269 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
8270 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
8271 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
8272 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
8273 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
8274 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
8275 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8276 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
8277 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
8278 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
8279 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
8268 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8269 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8270 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8271 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8272 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8273 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8274 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8275 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8276 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8277 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8278 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8279 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8280      (
8281        cat <<\_ASBOX
8282   ## ------------------------------ ##
# Line 6939 | Line 8287 | esac
8287        sed "s/^/$as_me: WARNING:     /" >&2
8288      ;;
8289   esac
8290 < echo "$as_me:$LINENO: checking for zlib.h" >&5
8291 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
8292 < if test "${ac_cv_header_zlib_h+set}" = set; then
8290 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8291 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8292 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8293    echo $ECHO_N "(cached) $ECHO_C" >&6
8294   else
8295 <  ac_cv_header_zlib_h=$ac_header_preproc
8295 >  eval "$as_ac_Header=\$ac_header_preproc"
8296   fi
8297 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8298 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
8297 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8298 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8299  
8300   fi
8301 < if test $ac_cv_header_zlib_h = yes; then
8302 <  zlib_cv_zlib_h=yes
8303 < else
8304 <  zlib_cv_zlib_h=no
8301 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8302 >  cat >>confdefs.h <<_ACEOF
8303 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8304 > _ACEOF
8305 >
8306   fi
8307  
8308 + done
8309  
8310 <        ac_ext=c
8311 < ac_cpp='$CPP $CPPFLAGS'
8312 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6963 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6964 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6965 <
6966 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6967 <        then
6968 <                #
6969 <                # If both library and header were found, use them
6970 <                #
6971 <
6972 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6973 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6974 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
8310 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8311 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8312 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8313    echo $ECHO_N "(cached) $ECHO_C" >&6
8314   else
8315 <  ac_check_lib_save_LIBS=$LIBS
8316 < LIBS="-lz  $LIBS"
8317 < cat >conftest.$ac_ext <<_ACEOF
8315 >  if test "$cross_compiling" = yes; then
8316 >  ac_cv_func_malloc_0_nonnull=no
8317 > else
8318 >  cat >conftest.$ac_ext <<_ACEOF
8319   /* confdefs.h.  */
8320   _ACEOF
8321   cat confdefs.h >>conftest.$ac_ext
8322   cat >>conftest.$ac_ext <<_ACEOF
8323   /* end confdefs.h.  */
8324 + #if STDC_HEADERS || HAVE_STDLIB_H
8325 + # include <stdlib.h>
8326 + #else
8327 + char *malloc ();
8328 + #endif
8329  
8330 < /* Override any gcc2 internal prototype to avoid an error.  */
8331 < #ifdef __cplusplus
8332 < extern "C"
8330 > #ifdef FC_DUMMY_MAIN
8331 > #ifndef FC_DUMMY_MAIN_EQ_F77
8332 > #  ifdef __cplusplus
8333 >     extern "C"
8334 > #  endif
8335 >   int FC_DUMMY_MAIN() { return 1; }
8336   #endif
8337 < /* We use char because int might match the return type of a gcc2
6991 <   builtin and then its argument prototype would still apply.  */
6992 < char inflateEnd ();
8337 > #endif
8338   int
8339   main ()
8340   {
8341 < inflateEnd ();
8341 > exit (malloc (0) ? 0 : 1);
8342    ;
8343    return 0;
8344   }
8345   _ACEOF
8346 < rm -f conftest.$ac_objext conftest$ac_exeext
8346 > rm -f conftest$ac_exeext
8347   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8348 <  (eval $ac_link) 2>conftest.er1
8348 >  (eval $ac_link) 2>&5
8349    ac_status=$?
7005  grep -v '^ *+' conftest.er1 >conftest.err
7006  rm -f conftest.er1
7007  cat conftest.err >&5
8350    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8351 <  (exit $ac_status); } &&
7010 <         { ac_try='test -z "$ac_c_werror_flag"
7011 <                         || test ! -s conftest.err'
8351 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8352    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8353    (eval $ac_try) 2>&5
8354    ac_status=$?
8355    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7016  (exit $ac_status); }; } &&
7017         { ac_try='test -s conftest$ac_exeext'
7018  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7019  (eval $ac_try) 2>&5
7020  ac_status=$?
7021  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8356    (exit $ac_status); }; }; then
8357 <  ac_cv_lib_z_inflateEnd=yes
8357 >  ac_cv_func_malloc_0_nonnull=yes
8358   else
8359 <  echo "$as_me: failed program was:" >&5
8359 >  echo "$as_me: program exited with status $ac_status" >&5
8360 > echo "$as_me: failed program was:" >&5
8361   sed 's/^/| /' conftest.$ac_ext >&5
8362  
8363 < ac_cv_lib_z_inflateEnd=no
8363 > ( exit $ac_status )
8364 > ac_cv_func_malloc_0_nonnull=no
8365   fi
8366 < rm -f conftest.err conftest.$ac_objext \
7031 <      conftest$ac_exeext conftest.$ac_ext
7032 < LIBS=$ac_check_lib_save_LIBS
8366 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8367   fi
7034 echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7035 echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
7036 if test $ac_cv_lib_z_inflateEnd = yes; then
7037  cat >>confdefs.h <<_ACEOF
7038 #define HAVE_LIBZ 1
7039 _ACEOF
7040
7041  LIBS="-lz $LIBS"
7042
8368   fi
8369 <
8370 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
8371 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7047 <                echo "$as_me:$LINENO: result: ok" >&5
7048 < echo "${ECHO_T}ok" >&6
7049 <        else
7050 <                #
7051 <                # If either header or library was not found, revert and bomb
7052 <                #
7053 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7054 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7055 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
7056 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
7057 <                echo "$as_me:$LINENO: result: failed" >&5
7058 < echo "${ECHO_T}failed" >&6
7059 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
7060 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
7061 <   { (exit 1); exit 1; }; }
7062 <        fi
7063 < fi
8369 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8370 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8371 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8372  
8373 + cat >>confdefs.h <<\_ACEOF
8374 + #define HAVE_MALLOC 1
8375 + _ACEOF
8376  
8377 + else
8378 +  cat >>confdefs.h <<\_ACEOF
8379 + #define HAVE_MALLOC 0
8380 + _ACEOF
8381  
8382 +   case $LIBOBJS in
8383 +    "malloc.$ac_objext"   | \
8384 +  *" malloc.$ac_objext"   | \
8385 +    "malloc.$ac_objext "* | \
8386 +  *" malloc.$ac_objext "* ) ;;
8387 +  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8388 + esac
8389  
8390  
8391 + cat >>confdefs.h <<\_ACEOF
8392 + #define malloc rpl_malloc
8393 + _ACEOF
8394  
8395 + fi
8396  
8397  
8398  
8399 + echo "$as_me:$LINENO: checking for working memcmp" >&5
8400 + echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8401 + if test "${ac_cv_func_memcmp_working+set}" = set; then
8402 +  echo $ECHO_N "(cached) $ECHO_C" >&6
8403 + else
8404 +  if test "$cross_compiling" = yes; then
8405 +  ac_cv_func_memcmp_working=no
8406 + else
8407 +  cat >conftest.$ac_ext <<_ACEOF
8408 + /* confdefs.h.  */
8409 + _ACEOF
8410 + cat confdefs.h >>conftest.$ac_ext
8411 + cat >>conftest.$ac_ext <<_ACEOF
8412 + /* end confdefs.h.  */
8413 + $ac_includes_default
8414 + #ifdef FC_DUMMY_MAIN
8415 + #ifndef FC_DUMMY_MAIN_EQ_F77
8416 + #  ifdef __cplusplus
8417 +     extern "C"
8418 + #  endif
8419 +   int FC_DUMMY_MAIN() { return 1; }
8420 + #endif
8421 + #endif
8422 + int
8423 + main ()
8424 + {
8425  
8426 +  /* Some versions of memcmp are not 8-bit clean.  */
8427 +  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8428 +  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8429 +    exit (1);
8430  
8431 +  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8432 +     or more and with at least one buffer not starting on a 4-byte boundary.
8433 +     William Lewis provided this test program.   */
8434 +  {
8435 +    char foo[21];
8436 +    char bar[21];
8437 +    int i;
8438 +    for (i = 0; i < 4; i++)
8439 +      {
8440 +        char *a = foo + i;
8441 +        char *b = bar + i;
8442 +        strcpy (a, "--------01111111");
8443 +        strcpy (b, "--------10000000");
8444 +        if (memcmp (a, b, 16) >= 0)
8445 +          exit (1);
8446 +      }
8447 +    exit (0);
8448 +  }
8449  
8450 +  ;
8451 +  return 0;
8452 + }
8453 + _ACEOF
8454 + rm -f conftest$ac_exeext
8455 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8456 +  (eval $ac_link) 2>&5
8457 +  ac_status=$?
8458 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8459 +  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8460 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8461 +  (eval $ac_try) 2>&5
8462 +  ac_status=$?
8463 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8464 +  (exit $ac_status); }; }; then
8465 +  ac_cv_func_memcmp_working=yes
8466 + else
8467 +  echo "$as_me: program exited with status $ac_status" >&5
8468 + echo "$as_me: failed program was:" >&5
8469 + sed 's/^/| /' conftest.$ac_ext >&5
8470  
8471 + ( exit $ac_status )
8472 + ac_cv_func_memcmp_working=no
8473 + fi
8474 + rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8475 + fi
8476 + fi
8477 + echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8478 + echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8479 + test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8480 +    "memcmp.$ac_objext"   | \
8481 +  *" memcmp.$ac_objext"   | \
8482 +    "memcmp.$ac_objext "* | \
8483 +  *" memcmp.$ac_objext "* ) ;;
8484 +  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8485 + esac
8486  
8487  
8488  
8489 <
7081 <
7082 <
7083 <
7084 <
7085 < 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
8489 > for ac_header in stdlib.h
8490   do
8491   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8492   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7231 | Line 8635 | done
8635  
8636   done
8637  
8638 < ac_ext=cc
8639 < ac_cpp='$CXXCPP $CPPFLAGS'
8640 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8641 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8642 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8638 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8639 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8640 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8641 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8642 > else
8643 >  if test "$cross_compiling" = yes; then
8644 >  ac_cv_func_realloc_0_nonnull=no
8645 > else
8646 >  cat >conftest.$ac_ext <<_ACEOF
8647 > /* confdefs.h.  */
8648 > _ACEOF
8649 > cat confdefs.h >>conftest.$ac_ext
8650 > cat >>conftest.$ac_ext <<_ACEOF
8651 > /* end confdefs.h.  */
8652 > #if STDC_HEADERS || HAVE_STDLIB_H
8653 > # include <stdlib.h>
8654 > #else
8655 > char *realloc ();
8656 > #endif
8657  
8658 + #ifdef FC_DUMMY_MAIN
8659 + #ifndef FC_DUMMY_MAIN_EQ_F77
8660 + #  ifdef __cplusplus
8661 +     extern "C"
8662 + #  endif
8663 +   int FC_DUMMY_MAIN() { return 1; }
8664 + #endif
8665 + #endif
8666 + int
8667 + main ()
8668 + {
8669 + exit (realloc (0, 0) ? 0 : 1);
8670 +  ;
8671 +  return 0;
8672 + }
8673 + _ACEOF
8674 + rm -f conftest$ac_exeext
8675 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8676 +  (eval $ac_link) 2>&5
8677 +  ac_status=$?
8678 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8679 +  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8680 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8681 +  (eval $ac_try) 2>&5
8682 +  ac_status=$?
8683 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8684 +  (exit $ac_status); }; }; then
8685 +  ac_cv_func_realloc_0_nonnull=yes
8686 + else
8687 +  echo "$as_me: program exited with status $ac_status" >&5
8688 + echo "$as_me: failed program was:" >&5
8689 + sed 's/^/| /' conftest.$ac_ext >&5
8690  
8691 + ( exit $ac_status )
8692 + ac_cv_func_realloc_0_nonnull=no
8693 + fi
8694 + rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8695 + fi
8696 + fi
8697 + echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8698 + echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8699 + if test $ac_cv_func_realloc_0_nonnull = yes; then
8700  
8701 + cat >>confdefs.h <<\_ACEOF
8702 + #define HAVE_REALLOC 1
8703 + _ACEOF
8704  
8705 + else
8706 +  cat >>confdefs.h <<\_ACEOF
8707 + #define HAVE_REALLOC 0
8708 + _ACEOF
8709  
8710 +   case $LIBOBJS in
8711 +    "realloc.$ac_objext"   | \
8712 +  *" realloc.$ac_objext"   | \
8713 +    "realloc.$ac_objext "* | \
8714 +  *" realloc.$ac_objext "* ) ;;
8715 +  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8716 + esac
8717  
8718 < for ac_header in ctype.h iostream fstream sstream strstream
8718 >
8719 > cat >>confdefs.h <<\_ACEOF
8720 > #define realloc rpl_realloc
8721 > _ACEOF
8722 >
8723 > fi
8724 >
8725 >
8726 >
8727 >
8728 >
8729 > for ac_header in sys/select.h sys/socket.h
8730   do
8731   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8732   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7275 | Line 8759 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8759    cat conftest.err >&5
8760    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8761    (exit $ac_status); } &&
8762 <         { ac_try='test -z "$ac_cxx_werror_flag"
8762 >         { ac_try='test -z "$ac_c_werror_flag"
8763                           || test ! -s conftest.err'
8764    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8765    (eval $ac_try) 2>&5
# Line 7319 | Line 8803 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
8803    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8804    (exit $ac_status); } >/dev/null; then
8805    if test -s conftest.err; then
8806 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8807 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8806 >    ac_cpp_err=$ac_c_preproc_warn_flag
8807 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8808    else
8809      ac_cpp_err=
8810    fi
# Line 7340 | Line 8824 | echo "${ECHO_T}$ac_header_preproc" >&6
8824   echo "${ECHO_T}$ac_header_preproc" >&6
8825  
8826   # So?  What about this header?
8827 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
8827 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8828    yes:no: )
8829      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8830   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7391 | Line 8875 | done
8875  
8876   done
8877  
8878 < ac_ext=c
8879 < ac_cpp='$CPP $CPPFLAGS'
8880 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8881 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8882 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8878 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8879 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8880 > if test "${ac_cv_func_select_args+set}" = set; then
8881 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8882 > else
8883 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8884 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8885 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8886 >   cat >conftest.$ac_ext <<_ACEOF
8887 > /* confdefs.h.  */
8888 > _ACEOF
8889 > cat confdefs.h >>conftest.$ac_ext
8890 > cat >>conftest.$ac_ext <<_ACEOF
8891 > /* end confdefs.h.  */
8892 > $ac_includes_default
8893 > #if HAVE_SYS_SELECT_H
8894 > # include <sys/select.h>
8895 > #endif
8896 > #if HAVE_SYS_SOCKET_H
8897 > # include <sys/socket.h>
8898 > #endif
8899  
8900 <
8901 <
8900 > #ifdef FC_DUMMY_MAIN
8901 > #ifndef FC_DUMMY_MAIN_EQ_F77
8902 > #  ifdef __cplusplus
8903 >     extern "C"
8904 > #  endif
8905 >   int FC_DUMMY_MAIN() { return 1; }
8906 > #endif
8907 > #endif
8908 > int
8909 > main ()
8910 > {
8911 > extern int select ($ac_arg1,
8912 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8913 >                                            $ac_arg5);
8914 >  ;
8915 >  return 0;
8916 > }
8917 > _ACEOF
8918 > rm -f conftest.$ac_objext
8919 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8920 >  (eval $ac_compile) 2>conftest.er1
8921 >  ac_status=$?
8922 >  grep -v '^ *+' conftest.er1 >conftest.err
8923 >  rm -f conftest.er1
8924 >  cat conftest.err >&5
8925 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8926 >  (exit $ac_status); } &&
8927 >         { ac_try='test -z "$ac_c_werror_flag"
8928 >                         || test ! -s conftest.err'
8929 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8930 >  (eval $ac_try) 2>&5
8931 >  ac_status=$?
8932 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8933 >  (exit $ac_status); }; } &&
8934 >         { ac_try='test -s conftest.$ac_objext'
8935 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8936 >  (eval $ac_try) 2>&5
8937 >  ac_status=$?
8938 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8939 >  (exit $ac_status); }; }; then
8940 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8941 > else
8942 >  echo "$as_me: failed program was:" >&5
8943 > sed 's/^/| /' conftest.$ac_ext >&5
8944  
8945 + fi
8946 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8947 +  done
8948 + done
8949 + done
8950 + # Provide a safe default value.
8951 + : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8952  
8953 + fi
8954 + echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8955 + echo "${ECHO_T}$ac_cv_func_select_args" >&6
8956 + ac_save_IFS=$IFS; IFS=','
8957 + set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8958 + IFS=$ac_save_IFS
8959 + shift
8960  
8961 + cat >>confdefs.h <<_ACEOF
8962 + #define SELECT_TYPE_ARG1 $1
8963 + _ACEOF
8964  
8965  
8966 + cat >>confdefs.h <<_ACEOF
8967 + #define SELECT_TYPE_ARG234 ($2)
8968 + _ACEOF
8969  
8970  
8971 + cat >>confdefs.h <<_ACEOF
8972 + #define SELECT_TYPE_ARG5 ($3)
8973 + _ACEOF
8974  
8975 + rm -f conftest*
8976  
8977  
8978 < for ac_func in rint snprintf sranddev strcasecmp strncasecmp stricmp strnicmp pstat_getstatic sysmp getsysinfo sysctl table
8978 > for ac_func in strftime
8979   do
8980   as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8981   echo "$as_me:$LINENO: checking for $ac_func" >&5
# Line 7460 | Line 9026 | char (*f) () = $ac_func;
9026   }
9027   #endif
9028  
9029 + #ifdef FC_DUMMY_MAIN
9030 + #ifndef FC_DUMMY_MAIN_EQ_F77
9031 + #  ifdef __cplusplus
9032 +     extern "C"
9033 + #  endif
9034 +   int FC_DUMMY_MAIN() { return 1; }
9035 + #endif
9036 + #endif
9037   int
9038   main ()
9039   {
# Line 7507 | Line 9081 | _ACEOF
9081   #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9082   _ACEOF
9083  
9084 < fi
9085 < done
9086 <
9087 < # special check for _system_configuration because AIX <4.3.2 do not
9088 < # contain the `physmem' member.
9089 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9090 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9084 > else
9085 >  # strftime is in -lintl on SCO UNIX.
9086 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9087 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9088 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9089 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9090 > else
9091 >  ac_check_lib_save_LIBS=$LIBS
9092 > LIBS="-lintl  $LIBS"
9093   cat >conftest.$ac_ext <<_ACEOF
9094   /* confdefs.h.  */
9095   _ACEOF
9096   cat confdefs.h >>conftest.$ac_ext
9097   cat >>conftest.$ac_ext <<_ACEOF
9098   /* end confdefs.h.  */
9099 < #include <sys/systemcfg.h>
9099 >
9100 > /* Override any gcc2 internal prototype to avoid an error.  */
9101 > #ifdef __cplusplus
9102 > extern "C"
9103 > #endif
9104 > /* We use char because int might match the return type of a gcc2
9105 >   builtin and then its argument prototype would still apply.  */
9106 > char strftime ();
9107 > #ifdef FC_DUMMY_MAIN
9108 > #ifndef FC_DUMMY_MAIN_EQ_F77
9109 > #  ifdef __cplusplus
9110 >     extern "C"
9111 > #  endif
9112 >   int FC_DUMMY_MAIN() { return 1; }
9113 > #endif
9114 > #endif
9115   int
9116   main ()
9117   {
9118 < double x = _system_configuration.physmem;
9118 > strftime ();
9119    ;
9120    return 0;
9121   }
9122   _ACEOF
9123 < rm -f conftest.$ac_objext
9124 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9125 <  (eval $ac_compile) 2>conftest.er1
9123 > rm -f conftest.$ac_objext conftest$ac_exeext
9124 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9125 >  (eval $ac_link) 2>conftest.er1
9126    ac_status=$?
9127    grep -v '^ *+' conftest.er1 >conftest.err
9128    rm -f conftest.er1
# Line 7545 | Line 9136 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9136    ac_status=$?
9137    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9138    (exit $ac_status); }; } &&
9139 <         { ac_try='test -s conftest.$ac_objext'
9139 >         { ac_try='test -s conftest$ac_exeext'
9140    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9141    (eval $ac_try) 2>&5
9142    ac_status=$?
9143    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9144    (exit $ac_status); }; }; then
9145 <  echo "$as_me:$LINENO: result: yes" >&5
9146 < echo "${ECHO_T}yes" >&6
9145 >  ac_cv_lib_intl_strftime=yes
9146 > else
9147 >  echo "$as_me: failed program was:" >&5
9148 > sed 's/^/| /' conftest.$ac_ext >&5
9149  
9150 < cat >>confdefs.h <<\_ACEOF
9151 < #define HAVE__SYSTEM_CONFIGURATION 1
9150 > ac_cv_lib_intl_strftime=no
9151 > fi
9152 > rm -f conftest.err conftest.$ac_objext \
9153 >      conftest$ac_exeext conftest.$ac_ext
9154 > LIBS=$ac_check_lib_save_LIBS
9155 > fi
9156 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9157 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9158 > if test $ac_cv_lib_intl_strftime = yes; then
9159 >  cat >>confdefs.h <<\_ACEOF
9160 > #define HAVE_STRFTIME 1
9161 > _ACEOF
9162 >
9163 > LIBS="-lintl $LIBS"
9164 > fi
9165 >
9166 > fi
9167 > done
9168 >
9169 > echo "$as_me:$LINENO: checking for working strtod" >&5
9170 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9171 > if test "${ac_cv_func_strtod+set}" = set; then
9172 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9173 > else
9174 >  if test "$cross_compiling" = yes; then
9175 >  ac_cv_func_strtod=no
9176 > else
9177 >  cat >conftest.$ac_ext <<_ACEOF
9178 > /* confdefs.h.  */
9179   _ACEOF
9180 + cat confdefs.h >>conftest.$ac_ext
9181 + cat >>conftest.$ac_ext <<_ACEOF
9182 + /* end confdefs.h.  */
9183  
9184 + double strtod ();
9185 + int
9186 + main()
9187 + {
9188 +  {
9189 +    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9190 +    char *string = " +69";
9191 +    char *term;
9192 +    double value;
9193 +    value = strtod (string, &term);
9194 +    if (value != 69 || term != (string + 4))
9195 +      exit (1);
9196 +  }
9197 +
9198 +  {
9199 +    /* Under Solaris 2.4, strtod returns the wrong value for the
9200 +       terminating character under some conditions.  */
9201 +    char *string = "NaN";
9202 +    char *term;
9203 +    strtod (string, &term);
9204 +    if (term != string && *(term - 1) == 0)
9205 +      exit (1);
9206 +  }
9207 +  exit (0);
9208 + }
9209 +
9210 + _ACEOF
9211 + rm -f conftest$ac_exeext
9212 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9213 +  (eval $ac_link) 2>&5
9214 +  ac_status=$?
9215 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9216 +  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9217 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9218 +  (eval $ac_try) 2>&5
9219 +  ac_status=$?
9220 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9221 +  (exit $ac_status); }; }; then
9222 +  ac_cv_func_strtod=yes
9223   else
9224 <  echo "$as_me: failed program was:" >&5
9224 >  echo "$as_me: program exited with status $ac_status" >&5
9225 > echo "$as_me: failed program was:" >&5
9226   sed 's/^/| /' conftest.$ac_ext >&5
9227  
9228 < echo "$as_me:$LINENO: result: no" >&5
9229 < echo "${ECHO_T}no" >&6
9228 > ( exit $ac_status )
9229 > ac_cv_func_strtod=no
9230   fi
9231 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9232 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
9233 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
9234 < if test "${ac_cv_header_time+set}" = set; then
9231 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9232 > fi
9233 > fi
9234 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9235 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9236 > if test $ac_cv_func_strtod = no; then
9237 >  case $LIBOBJS in
9238 >    "strtod.$ac_objext"   | \
9239 >  *" strtod.$ac_objext"   | \
9240 >    "strtod.$ac_objext "* | \
9241 >  *" strtod.$ac_objext "* ) ;;
9242 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9243 > esac
9244 >
9245 > echo "$as_me:$LINENO: checking for pow" >&5
9246 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9247 > if test "${ac_cv_func_pow+set}" = set; then
9248    echo $ECHO_N "(cached) $ECHO_C" >&6
9249   else
9250    cat >conftest.$ac_ext <<_ACEOF
# Line 7577 | Line 9253 | cat >>conftest.$ac_ext <<_ACEOF
9253   cat confdefs.h >>conftest.$ac_ext
9254   cat >>conftest.$ac_ext <<_ACEOF
9255   /* end confdefs.h.  */
9256 < #include <sys/types.h>
9257 < #include <sys/time.h>
9258 < #include <time.h>
9256 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9257 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9258 > #define pow innocuous_pow
9259  
9260 + /* System header to define __stub macros and hopefully few prototypes,
9261 +    which can conflict with char pow (); below.
9262 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9263 +    <limits.h> exists even on freestanding compilers.  */
9264 +
9265 + #ifdef __STDC__
9266 + # include <limits.h>
9267 + #else
9268 + # include <assert.h>
9269 + #endif
9270 +
9271 + #undef pow
9272 +
9273 + /* Override any gcc2 internal prototype to avoid an error.  */
9274 + #ifdef __cplusplus
9275 + extern "C"
9276 + {
9277 + #endif
9278 + /* We use char because int might match the return type of a gcc2
9279 +   builtin and then its argument prototype would still apply.  */
9280 + char pow ();
9281 + /* The GNU C library defines this for functions which it implements
9282 +    to always fail with ENOSYS.  Some functions are actually named
9283 +    something starting with __ and the normal name is an alias.  */
9284 + #if defined (__stub_pow) || defined (__stub___pow)
9285 + choke me
9286 + #else
9287 + char (*f) () = pow;
9288 + #endif
9289 + #ifdef __cplusplus
9290 + }
9291 + #endif
9292 +
9293 + #ifdef FC_DUMMY_MAIN
9294 + #ifndef FC_DUMMY_MAIN_EQ_F77
9295 + #  ifdef __cplusplus
9296 +     extern "C"
9297 + #  endif
9298 +   int FC_DUMMY_MAIN() { return 1; }
9299 + #endif
9300 + #endif
9301   int
9302   main ()
9303   {
9304 < if ((struct tm *) 0)
7588 < return 0;
9304 > return f != pow;
9305    ;
9306    return 0;
9307   }
9308   _ACEOF
9309 < rm -f conftest.$ac_objext
9310 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9311 <  (eval $ac_compile) 2>conftest.er1
9309 > rm -f conftest.$ac_objext conftest$ac_exeext
9310 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9311 >  (eval $ac_link) 2>conftest.er1
9312    ac_status=$?
9313    grep -v '^ *+' conftest.er1 >conftest.err
9314    rm -f conftest.er1
# Line 7606 | Line 9322 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9322    ac_status=$?
9323    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9324    (exit $ac_status); }; } &&
9325 <         { ac_try='test -s conftest.$ac_objext'
9325 >         { ac_try='test -s conftest$ac_exeext'
9326    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9327    (eval $ac_try) 2>&5
9328    ac_status=$?
9329    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9330    (exit $ac_status); }; }; then
9331 <  ac_cv_header_time=yes
9331 >  ac_cv_func_pow=yes
9332   else
9333    echo "$as_me: failed program was:" >&5
9334   sed 's/^/| /' conftest.$ac_ext >&5
9335  
9336 < ac_cv_header_time=no
9336 > ac_cv_func_pow=no
9337   fi
9338 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9338 > rm -f conftest.err conftest.$ac_objext \
9339 >      conftest$ac_exeext conftest.$ac_ext
9340   fi
9341 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
9342 < echo "${ECHO_T}$ac_cv_header_time" >&6
7626 < if test $ac_cv_header_time = yes; then
9341 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9342 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9343  
9344 < cat >>confdefs.h <<\_ACEOF
9345 < #define TIME_WITH_SYS_TIME 1
9346 < _ACEOF
9347 <
7632 < fi
7633 <
7634 <
7635 < echo "$as_me:$LINENO: checking for clock_t" >&5
7636 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7637 < if test "${ac_cv_type_clock_t+set}" = set; then
9344 > if test $ac_cv_func_pow = no; then
9345 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9346 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9347 > if test "${ac_cv_lib_m_pow+set}" = set; then
9348    echo $ECHO_N "(cached) $ECHO_C" >&6
9349   else
9350 <  cat >conftest.$ac_ext <<_ACEOF
9350 >  ac_check_lib_save_LIBS=$LIBS
9351 > LIBS="-lm  $LIBS"
9352 > cat >conftest.$ac_ext <<_ACEOF
9353   /* confdefs.h.  */
9354   _ACEOF
9355   cat confdefs.h >>conftest.$ac_ext
9356   cat >>conftest.$ac_ext <<_ACEOF
9357   /* end confdefs.h.  */
9358 < $ac_includes_default
9358 >
9359 > /* Override any gcc2 internal prototype to avoid an error.  */
9360 > #ifdef __cplusplus
9361 > extern "C"
9362 > #endif
9363 > /* We use char because int might match the return type of a gcc2
9364 >   builtin and then its argument prototype would still apply.  */
9365 > char pow ();
9366 > #ifdef FC_DUMMY_MAIN
9367 > #ifndef FC_DUMMY_MAIN_EQ_F77
9368 > #  ifdef __cplusplus
9369 >     extern "C"
9370 > #  endif
9371 >   int FC_DUMMY_MAIN() { return 1; }
9372 > #endif
9373 > #endif
9374   int
9375   main ()
9376   {
9377 < if ((clock_t *) 0)
7651 <  return 0;
7652 < if (sizeof (clock_t))
7653 <  return 0;
9377 > pow ();
9378    ;
9379    return 0;
9380   }
9381   _ACEOF
9382 < rm -f conftest.$ac_objext
9383 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9384 <  (eval $ac_compile) 2>conftest.er1
9382 > rm -f conftest.$ac_objext conftest$ac_exeext
9383 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9384 >  (eval $ac_link) 2>conftest.er1
9385    ac_status=$?
9386    grep -v '^ *+' conftest.er1 >conftest.err
9387    rm -f conftest.er1
# Line 7671 | Line 9395 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9395    ac_status=$?
9396    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9397    (exit $ac_status); }; } &&
9398 <         { ac_try='test -s conftest.$ac_objext'
9398 >         { ac_try='test -s conftest$ac_exeext'
9399    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9400    (eval $ac_try) 2>&5
9401    ac_status=$?
9402    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9403    (exit $ac_status); }; }; then
9404 <  ac_cv_type_clock_t=yes
9404 >  ac_cv_lib_m_pow=yes
9405   else
9406    echo "$as_me: failed program was:" >&5
9407   sed 's/^/| /' conftest.$ac_ext >&5
9408  
9409 < ac_cv_type_clock_t=no
9409 > ac_cv_lib_m_pow=no
9410   fi
9411 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9411 > rm -f conftest.err conftest.$ac_objext \
9412 >      conftest$ac_exeext conftest.$ac_ext
9413 > LIBS=$ac_check_lib_save_LIBS
9414   fi
9415 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
9416 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
9417 < if test $ac_cv_type_clock_t = yes; then
9415 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9416 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9417 > if test $ac_cv_lib_m_pow = yes; then
9418 >  POW_LIB=-lm
9419 > else
9420 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9421 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9422 > fi
9423  
9424 < cat >>confdefs.h <<_ACEOF
7694 < #define HAVE_CLOCK_T 1
7695 < _ACEOF
9424 > fi
9425  
7697
9426   fi
9427  
9428 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
9429 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
9430 < if test "${ac_cv_c_const+set}" = set; then
9428 >
9429 >
9430 >
9431 >
9432 >
9433 >
9434 >
9435 >
9436 >
9437 >
9438 >
9439 >
9440 >
9441 >
9442 >
9443 >
9444 >
9445 >
9446 >
9447 >
9448 >
9449 >
9450 >
9451 >
9452 >
9453 >
9454 >
9455 > 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
9456 > do
9457 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9458 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9459 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9460 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9461    echo $ECHO_N "(cached) $ECHO_C" >&6
9462   else
9463    cat >conftest.$ac_ext <<_ACEOF
# Line 7708 | Line 9466 | cat >>conftest.$ac_ext <<_ACEOF
9466   cat confdefs.h >>conftest.$ac_ext
9467   cat >>conftest.$ac_ext <<_ACEOF
9468   /* end confdefs.h.  */
9469 + /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9470 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9471 + #define $ac_func innocuous_$ac_func
9472  
9473 < int
9474 < main ()
9475 < {
9476 < /* FIXME: Include the comments suggested by Paul. */
7716 < #ifndef __cplusplus
7717 <  /* Ultrix mips cc rejects this.  */
7718 <  typedef int charset[2];
7719 <  const charset x;
7720 <  /* SunOS 4.1.1 cc rejects this.  */
7721 <  char const *const *ccp;
7722 <  char **p;
7723 <  /* NEC SVR4.0.2 mips cc rejects this.  */
7724 <  struct point {int x, y;};
7725 <  static struct point const zero = {0,0};
7726 <  /* AIX XL C 1.02.0.0 rejects this.
7727 <     It does not let you subtract one const X* pointer from another in
7728 <     an arm of an if-expression whose if-part is not a constant
7729 <     expression */
7730 <  const char *g = "string";
7731 <  ccp = &g + (g ? g-g : 0);
7732 <  /* HPUX 7.0 cc rejects these. */
7733 <  ++ccp;
7734 <  p = (char**) ccp;
7735 <  ccp = (char const *const *) p;
7736 <  { /* SCO 3.2v4 cc rejects this.  */
7737 <    char *t;
7738 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
9473 > /* System header to define __stub macros and hopefully few prototypes,
9474 >    which can conflict with char $ac_func (); below.
9475 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9476 >    <limits.h> exists even on freestanding compilers.  */
9477  
9478 <    *t++ = 0;
9479 <  }
9480 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
9481 <    int x[] = {25, 17};
7744 <    const int *foo = &x[0];
7745 <    ++foo;
7746 <  }
7747 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7748 <    typedef const int *iptr;
7749 <    iptr p = 0;
7750 <    ++p;
7751 <  }
7752 <  { /* AIX XL C 1.02.0.0 rejects this saying
7753 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7754 <    struct s { int j; const int *ap[3]; };
7755 <    struct s *b; b->j = 5;
7756 <  }
7757 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7758 <    const int foo = 10;
7759 <  }
9478 > #ifdef __STDC__
9479 > # include <limits.h>
9480 > #else
9481 > # include <assert.h>
9482   #endif
9483  
9484 + #undef $ac_func
9485 +
9486 + /* Override any gcc2 internal prototype to avoid an error.  */
9487 + #ifdef __cplusplus
9488 + extern "C"
9489 + {
9490 + #endif
9491 + /* We use char because int might match the return type of a gcc2
9492 +   builtin and then its argument prototype would still apply.  */
9493 + char $ac_func ();
9494 + /* The GNU C library defines this for functions which it implements
9495 +    to always fail with ENOSYS.  Some functions are actually named
9496 +    something starting with __ and the normal name is an alias.  */
9497 + #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9498 + choke me
9499 + #else
9500 + char (*f) () = $ac_func;
9501 + #endif
9502 + #ifdef __cplusplus
9503 + }
9504 + #endif
9505 +
9506 + #ifdef FC_DUMMY_MAIN
9507 + #ifndef FC_DUMMY_MAIN_EQ_F77
9508 + #  ifdef __cplusplus
9509 +     extern "C"
9510 + #  endif
9511 +   int FC_DUMMY_MAIN() { return 1; }
9512 + #endif
9513 + #endif
9514 + int
9515 + main ()
9516 + {
9517 + return f != $ac_func;
9518    ;
9519    return 0;
9520   }
9521   _ACEOF
9522 < rm -f conftest.$ac_objext
9523 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9524 <  (eval $ac_compile) 2>conftest.er1
9522 > rm -f conftest.$ac_objext conftest$ac_exeext
9523 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9524 >  (eval $ac_link) 2>conftest.er1
9525    ac_status=$?
9526    grep -v '^ *+' conftest.er1 >conftest.err
9527    rm -f conftest.er1
# Line 7779 | Line 9535 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9535    ac_status=$?
9536    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9537    (exit $ac_status); }; } &&
9538 <         { ac_try='test -s conftest.$ac_objext'
9538 >         { ac_try='test -s conftest$ac_exeext'
9539    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9540    (eval $ac_try) 2>&5
9541    ac_status=$?
9542    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9543    (exit $ac_status); }; }; then
9544 <  ac_cv_c_const=yes
9544 >  eval "$as_ac_var=yes"
9545   else
9546    echo "$as_me: failed program was:" >&5
9547   sed 's/^/| /' conftest.$ac_ext >&5
9548  
9549 < ac_cv_c_const=no
9549 > eval "$as_ac_var=no"
9550   fi
9551 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9551 > rm -f conftest.err conftest.$ac_objext \
9552 >      conftest$ac_exeext conftest.$ac_ext
9553   fi
9554 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
9555 < echo "${ECHO_T}$ac_cv_c_const" >&6
9556 < if test $ac_cv_c_const = no; then
9557 <
9558 < cat >>confdefs.h <<\_ACEOF
7802 < #define const
9554 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9555 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9556 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9557 >  cat >>confdefs.h <<_ACEOF
9558 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9559   _ACEOF
9560  
9561   fi
9562 + done
9563  
9564 < echo "$as_me:$LINENO: checking for inline" >&5
9565 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
9566 < if test "${ac_cv_c_inline+set}" = set; then
9567 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9568 < else
9569 <  ac_cv_c_inline=no
7813 < for ac_kw in inline __inline__ __inline; do
7814 <  cat >conftest.$ac_ext <<_ACEOF
9564 >
9565 > # special check for _system_configuration because AIX <4.3.2 do not
9566 > # contain the `physmem' member.
9567 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9568 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9569 > cat >conftest.$ac_ext <<_ACEOF
9570   /* confdefs.h.  */
9571   _ACEOF
9572   cat confdefs.h >>conftest.$ac_ext
9573   cat >>conftest.$ac_ext <<_ACEOF
9574   /* end confdefs.h.  */
9575 < #ifndef __cplusplus
9576 < typedef int foo_t;
9577 < static $ac_kw foo_t static_foo () {return 0; }
9578 < $ac_kw foo_t foo () {return 0; }
9575 > #include <sys/systemcfg.h>
9576 > #ifdef FC_DUMMY_MAIN
9577 > #ifndef FC_DUMMY_MAIN_EQ_F77
9578 > #  ifdef __cplusplus
9579 >     extern "C"
9580 > #  endif
9581 >   int FC_DUMMY_MAIN() { return 1; }
9582   #endif
9583 <
9583 > #endif
9584 > int
9585 > main ()
9586 > {
9587 > double x = _system_configuration.physmem;
9588 >  ;
9589 >  return 0;
9590 > }
9591   _ACEOF
9592   rm -f conftest.$ac_objext
9593   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7846 | Line 9611 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9611    ac_status=$?
9612    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9613    (exit $ac_status); }; }; then
9614 <  ac_cv_c_inline=$ac_kw; break
9614 >  echo "$as_me:$LINENO: result: yes" >&5
9615 > echo "${ECHO_T}yes" >&6
9616 >
9617 > cat >>confdefs.h <<\_ACEOF
9618 > #define HAVE__SYSTEM_CONFIGURATION 1
9619 > _ACEOF
9620 >
9621   else
9622    echo "$as_me: failed program was:" >&5
9623   sed 's/^/| /' conftest.$ac_ext >&5
9624  
9625 + echo "$as_me:$LINENO: result: no" >&5
9626 + echo "${ECHO_T}no" >&6
9627   fi
9628   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7856 done
9629  
7858 fi
7859 echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7860 echo "${ECHO_T}$ac_cv_c_inline" >&6
7861
7862
7863 case $ac_cv_c_inline in
7864  inline | yes) ;;
7865  *)
7866    case $ac_cv_c_inline in
7867      no) ac_val=;;
7868      *) ac_val=$ac_cv_c_inline;;
7869    esac
7870    cat >>confdefs.h <<_ACEOF
7871 #ifndef __cplusplus
7872 #define inline $ac_val
7873 #endif
7874 _ACEOF
7875    ;;
7876 esac
7877
7878
7879
9630    # clean out junk possibly left behind by a previous configuration
9631    rm -f src/getopt.h
9632    # Check for getopt_long support
# Line 8082 | Line 9832 | char (*f) () = $ac_func;
9832   }
9833   #endif
9834  
9835 + #ifdef FC_DUMMY_MAIN
9836 + #ifndef FC_DUMMY_MAIN_EQ_F77
9837 + #  ifdef __cplusplus
9838 +     extern "C"
9839 + #  endif
9840 +   int FC_DUMMY_MAIN() { return 1; }
9841 + #endif
9842 + #endif
9843   int
9844   main ()
9845   {
# Line 8152 | Line 9910 | char getopt_long ();
9910   /* We use char because int might match the return type of a gcc2
9911     builtin and then its argument prototype would still apply.  */
9912   char getopt_long ();
9913 + #ifdef FC_DUMMY_MAIN
9914 + #ifndef FC_DUMMY_MAIN_EQ_F77
9915 + #  ifdef __cplusplus
9916 +     extern "C"
9917 + #  endif
9918 +   int FC_DUMMY_MAIN() { return 1; }
9919 + #endif
9920 + #endif
9921   int
9922   main ()
9923   {
# Line 8226 | Line 9992 | done
9992   done
9993  
9994  
9995 + ac_ext=cc
9996 + ac_cpp='$CXXCPP $CPPFLAGS'
9997 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9998 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9999 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10000  
8230 case $debug in
8231  1)
8232     ;;
8233  *)
10001  
10002 <
10003 <
10004 <
8238 <
8239 <
8240 < echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
8241 < echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
8242 < if test "${ac_cv_prog_really_gcc+set}" = set; then
10002 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10003 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10004 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10005    echo $ECHO_N "(cached) $ECHO_C" >&6
10006   else
10007  
8246 cat > conftest.c <<EOF
8247 #ifdef __GNUC__
8248  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
8249     no;
8250  #else
8251     yes;
8252  #endif
8253 #endif
8254 EOF
8255 if { ac_try='${CC-cc} -E conftest.c'
8256  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8257  (eval $ac_try) 2>&5
8258  ac_status=$?
8259  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8260  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8261  ac_cv_prog_really_gcc=yes
8262 else
8263  ac_cv_prog_really_gcc=no
8264 fi
10008  
10009 < fi
10010 < echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
10011 < echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6
10012 < if test "$ac_cv_prog_really_gcc" = yes; then
10013 <        :
10009 > ac_ext=cc
10010 > ac_cpp='$CXXCPP $CPPFLAGS'
10011 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10012 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10013 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10014  
10015 + cat >conftest.$ac_ext <<_ACEOF
10016 + /* confdefs.h.  */
10017 + _ACEOF
10018 + cat confdefs.h >>conftest.$ac_ext
10019 + cat >>conftest.$ac_ext <<_ACEOF
10020 + /* end confdefs.h.  */
10021 + namespace Outer { namespace Inner { int i = 0; }}
10022 + #ifdef FC_DUMMY_MAIN
10023 + #ifndef FC_DUMMY_MAIN_EQ_F77
10024 + #  ifdef __cplusplus
10025 +     extern "C"
10026 + #  endif
10027 +   int FC_DUMMY_MAIN() { return 1; }
10028 + #endif
10029 + #endif
10030 + int
10031 + main ()
10032 + {
10033 + using namespace Outer::Inner; return i;
10034 +  ;
10035 +  return 0;
10036 + }
10037 + _ACEOF
10038 + rm -f conftest.$ac_objext
10039 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10040 +  (eval $ac_compile) 2>conftest.er1
10041 +  ac_status=$?
10042 +  grep -v '^ *+' conftest.er1 >conftest.err
10043 +  rm -f conftest.er1
10044 +  cat conftest.err >&5
10045 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10046 +  (exit $ac_status); } &&
10047 +         { ac_try='test -z "$ac_cxx_werror_flag"
10048 +                         || test ! -s conftest.err'
10049 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10050 +  (eval $ac_try) 2>&5
10051 +  ac_status=$?
10052 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10053 +  (exit $ac_status); }; } &&
10054 +         { ac_try='test -s conftest.$ac_objext'
10055 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10056 +  (eval $ac_try) 2>&5
10057 +  ac_status=$?
10058 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10059 +  (exit $ac_status); }; }; then
10060 +  ac_cv_cxx_namespaces=yes
10061   else
10062 <        :
10062 >  echo "$as_me: failed program was:" >&5
10063 > sed 's/^/| /' conftest.$ac_ext >&5
10064  
10065 + ac_cv_cxx_namespaces=no
10066   fi
10067 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10068 + ac_ext=cc
10069 + ac_cpp='$CXXCPP $CPPFLAGS'
10070 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10071 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10072 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10073  
10074  
8278 # Try to determine "good" native compiler flags if none specified on command
8279 # line
8280 if test "$ac_test_CFLAGS" != "set"; then
8281  CFLAGS=""
8282  case "${host_cpu}-${host_os}" in
8283
8284  *linux*) if test "$CC" = icc; then
8285                    CFLAGS="-O"
8286                fi;;
8287  sparc-solaris2*) if test "$CC" = cc; then
8288                    CFLAGS="-native -fast -xO5 -dalign"
8289                 fi;;
8290
8291  alpha*-osf*)  if test "$CC" = cc; then
8292                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
8293                fi;;
8294
8295  hppa*-hpux*)  if test "$CC" = cc; then
8296                    CFLAGS="-Ae +O3 +Oall"
8297                fi;;
8298
8299   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
8300                    CFLAGS="-O3 -qtune=auto -qansialias -w"
8301                fi;;
8302   powerpc*-aix*)
8303        if test "$CC" = cc -o "$CC" = xlc; then
8304                CFLAGS="-O3 -qtune=auto -qansialias -w"
8305                echo "*******************************************************"
8306                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8307                echo "*  recommended that you use                           *"
8308                echo "*                                                     *"
8309                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8310                echo "*                                 ^^^                 *"
8311                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8312                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
8313                echo "*******************************************************"
8314        fi;;
8315   *darwin*)
8316        if test "$CC" = xlc -o "$CC" = cc; then
8317                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
8318        fi;;
8319  esac
8320
8321  # use default flags for gcc on all systems
8322  if test $ac_cv_prog_really_gcc = yes; then
8323     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
8324  fi
8325
8326  # test for gcc-specific flags:
8327  if test $ac_cv_prog_really_gcc = yes; then
8328    # -malign-double for x86 systems
8329
8330
8331 echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
8332 echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
8333 if test "${ac_align_double+set}" = set; then
8334  echo $ECHO_N "(cached) $ECHO_C" >&6
8335 else
8336  echo 'void f(){}' > conftest.c
8337 if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
8338        ac_align_double=yes
8339 else
8340        ac_align_double=no
10075   fi
10076 < rm -f conftest*
10076 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10077 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10078 > if test "$ac_cv_cxx_namespaces" = yes; then
10079  
10080 < fi
10081 < echo "$as_me:$LINENO: result: $ac_align_double" >&5
10082 < echo "${ECHO_T}$ac_align_double" >&6
8347 < if test "$ac_align_double" = yes; then
8348 <        :
8349 <        CFLAGS="$CFLAGS -malign-double"
8350 < else
8351 <        :
10080 > cat >>confdefs.h <<\_ACEOF
10081 > #define HAVE_NAMESPACES
10082 > _ACEOF
10083  
10084   fi
10085  
10086 <    # -fstrict-aliasing for gcc-2.95+
10087 <
10088 <
10089 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
10090 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
10091 < if test "${ac_fstrict_aliasing+set}" = set; then
10092 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10093 < else
10094 <  echo 'void f(){}' > conftest.c
10095 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
10096 <        ac_fstrict_aliasing=yes
10097 < else
10098 <        ac_fstrict_aliasing=no
10099 < fi
10100 < rm -f conftest*
10101 <
10102 < fi
10103 < echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
10104 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6
10105 < if test "$ac_fstrict_aliasing" = yes; then
10106 <        :
10107 <        CFLAGS="$CFLAGS -fstrict-aliasing"
10108 < else
10109 <        :
10086 > ac_ext=cc
10087 > ac_cpp='$CXXCPP $CPPFLAGS'
10088 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10089 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10090 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10091 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10092 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10093 > if test -z "$CXXCPP"; then
10094 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10095 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10096 > else
10097 >      # Double quotes because CXXCPP needs to be expanded
10098 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10099 >    do
10100 >      ac_preproc_ok=false
10101 > for ac_cxx_preproc_warn_flag in '' yes
10102 > do
10103 >  # Use a header file that comes with gcc, so configuring glibc
10104 >  # with a fresh cross-compiler works.
10105 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10106 >  # <limits.h> exists even on freestanding compilers.
10107 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10108 >  # not just through cpp. "Syntax error" is here to catch this case.
10109 >  cat >conftest.$ac_ext <<_ACEOF
10110 > /* confdefs.h.  */
10111 > _ACEOF
10112 > cat confdefs.h >>conftest.$ac_ext
10113 > cat >>conftest.$ac_ext <<_ACEOF
10114 > /* end confdefs.h.  */
10115 > #ifdef __STDC__
10116 > # include <limits.h>
10117 > #else
10118 > # include <assert.h>
10119 > #endif
10120 >                     Syntax error
10121 > _ACEOF
10122 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10123 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10124 >  ac_status=$?
10125 >  grep -v '^ *+' conftest.er1 >conftest.err
10126 >  rm -f conftest.er1
10127 >  cat conftest.err >&5
10128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10129 >  (exit $ac_status); } >/dev/null; then
10130 >  if test -s conftest.err; then
10131 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10132 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10133 >  else
10134 >    ac_cpp_err=
10135 >  fi
10136 > else
10137 >  ac_cpp_err=yes
10138 > fi
10139 > if test -z "$ac_cpp_err"; then
10140 >  :
10141 > else
10142 >  echo "$as_me: failed program was:" >&5
10143 > sed 's/^/| /' conftest.$ac_ext >&5
10144  
10145 +  # Broken: fails on valid input.
10146 + continue
10147   fi
10148 + rm -f conftest.err conftest.$ac_ext
10149  
10150 +  # OK, works on sane cases.  Now check whether non-existent headers
10151 +  # can be detected and how.
10152 +  cat >conftest.$ac_ext <<_ACEOF
10153 + /* confdefs.h.  */
10154 + _ACEOF
10155 + cat confdefs.h >>conftest.$ac_ext
10156 + cat >>conftest.$ac_ext <<_ACEOF
10157 + /* end confdefs.h.  */
10158 + #include <ac_nonexistent.h>
10159 + _ACEOF
10160 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10161 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10162 +  ac_status=$?
10163 +  grep -v '^ *+' conftest.er1 >conftest.err
10164 +  rm -f conftest.er1
10165 +  cat conftest.err >&5
10166 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10167 +  (exit $ac_status); } >/dev/null; then
10168 +  if test -s conftest.err; then
10169 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
10170 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10171 +  else
10172 +    ac_cpp_err=
10173    fi
8383
8384  CPU_FLAGS=""
8385  if test $ac_cv_prog_really_gcc = yes; then
8386                  case "${host_cpu}" in
8387          i586*)
8388
8389 echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
8390 echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
8391 if test "${ac_cpu_pentium+set}" = set; then
8392  echo $ECHO_N "(cached) $ECHO_C" >&6
10174   else
10175 <  echo 'void f(){}' > conftest.c
10176 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
10177 <        ac_cpu_pentium=yes
10175 >  ac_cpp_err=yes
10176 > fi
10177 > if test -z "$ac_cpp_err"; then
10178 >  # Broken: success on invalid input.
10179 > continue
10180   else
10181 <        ac_cpu_pentium=no
10181 >  echo "$as_me: failed program was:" >&5
10182 > sed 's/^/| /' conftest.$ac_ext >&5
10183 >
10184 >  # Passes both tests.
10185 > ac_preproc_ok=:
10186 > break
10187   fi
10188 < rm -f conftest*
10188 > rm -f conftest.err conftest.$ac_ext
10189  
10190 + done
10191 + # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10192 + rm -f conftest.err conftest.$ac_ext
10193 + if $ac_preproc_ok; then
10194 +  break
10195   fi
8403 echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
8404 echo "${ECHO_T}$ac_cpu_pentium" >&6
8405 if test "$ac_cpu_pentium" = yes; then
8406        :
8407        CPU_FLAGS=-mcpu=pentium
8408 else
8409        :
10196  
10197 +    done
10198 +    ac_cv_prog_CXXCPP=$CXXCPP
10199  
10200 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
10201 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
8414 < if test "${ac_pentium+set}" = set; then
8415 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10200 > fi
10201 >  CXXCPP=$ac_cv_prog_CXXCPP
10202   else
10203 <  echo 'void f(){}' > conftest.c
10204 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
10205 <        ac_pentium=yes
10203 >  ac_cv_prog_CXXCPP=$CXXCPP
10204 > fi
10205 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10206 > echo "${ECHO_T}$CXXCPP" >&6
10207 > ac_preproc_ok=false
10208 > for ac_cxx_preproc_warn_flag in '' yes
10209 > do
10210 >  # Use a header file that comes with gcc, so configuring glibc
10211 >  # with a fresh cross-compiler works.
10212 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10213 >  # <limits.h> exists even on freestanding compilers.
10214 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10215 >  # not just through cpp. "Syntax error" is here to catch this case.
10216 >  cat >conftest.$ac_ext <<_ACEOF
10217 > /* confdefs.h.  */
10218 > _ACEOF
10219 > cat confdefs.h >>conftest.$ac_ext
10220 > cat >>conftest.$ac_ext <<_ACEOF
10221 > /* end confdefs.h.  */
10222 > #ifdef __STDC__
10223 > # include <limits.h>
10224 > #else
10225 > # include <assert.h>
10226 > #endif
10227 >                     Syntax error
10228 > _ACEOF
10229 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10230 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10231 >  ac_status=$?
10232 >  grep -v '^ *+' conftest.er1 >conftest.err
10233 >  rm -f conftest.er1
10234 >  cat conftest.err >&5
10235 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10236 >  (exit $ac_status); } >/dev/null; then
10237 >  if test -s conftest.err; then
10238 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10239 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10240 >  else
10241 >    ac_cpp_err=
10242 >  fi
10243   else
10244 <        ac_pentium=no
10244 >  ac_cpp_err=yes
10245   fi
10246 < rm -f conftest*
10246 > if test -z "$ac_cpp_err"; then
10247 >  :
10248 > else
10249 >  echo "$as_me: failed program was:" >&5
10250 > sed 's/^/| /' conftest.$ac_ext >&5
10251  
10252 +  # Broken: fails on valid input.
10253 + continue
10254   fi
10255 < echo "$as_me:$LINENO: result: $ac_pentium" >&5
8427 < echo "${ECHO_T}$ac_pentium" >&6
8428 < if test "$ac_pentium" = yes; then
8429 <        :
8430 <        CPU_FLAGS=-mpentium
8431 < else
8432 <        :
10255 > rm -f conftest.err conftest.$ac_ext
10256  
10257 +  # OK, works on sane cases.  Now check whether non-existent headers
10258 +  # can be detected and how.
10259 +  cat >conftest.$ac_ext <<_ACEOF
10260 + /* confdefs.h.  */
10261 + _ACEOF
10262 + cat confdefs.h >>conftest.$ac_ext
10263 + cat >>conftest.$ac_ext <<_ACEOF
10264 + /* end confdefs.h.  */
10265 + #include <ac_nonexistent.h>
10266 + _ACEOF
10267 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10268 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10269 +  ac_status=$?
10270 +  grep -v '^ *+' conftest.er1 >conftest.err
10271 +  rm -f conftest.er1
10272 +  cat conftest.err >&5
10273 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10274 +  (exit $ac_status); } >/dev/null; then
10275 +  if test -s conftest.err; then
10276 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
10277 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10278 +  else
10279 +    ac_cpp_err=
10280 +  fi
10281 + else
10282 +  ac_cpp_err=yes
10283   fi
10284 + if test -z "$ac_cpp_err"; then
10285 +  # Broken: success on invalid input.
10286 + continue
10287 + else
10288 +  echo "$as_me: failed program was:" >&5
10289 + sed 's/^/| /' conftest.$ac_ext >&5
10290  
10291 +  # Passes both tests.
10292 + ac_preproc_ok=:
10293 + break
10294   fi
10295 + rm -f conftest.err conftest.$ac_ext
10296  
10297 <                  ;;
10298 <          i686*)
10299 <
10300 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
10301 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
8443 < if test "${ac_cpu_pentiumpro+set}" = set; then
8444 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10297 > done
10298 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10299 > rm -f conftest.err conftest.$ac_ext
10300 > if $ac_preproc_ok; then
10301 >  :
10302   else
10303 <  echo 'void f(){}' > conftest.c
10304 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
10305 <        ac_cpu_pentiumpro=yes
10306 < else
10307 <        ac_cpu_pentiumpro=no
10303 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10304 > See \`config.log' for more details." >&5
10305 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10306 > See \`config.log' for more details." >&2;}
10307 >   { (exit 1); exit 1; }; }
10308   fi
8452 rm -f conftest*
10309  
10310 < fi
10311 < echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
10312 < echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
10313 < if test "$ac_cpu_pentiumpro" = yes; then
10314 <        :
8459 <        CPU_FLAGS=-mcpu=pentiumpro
8460 < else
8461 <        :
10310 > ac_ext=cc
10311 > ac_cpp='$CXXCPP $CPPFLAGS'
10312 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10313 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10314 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10315  
10316  
10317 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
10318 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
10319 < if test "${ac_pentiumpro+set}" = set; then
10317 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10318 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10319 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10320    echo $ECHO_N "(cached) $ECHO_C" >&6
10321   else
8469  echo 'void f(){}' > conftest.c
8470 if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
8471        ac_pentiumpro=yes
8472 else
8473        ac_pentiumpro=no
8474 fi
8475 rm -f conftest*
10322  
8477 fi
8478 echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
8479 echo "${ECHO_T}$ac_pentiumpro" >&6
8480 if test "$ac_pentiumpro" = yes; then
8481        :
8482        CPU_FLAGS=-mpentiumpro
8483 else
8484        :
10323  
8486 fi
10324  
10325 < fi
10325 > ac_ext=cc
10326 > ac_cpp='$CXXCPP $CPPFLAGS'
10327 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10328 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10329 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10330  
10331 <                  ;;
10332 <          powerpc*)
10333 <                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
10334 <                is60x=`echo $cputype | egrep "^600-9e?$"`
10335 <                if test -n "$is60x"; then
10336 <
10337 <
10338 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
10339 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
10340 < if test "${ac_m_cpu_60x+set}" = set; then
10341 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10331 > cat >conftest.$ac_ext <<_ACEOF
10332 > /* confdefs.h.  */
10333 > _ACEOF
10334 > cat confdefs.h >>conftest.$ac_ext
10335 > cat >>conftest.$ac_ext <<_ACEOF
10336 > /* end confdefs.h.  */
10337 > #include <list>
10338 > #include <deque>
10339 > #ifdef HAVE_NAMESPACES
10340 > using namespace std;
10341 > #endif
10342 > #ifdef FC_DUMMY_MAIN
10343 > #ifndef FC_DUMMY_MAIN_EQ_F77
10344 > #  ifdef __cplusplus
10345 >     extern "C"
10346 > #  endif
10347 >   int FC_DUMMY_MAIN() { return 1; }
10348 > #endif
10349 > #endif
10350 > int
10351 > main ()
10352 > {
10353 > list<int> x; x.push_back(5);
10354 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10355 >  ;
10356 >  return 0;
10357 > }
10358 > _ACEOF
10359 > rm -f conftest.$ac_objext
10360 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10361 >  (eval $ac_compile) 2>conftest.er1
10362 >  ac_status=$?
10363 >  grep -v '^ *+' conftest.er1 >conftest.err
10364 >  rm -f conftest.er1
10365 >  cat conftest.err >&5
10366 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10367 >  (exit $ac_status); } &&
10368 >         { ac_try='test -z "$ac_cxx_werror_flag"
10369 >                         || test ! -s conftest.err'
10370 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10371 >  (eval $ac_try) 2>&5
10372 >  ac_status=$?
10373 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10374 >  (exit $ac_status); }; } &&
10375 >         { ac_try='test -s conftest.$ac_objext'
10376 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10377 >  (eval $ac_try) 2>&5
10378 >  ac_status=$?
10379 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380 >  (exit $ac_status); }; }; then
10381 >  ac_cv_cxx_have_stl=yes
10382   else
10383 <  echo 'void f(){}' > conftest.c
10384 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
10385 <        ac_m_cpu_60x=yes
10386 < else
8506 <        ac_m_cpu_60x=no
10383 >  echo "$as_me: failed program was:" >&5
10384 > sed 's/^/| /' conftest.$ac_ext >&5
10385 >
10386 > ac_cv_cxx_have_stl=no
10387   fi
10388 < rm -f conftest*
10388 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10389 > ac_ext=cc
10390 > ac_cpp='$CXXCPP $CPPFLAGS'
10391 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10392 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10393 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10394  
10395 +
10396   fi
10397 < echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
10398 < echo "${ECHO_T}$ac_m_cpu_60x" >&6
10399 < if test "$ac_m_cpu_60x" = yes; then
8514 <        :
8515 <        CPU_FLAGS=-mcpu=$cputype
8516 < else
8517 <        :
10397 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10398 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10399 > if test "$ac_cv_cxx_have_stl" = yes; then
10400  
10401 + cat >>confdefs.h <<\_ACEOF
10402 + #define HAVE_STL
10403 + _ACEOF
10404 +
10405   fi
10406  
8521                elif test "$cputype" = 750; then
10407  
10408  
10409 < echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
10410 < echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6
10411 < if test "${ac_cv_prog_gcc_2_95+set}" = set; then
10409 >  if test "${ac_cv_header_iostream+set}" = set; then
10410 >  echo "$as_me:$LINENO: checking for iostream" >&5
10411 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10412 > if test "${ac_cv_header_iostream+set}" = set; then
10413    echo $ECHO_N "(cached) $ECHO_C" >&6
10414 + fi
10415 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10416 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10417   else
10418 <
10419 < cat > conftest.c <<EOF
10420 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
10421 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
10422 <     yes;
10423 < #  endif
10424 < #endif
10425 < EOF
10426 < if { ac_try='${CC-cc} -E conftest.c'
10418 >  # Is the header compilable?
10419 > echo "$as_me:$LINENO: checking iostream usability" >&5
10420 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10421 > cat >conftest.$ac_ext <<_ACEOF
10422 > /* confdefs.h.  */
10423 > _ACEOF
10424 > cat confdefs.h >>conftest.$ac_ext
10425 > cat >>conftest.$ac_ext <<_ACEOF
10426 > /* end confdefs.h.  */
10427 > $ac_includes_default
10428 > #include <iostream>
10429 > _ACEOF
10430 > rm -f conftest.$ac_objext
10431 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10432 >  (eval $ac_compile) 2>conftest.er1
10433 >  ac_status=$?
10434 >  grep -v '^ *+' conftest.er1 >conftest.err
10435 >  rm -f conftest.er1
10436 >  cat conftest.err >&5
10437 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10438 >  (exit $ac_status); } &&
10439 >         { ac_try='test -z "$ac_cxx_werror_flag"
10440 >                         || test ! -s conftest.err'
10441    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10442    (eval $ac_try) 2>&5
10443    ac_status=$?
10444    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10445 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
10446 <  ac_cv_prog_gcc_2_95=yes
10445 >  (exit $ac_status); }; } &&
10446 >         { ac_try='test -s conftest.$ac_objext'
10447 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10448 >  (eval $ac_try) 2>&5
10449 >  ac_status=$?
10450 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10451 >  (exit $ac_status); }; }; then
10452 >  ac_header_compiler=yes
10453   else
10454 <  ac_cv_prog_gcc_2_95=no
10455 < fi
10454 >  echo "$as_me: failed program was:" >&5
10455 > sed 's/^/| /' conftest.$ac_ext >&5
10456  
10457 + ac_header_compiler=no
10458   fi
10459 < echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
10460 < echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6
10461 < if test "$ac_cv_prog_gcc_2_95" = yes; then
8552 <        :
10459 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10460 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10461 > echo "${ECHO_T}$ac_header_compiler" >&6
10462  
10463 <
10464 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
10465 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
10466 < if test "${ac_m_cpu_750+set}" = set; then
10467 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10463 > # Is the header present?
10464 > echo "$as_me:$LINENO: checking iostream presence" >&5
10465 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10466 > cat >conftest.$ac_ext <<_ACEOF
10467 > /* confdefs.h.  */
10468 > _ACEOF
10469 > cat confdefs.h >>conftest.$ac_ext
10470 > cat >>conftest.$ac_ext <<_ACEOF
10471 > /* end confdefs.h.  */
10472 > #include <iostream>
10473 > _ACEOF
10474 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10475 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10476 >  ac_status=$?
10477 >  grep -v '^ *+' conftest.er1 >conftest.err
10478 >  rm -f conftest.er1
10479 >  cat conftest.err >&5
10480 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10481 >  (exit $ac_status); } >/dev/null; then
10482 >  if test -s conftest.err; then
10483 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10484 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10485 >  else
10486 >    ac_cpp_err=
10487 >  fi
10488   else
10489 <  echo 'void f(){}' > conftest.c
8561 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
8562 <        ac_m_cpu_750=yes
8563 < else
8564 <        ac_m_cpu_750=no
10489 >  ac_cpp_err=yes
10490   fi
10491 < rm -f conftest*
10492 <
8568 < fi
8569 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
8570 < echo "${ECHO_T}$ac_m_cpu_750" >&6
8571 < if test "$ac_m_cpu_750" = yes; then
8572 <        :
8573 <        CPU_FLAGS=-mcpu=750
10491 > if test -z "$ac_cpp_err"; then
10492 >  ac_header_preproc=yes
10493   else
10494 <        :
10494 >  echo "$as_me: failed program was:" >&5
10495 > sed 's/^/| /' conftest.$ac_ext >&5
10496  
10497 +  ac_header_preproc=no
10498   fi
10499 + rm -f conftest.err conftest.$ac_ext
10500 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10501 + echo "${ECHO_T}$ac_header_preproc" >&6
10502  
10503 < else
10504 <        :
10503 > # So?  What about this header?
10504 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10505 >  yes:no: )
10506 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10507 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10508 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10509 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10510 >    ac_header_preproc=yes
10511 >    ;;
10512 >  no:yes:* )
10513 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10514 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10515 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10516 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10517 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10518 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10519 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10520 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10521 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10522 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10523 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10524 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10525 >    (
10526 >      cat <<\_ASBOX
10527 > ## ------------------------------ ##
10528 > ## Report this to gezelter@nd.edu ##
10529 > ## ------------------------------ ##
10530 > _ASBOX
10531 >    ) |
10532 >      sed "s/^/$as_me: WARNING:     /" >&2
10533 >    ;;
10534 > esac
10535 > echo "$as_me:$LINENO: checking for iostream" >&5
10536 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10537 > if test "${ac_cv_header_iostream+set}" = set; then
10538 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10539 > else
10540 >  ac_cv_header_iostream=$ac_header_preproc
10541 > fi
10542 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10543 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10544  
10545   fi
10546 + if test $ac_cv_header_iostream = yes; then
10547  
8584                fi
8585                if test -z "$CPU_FLAGS"; then
10548  
10549 + cat >>confdefs.h <<\_ACEOF
10550 + #define HAVE_IOSTREAM 1
10551 + _ACEOF
10552  
10553 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
10554 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
10555 < if test "${ac_m_cpu_powerpc+set}" = set; then
10553 >
10554 > else
10555 >
10556 >
10557 > for ac_header in iostream.h
10558 > do
10559 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10560 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10561 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10562 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10563 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10564    echo $ECHO_N "(cached) $ECHO_C" >&6
10565 + fi
10566 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10567 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10568   else
10569 <  echo 'void f(){}' > conftest.c
10570 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
10571 <        ac_m_cpu_powerpc=yes
10569 >  # Is the header compilable?
10570 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10571 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10572 > cat >conftest.$ac_ext <<_ACEOF
10573 > /* confdefs.h.  */
10574 > _ACEOF
10575 > cat confdefs.h >>conftest.$ac_ext
10576 > cat >>conftest.$ac_ext <<_ACEOF
10577 > /* end confdefs.h.  */
10578 > $ac_includes_default
10579 > #include <$ac_header>
10580 > _ACEOF
10581 > rm -f conftest.$ac_objext
10582 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10583 >  (eval $ac_compile) 2>conftest.er1
10584 >  ac_status=$?
10585 >  grep -v '^ *+' conftest.er1 >conftest.err
10586 >  rm -f conftest.er1
10587 >  cat conftest.err >&5
10588 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589 >  (exit $ac_status); } &&
10590 >         { ac_try='test -z "$ac_cxx_werror_flag"
10591 >                         || test ! -s conftest.err'
10592 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10593 >  (eval $ac_try) 2>&5
10594 >  ac_status=$?
10595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10596 >  (exit $ac_status); }; } &&
10597 >         { ac_try='test -s conftest.$ac_objext'
10598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10599 >  (eval $ac_try) 2>&5
10600 >  ac_status=$?
10601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10602 >  (exit $ac_status); }; }; then
10603 >  ac_header_compiler=yes
10604   else
10605 <        ac_m_cpu_powerpc=no
10605 >  echo "$as_me: failed program was:" >&5
10606 > sed 's/^/| /' conftest.$ac_ext >&5
10607 >
10608 > ac_header_compiler=no
10609   fi
10610 < rm -f conftest*
10610 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10611 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10612 > echo "${ECHO_T}$ac_header_compiler" >&6
10613  
10614 + # Is the header present?
10615 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
10616 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10617 + cat >conftest.$ac_ext <<_ACEOF
10618 + /* confdefs.h.  */
10619 + _ACEOF
10620 + cat confdefs.h >>conftest.$ac_ext
10621 + cat >>conftest.$ac_ext <<_ACEOF
10622 + /* end confdefs.h.  */
10623 + #include <$ac_header>
10624 + _ACEOF
10625 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10626 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10627 +  ac_status=$?
10628 +  grep -v '^ *+' conftest.er1 >conftest.err
10629 +  rm -f conftest.er1
10630 +  cat conftest.err >&5
10631 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10632 +  (exit $ac_status); } >/dev/null; then
10633 +  if test -s conftest.err; then
10634 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
10635 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10636 +  else
10637 +    ac_cpp_err=
10638 +  fi
10639 + else
10640 +  ac_cpp_err=yes
10641   fi
10642 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
10643 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
8604 < if test "$ac_m_cpu_powerpc" = yes; then
8605 <        :
8606 <        CPU_FLAGS=-mcpu=powerpc
10642 > if test -z "$ac_cpp_err"; then
10643 >  ac_header_preproc=yes
10644   else
10645 <        :
10645 >  echo "$as_me: failed program was:" >&5
10646 > sed 's/^/| /' conftest.$ac_ext >&5
10647  
10648 +  ac_header_preproc=no
10649   fi
10650 + rm -f conftest.err conftest.$ac_ext
10651 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10652 + echo "${ECHO_T}$ac_header_preproc" >&6
10653  
10654 <                fi
10655 <                if test -z "$CPU_FLAGS"; then
10656 <
10657 <
10658 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
10659 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
10660 < if test "${ac_m_powerpc+set}" = set; then
10654 > # So?  What about this header?
10655 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10656 >  yes:no: )
10657 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10658 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10659 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10660 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10661 >    ac_header_preproc=yes
10662 >    ;;
10663 >  no:yes:* )
10664 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10665 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10666 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10667 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10668 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10669 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10670 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10671 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10672 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10673 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10674 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10675 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10676 >    (
10677 >      cat <<\_ASBOX
10678 > ## ------------------------------ ##
10679 > ## Report this to gezelter@nd.edu ##
10680 > ## ------------------------------ ##
10681 > _ASBOX
10682 >    ) |
10683 >      sed "s/^/$as_me: WARNING:     /" >&2
10684 >    ;;
10685 > esac
10686 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10687 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10688 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10689    echo $ECHO_N "(cached) $ECHO_C" >&6
10690   else
10691 <  echo 'void f(){}' > conftest.c
8622 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
8623 <        ac_m_powerpc=yes
8624 < else
8625 <        ac_m_powerpc=no
10691 >  eval "$as_ac_Header=\$ac_header_preproc"
10692   fi
10693 < rm -f conftest*
10693 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10694 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10695  
10696   fi
10697 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
10698 < echo "${ECHO_T}$ac_m_powerpc" >&6
10699 < if test "$ac_m_powerpc" = yes; then
10700 <        :
8634 <        CPU_FLAGS=-mpowerpc
8635 < else
8636 <        :
10697 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10698 >  cat >>confdefs.h <<_ACEOF
10699 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10700 > _ACEOF
10701  
10702   fi
10703  
10704 <                fi
8641 <          esac
8642 <  fi
10704 > done
10705  
8644  if test -n "$CPU_FLAGS"; then
8645        CFLAGS="$CFLAGS $CPU_FLAGS"
8646  fi
10706  
10707 <  if test -z "$CFLAGS"; then
8649 <        echo ""
8650 <        echo "********************************************************"
8651 <        echo "* WARNING: Don't know the best CFLAGS for this system  *"
8652 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
8653 <        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
8654 <        echo "********************************************************"
8655 <        echo ""
8656 <        CFLAGS="-O3"
8657 <  fi
10707 > fi
10708  
10709  
10710  
10711 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
10712 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
10713 < if test "${ac_guessed_cflags+set}" = set; then
10711 >
10712 >  if test "${ac_cv_header_iomanip+set}" = set; then
10713 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10714 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10715 > if test "${ac_cv_header_iomanip+set}" = set; then
10716    echo $ECHO_N "(cached) $ECHO_C" >&6
8665 else
8666  echo 'void f(){}' > conftest.c
8667 if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
8668        ac_guessed_cflags=yes
8669 else
8670        ac_guessed_cflags=no
10717   fi
10718 < rm -f conftest*
10718 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10719 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10720 > else
10721 >  # Is the header compilable?
10722 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10723 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10724 > cat >conftest.$ac_ext <<_ACEOF
10725 > /* confdefs.h.  */
10726 > _ACEOF
10727 > cat confdefs.h >>conftest.$ac_ext
10728 > cat >>conftest.$ac_ext <<_ACEOF
10729 > /* end confdefs.h.  */
10730 > $ac_includes_default
10731 > #include <iomanip>
10732 > _ACEOF
10733 > rm -f conftest.$ac_objext
10734 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10735 >  (eval $ac_compile) 2>conftest.er1
10736 >  ac_status=$?
10737 >  grep -v '^ *+' conftest.er1 >conftest.err
10738 >  rm -f conftest.er1
10739 >  cat conftest.err >&5
10740 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10741 >  (exit $ac_status); } &&
10742 >         { ac_try='test -z "$ac_cxx_werror_flag"
10743 >                         || test ! -s conftest.err'
10744 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10745 >  (eval $ac_try) 2>&5
10746 >  ac_status=$?
10747 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10748 >  (exit $ac_status); }; } &&
10749 >         { ac_try='test -s conftest.$ac_objext'
10750 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10751 >  (eval $ac_try) 2>&5
10752 >  ac_status=$?
10753 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10754 >  (exit $ac_status); }; }; then
10755 >  ac_header_compiler=yes
10756 > else
10757 >  echo "$as_me: failed program was:" >&5
10758 > sed 's/^/| /' conftest.$ac_ext >&5
10759 >
10760 > ac_header_compiler=no
10761 > fi
10762 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10763 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10764 > echo "${ECHO_T}$ac_header_compiler" >&6
10765 >
10766 > # Is the header present?
10767 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10768 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10769 > cat >conftest.$ac_ext <<_ACEOF
10770 > /* confdefs.h.  */
10771 > _ACEOF
10772 > cat confdefs.h >>conftest.$ac_ext
10773 > cat >>conftest.$ac_ext <<_ACEOF
10774 > /* end confdefs.h.  */
10775 > #include <iomanip>
10776 > _ACEOF
10777 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10778 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10779 >  ac_status=$?
10780 >  grep -v '^ *+' conftest.er1 >conftest.err
10781 >  rm -f conftest.er1
10782 >  cat conftest.err >&5
10783 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10784 >  (exit $ac_status); } >/dev/null; then
10785 >  if test -s conftest.err; then
10786 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10787 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10788 >  else
10789 >    ac_cpp_err=
10790 >  fi
10791 > else
10792 >  ac_cpp_err=yes
10793 > fi
10794 > if test -z "$ac_cpp_err"; then
10795 >  ac_header_preproc=yes
10796 > else
10797 >  echo "$as_me: failed program was:" >&5
10798 > sed 's/^/| /' conftest.$ac_ext >&5
10799 >
10800 >  ac_header_preproc=no
10801 > fi
10802 > rm -f conftest.err conftest.$ac_ext
10803 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10804 > echo "${ECHO_T}$ac_header_preproc" >&6
10805 >
10806 > # So?  What about this header?
10807 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10808 >  yes:no: )
10809 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10810 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10811 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10812 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10813 >    ac_header_preproc=yes
10814 >    ;;
10815 >  no:yes:* )
10816 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10817 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10818 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10819 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10820 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10821 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10822 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10823 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10824 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10825 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10826 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10827 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10828 >    (
10829 >      cat <<\_ASBOX
10830 > ## ------------------------------ ##
10831 > ## Report this to gezelter@nd.edu ##
10832 > ## ------------------------------ ##
10833 > _ASBOX
10834 >    ) |
10835 >      sed "s/^/$as_me: WARNING:     /" >&2
10836 >    ;;
10837 > esac
10838 > echo "$as_me:$LINENO: checking for iomanip" >&5
10839 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10840 > if test "${ac_cv_header_iomanip+set}" = set; then
10841 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10842 > else
10843 >  ac_cv_header_iomanip=$ac_header_preproc
10844 > fi
10845 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10846 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10847 >
10848 > fi
10849 > if test $ac_cv_header_iomanip = yes; then
10850 >
10851 >
10852 > cat >>confdefs.h <<\_ACEOF
10853 > #define HAVE_IOMANIP 1
10854 > _ACEOF
10855 >
10856 >
10857 > else
10858 >
10859 >
10860 > for ac_header in iomanip.h
10861 > do
10862 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10863 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10864 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10865 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10866 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10867 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10868 > fi
10869 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10870 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10871 > else
10872 >  # Is the header compilable?
10873 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10874 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10875 > cat >conftest.$ac_ext <<_ACEOF
10876 > /* confdefs.h.  */
10877 > _ACEOF
10878 > cat confdefs.h >>conftest.$ac_ext
10879 > cat >>conftest.$ac_ext <<_ACEOF
10880 > /* end confdefs.h.  */
10881 > $ac_includes_default
10882 > #include <$ac_header>
10883 > _ACEOF
10884 > rm -f conftest.$ac_objext
10885 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10886 >  (eval $ac_compile) 2>conftest.er1
10887 >  ac_status=$?
10888 >  grep -v '^ *+' conftest.er1 >conftest.err
10889 >  rm -f conftest.er1
10890 >  cat conftest.err >&5
10891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10892 >  (exit $ac_status); } &&
10893 >         { ac_try='test -z "$ac_cxx_werror_flag"
10894 >                         || test ! -s conftest.err'
10895 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10896 >  (eval $ac_try) 2>&5
10897 >  ac_status=$?
10898 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10899 >  (exit $ac_status); }; } &&
10900 >         { ac_try='test -s conftest.$ac_objext'
10901 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10902 >  (eval $ac_try) 2>&5
10903 >  ac_status=$?
10904 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10905 >  (exit $ac_status); }; }; then
10906 >  ac_header_compiler=yes
10907 > else
10908 >  echo "$as_me: failed program was:" >&5
10909 > sed 's/^/| /' conftest.$ac_ext >&5
10910 >
10911 > ac_header_compiler=no
10912 > fi
10913 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10914 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10915 > echo "${ECHO_T}$ac_header_compiler" >&6
10916 >
10917 > # Is the header present?
10918 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10919 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10920 > cat >conftest.$ac_ext <<_ACEOF
10921 > /* confdefs.h.  */
10922 > _ACEOF
10923 > cat confdefs.h >>conftest.$ac_ext
10924 > cat >>conftest.$ac_ext <<_ACEOF
10925 > /* end confdefs.h.  */
10926 > #include <$ac_header>
10927 > _ACEOF
10928 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10929 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10930 >  ac_status=$?
10931 >  grep -v '^ *+' conftest.er1 >conftest.err
10932 >  rm -f conftest.er1
10933 >  cat conftest.err >&5
10934 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10935 >  (exit $ac_status); } >/dev/null; then
10936 >  if test -s conftest.err; then
10937 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10938 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10939 >  else
10940 >    ac_cpp_err=
10941 >  fi
10942 > else
10943 >  ac_cpp_err=yes
10944 > fi
10945 > if test -z "$ac_cpp_err"; then
10946 >  ac_header_preproc=yes
10947 > else
10948 >  echo "$as_me: failed program was:" >&5
10949 > sed 's/^/| /' conftest.$ac_ext >&5
10950 >
10951 >  ac_header_preproc=no
10952 > fi
10953 > rm -f conftest.err conftest.$ac_ext
10954 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10955 > echo "${ECHO_T}$ac_header_preproc" >&6
10956 >
10957 > # So?  What about this header?
10958 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10959 >  yes:no: )
10960 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10961 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10962 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10963 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10964 >    ac_header_preproc=yes
10965 >    ;;
10966 >  no:yes:* )
10967 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10968 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10969 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10970 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10971 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10972 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10973 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10974 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10975 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10976 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10977 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10978 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10979 >    (
10980 >      cat <<\_ASBOX
10981 > ## ------------------------------ ##
10982 > ## Report this to gezelter@nd.edu ##
10983 > ## ------------------------------ ##
10984 > _ASBOX
10985 >    ) |
10986 >      sed "s/^/$as_me: WARNING:     /" >&2
10987 >    ;;
10988 > esac
10989 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10990 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10991 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10992 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10993 > else
10994 >  eval "$as_ac_Header=\$ac_header_preproc"
10995 > fi
10996 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10997 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10998 >
10999 > fi
11000 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11001 >  cat >>confdefs.h <<_ACEOF
11002 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11003 > _ACEOF
11004 >
11005 > fi
11006 >
11007 > done
11008 >
11009 >
11010 > fi
11011 >
11012 >
11013 >
11014 >
11015 > for ac_header in cmath
11016 > do
11017 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11018 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11019 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11020 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11021 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11022 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11023 > fi
11024 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11025 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11026 > else
11027 >  # Is the header compilable?
11028 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11029 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11030 > cat >conftest.$ac_ext <<_ACEOF
11031 > /* confdefs.h.  */
11032 > _ACEOF
11033 > cat confdefs.h >>conftest.$ac_ext
11034 > cat >>conftest.$ac_ext <<_ACEOF
11035 > /* end confdefs.h.  */
11036 > $ac_includes_default
11037 > #include <$ac_header>
11038 > _ACEOF
11039 > rm -f conftest.$ac_objext
11040 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11041 >  (eval $ac_compile) 2>conftest.er1
11042 >  ac_status=$?
11043 >  grep -v '^ *+' conftest.er1 >conftest.err
11044 >  rm -f conftest.er1
11045 >  cat conftest.err >&5
11046 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11047 >  (exit $ac_status); } &&
11048 >         { ac_try='test -z "$ac_cxx_werror_flag"
11049 >                         || test ! -s conftest.err'
11050 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11051 >  (eval $ac_try) 2>&5
11052 >  ac_status=$?
11053 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11054 >  (exit $ac_status); }; } &&
11055 >         { ac_try='test -s conftest.$ac_objext'
11056 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11057 >  (eval $ac_try) 2>&5
11058 >  ac_status=$?
11059 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11060 >  (exit $ac_status); }; }; then
11061 >  ac_header_compiler=yes
11062 > else
11063 >  echo "$as_me: failed program was:" >&5
11064 > sed 's/^/| /' conftest.$ac_ext >&5
11065 >
11066 > ac_header_compiler=no
11067 > fi
11068 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11069 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11070 > echo "${ECHO_T}$ac_header_compiler" >&6
11071 >
11072 > # Is the header present?
11073 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11074 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11075 > cat >conftest.$ac_ext <<_ACEOF
11076 > /* confdefs.h.  */
11077 > _ACEOF
11078 > cat confdefs.h >>conftest.$ac_ext
11079 > cat >>conftest.$ac_ext <<_ACEOF
11080 > /* end confdefs.h.  */
11081 > #include <$ac_header>
11082 > _ACEOF
11083 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11084 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11085 >  ac_status=$?
11086 >  grep -v '^ *+' conftest.er1 >conftest.err
11087 >  rm -f conftest.er1
11088 >  cat conftest.err >&5
11089 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11090 >  (exit $ac_status); } >/dev/null; then
11091 >  if test -s conftest.err; then
11092 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11093 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11094 >  else
11095 >    ac_cpp_err=
11096 >  fi
11097 > else
11098 >  ac_cpp_err=yes
11099 > fi
11100 > if test -z "$ac_cpp_err"; then
11101 >  ac_header_preproc=yes
11102 > else
11103 >  echo "$as_me: failed program was:" >&5
11104 > sed 's/^/| /' conftest.$ac_ext >&5
11105 >
11106 >  ac_header_preproc=no
11107 > fi
11108 > rm -f conftest.err conftest.$ac_ext
11109 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11110 > echo "${ECHO_T}$ac_header_preproc" >&6
11111 >
11112 > # So?  What about this header?
11113 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11114 >  yes:no: )
11115 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11116 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11117 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11118 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11119 >    ac_header_preproc=yes
11120 >    ;;
11121 >  no:yes:* )
11122 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11123 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11124 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11125 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11126 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11127 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11128 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11129 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11130 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11131 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11132 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11133 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11134 >    (
11135 >      cat <<\_ASBOX
11136 > ## ------------------------------ ##
11137 > ## Report this to gezelter@nd.edu ##
11138 > ## ------------------------------ ##
11139 > _ASBOX
11140 >    ) |
11141 >      sed "s/^/$as_me: WARNING:     /" >&2
11142 >    ;;
11143 > esac
11144 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11145 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11146 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11147 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11148 > else
11149 >  eval "$as_ac_Header=\$ac_header_preproc"
11150 > fi
11151 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11152 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11153 >
11154 > fi
11155 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11156 >  cat >>confdefs.h <<_ACEOF
11157 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11158 > _ACEOF
11159 >
11160 > fi
11161 >
11162 > done
11163 >
11164 >
11165 >
11166 >
11167 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11168 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11169 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11170 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11171 > else
11172 >
11173 >      ac_cv_cxx_have_std_iostream=no
11174 >      ac_cv_cxx_need_use_std_iostream=no
11175 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11176 >
11177 >
11178 >        ac_ext=cc
11179 > ac_cpp='$CXXCPP $CPPFLAGS'
11180 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11181 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11182 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11183  
11184 +        cat >conftest.$ac_ext <<_ACEOF
11185 + /* confdefs.h.  */
11186 + _ACEOF
11187 + cat confdefs.h >>conftest.$ac_ext
11188 + cat >>conftest.$ac_ext <<_ACEOF
11189 + /* end confdefs.h.  */
11190 +
11191 + #ifdef HAVE_IOSTREAM
11192 + #include <iostream>
11193 + #else
11194 + #include <iostream.h>
11195 + #endif
11196 +
11197 + #ifdef FC_DUMMY_MAIN
11198 + #ifndef FC_DUMMY_MAIN_EQ_F77
11199 + #  ifdef __cplusplus
11200 +     extern "C"
11201 + #  endif
11202 +   int FC_DUMMY_MAIN() { return 1; }
11203 + #endif
11204 + #endif
11205 + int
11206 + main ()
11207 + {
11208 + std::cout<<"Hello World"<<std::endl;return 0;
11209 +  ;
11210 +  return 0;
11211 + }
11212 + _ACEOF
11213 + rm -f conftest.$ac_objext
11214 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11215 +  (eval $ac_compile) 2>conftest.er1
11216 +  ac_status=$?
11217 +  grep -v '^ *+' conftest.er1 >conftest.err
11218 +  rm -f conftest.er1
11219 +  cat conftest.err >&5
11220 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11221 +  (exit $ac_status); } &&
11222 +         { ac_try='test -z "$ac_cxx_werror_flag"
11223 +                         || test ! -s conftest.err'
11224 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11225 +  (eval $ac_try) 2>&5
11226 +  ac_status=$?
11227 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11228 +  (exit $ac_status); }; } &&
11229 +         { ac_try='test -s conftest.$ac_objext'
11230 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11231 +  (eval $ac_try) 2>&5
11232 +  ac_status=$?
11233 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11234 +  (exit $ac_status); }; }; then
11235 +  ac_cv_cxx_have_std_iostream=yes
11236 + else
11237 +  echo "$as_me: failed program was:" >&5
11238 + sed 's/^/| /' conftest.$ac_ext >&5
11239 +
11240   fi
11241 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11242 +        cat >conftest.$ac_ext <<_ACEOF
11243 + /* confdefs.h.  */
11244 + _ACEOF
11245 + cat confdefs.h >>conftest.$ac_ext
11246 + cat >>conftest.$ac_ext <<_ACEOF
11247 + /* end confdefs.h.  */
11248 +
11249 + #define __USE_STD_IOSTREAM 1
11250 + #ifdef HAVE_IOSTREAM
11251 + #include <iostream>
11252 + #else
11253 + #include <iostream.h>
11254 + #endif
11255 +
11256 + #ifdef FC_DUMMY_MAIN
11257 + #ifndef FC_DUMMY_MAIN_EQ_F77
11258 + #  ifdef __cplusplus
11259 +     extern "C"
11260 + #  endif
11261 +   int FC_DUMMY_MAIN() { return 1; }
11262 + #endif
11263 + #endif
11264 + int
11265 + main ()
11266 + {
11267 + std::cout<<"Hello World"<<std::endl;return 0;
11268 +  ;
11269 +  return 0;
11270 + }
11271 + _ACEOF
11272 + rm -f conftest.$ac_objext
11273 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11274 +  (eval $ac_compile) 2>conftest.er1
11275 +  ac_status=$?
11276 +  grep -v '^ *+' conftest.er1 >conftest.err
11277 +  rm -f conftest.er1
11278 +  cat conftest.err >&5
11279 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11280 +  (exit $ac_status); } &&
11281 +         { ac_try='test -z "$ac_cxx_werror_flag"
11282 +                         || test ! -s conftest.err'
11283 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11284 +  (eval $ac_try) 2>&5
11285 +  ac_status=$?
11286 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11287 +  (exit $ac_status); }; } &&
11288 +         { ac_try='test -s conftest.$ac_objext'
11289 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11290 +  (eval $ac_try) 2>&5
11291 +  ac_status=$?
11292 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11293 +  (exit $ac_status); }; }; then
11294 +  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11295 + else
11296 +  echo "$as_me: failed program was:" >&5
11297 + sed 's/^/| /' conftest.$ac_ext >&5
11298 +
11299 + fi
11300 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11301 +        ac_ext=cc
11302 + ac_cpp='$CXXCPP $CPPFLAGS'
11303 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11304 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11305 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11306 +
11307 +      fi
11308 +
11309 + fi
11310 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11311 + echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11312 +  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11313 +
11314 + cat >>confdefs.h <<\_ACEOF
11315 + #define HAVE_STD_IOSTREAM 1
11316 + _ACEOF
11317 +
11318 +  fi
11319 +  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11320 +
11321 + cat >>confdefs.h <<\_ACEOF
11322 + #define __USE_STD_IOSTREAM 1
11323 + _ACEOF
11324 +
11325 +  fi
11326 +
11327 +
11328 +
11329 +
11330 +  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11331 + echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11332 + if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11333 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11334 + else
11335 +
11336 +      ac_cv_cxx_have_std_stl=no
11337 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11338 +
11339 +
11340 +        ac_ext=cc
11341 + ac_cpp='$CXXCPP $CPPFLAGS'
11342 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11343 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11344 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11345 +
11346 +        cat >conftest.$ac_ext <<_ACEOF
11347 + /* confdefs.h.  */
11348 + _ACEOF
11349 + cat confdefs.h >>conftest.$ac_ext
11350 + cat >>conftest.$ac_ext <<_ACEOF
11351 + /* end confdefs.h.  */
11352 + #include <list>
11353 +
11354 + #ifdef FC_DUMMY_MAIN
11355 + #ifndef FC_DUMMY_MAIN_EQ_F77
11356 + #  ifdef __cplusplus
11357 +     extern "C"
11358 + #  endif
11359 +   int FC_DUMMY_MAIN() { return 1; }
11360 + #endif
11361 + #endif
11362 + int
11363 + main ()
11364 + {
11365 + std::list<int> foo;return 0;
11366 +  ;
11367 +  return 0;
11368 + }
11369 + _ACEOF
11370 + rm -f conftest.$ac_objext
11371 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11372 +  (eval $ac_compile) 2>conftest.er1
11373 +  ac_status=$?
11374 +  grep -v '^ *+' conftest.er1 >conftest.err
11375 +  rm -f conftest.er1
11376 +  cat conftest.err >&5
11377 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11378 +  (exit $ac_status); } &&
11379 +         { ac_try='test -z "$ac_cxx_werror_flag"
11380 +                         || test ! -s conftest.err'
11381 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11382 +  (eval $ac_try) 2>&5
11383 +  ac_status=$?
11384 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11385 +  (exit $ac_status); }; } &&
11386 +         { ac_try='test -s conftest.$ac_objext'
11387 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11388 +  (eval $ac_try) 2>&5
11389 +  ac_status=$?
11390 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11391 +  (exit $ac_status); }; }; then
11392 +  ac_cv_cxx_have_std_stl=yes
11393 + else
11394 +  echo "$as_me: failed program was:" >&5
11395 + sed 's/^/| /' conftest.$ac_ext >&5
11396 +
11397 + fi
11398 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11399 +        ac_ext=cc
11400 + ac_cpp='$CXXCPP $CPPFLAGS'
11401 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11402 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11403 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11404 +
11405 +      fi
11406 +
11407 + fi
11408 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11409 + echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11410 +  if test "$ac_cv_cxx_have_std_stl" = yes; then
11411 +
11412 + cat >>confdefs.h <<\_ACEOF
11413 + #define HAVE_STD_STL 1
11414 + _ACEOF
11415 +
11416 +  fi
11417 +
11418 +
11419 +
11420 +  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11421 + echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11422 + if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11423 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11424 + else
11425 +
11426 +    ac_cv_cxx_have_fstream_attach=no
11427 +
11428 +
11429 +    ac_ext=cc
11430 + ac_cpp='$CXXCPP $CPPFLAGS'
11431 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11432 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11433 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11434 +
11435 +    cat >conftest.$ac_ext <<_ACEOF
11436 + /* confdefs.h.  */
11437 + _ACEOF
11438 + cat confdefs.h >>conftest.$ac_ext
11439 + cat >>conftest.$ac_ext <<_ACEOF
11440 + /* end confdefs.h.  */
11441 +
11442 + #ifdef HAVE_IOSTREAM
11443 + #include <fstream>
11444 + #else
11445 + #include <fstream.h>
11446 + #endif
11447 + #ifdef HAVE_STD_IOSTREAM
11448 + using namespace std;
11449 + #endif
11450 +
11451 + #ifdef FC_DUMMY_MAIN
11452 + #ifndef FC_DUMMY_MAIN_EQ_F77
11453 + #  ifdef __cplusplus
11454 +     extern "C"
11455 + #  endif
11456 +   int FC_DUMMY_MAIN() { return 1; }
11457 + #endif
11458 + #endif
11459 + int
11460 + main ()
11461 + {
11462 + int fd=0;ofstream s;s.attach(fd);
11463 +  ;
11464 +  return 0;
11465 + }
11466 + _ACEOF
11467 + rm -f conftest.$ac_objext
11468 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11469 +  (eval $ac_compile) 2>conftest.er1
11470 +  ac_status=$?
11471 +  grep -v '^ *+' conftest.er1 >conftest.err
11472 +  rm -f conftest.er1
11473 +  cat conftest.err >&5
11474 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11475 +  (exit $ac_status); } &&
11476 +         { ac_try='test -z "$ac_cxx_werror_flag"
11477 +                         || test ! -s conftest.err'
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); }; } &&
11483 +         { ac_try='test -s conftest.$ac_objext'
11484 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11485 +  (eval $ac_try) 2>&5
11486 +  ac_status=$?
11487 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11488 +  (exit $ac_status); }; }; then
11489 +  ac_cv_cxx_have_fstream_attach=yes
11490 + else
11491 +  echo "$as_me: failed program was:" >&5
11492 + sed 's/^/| /' conftest.$ac_ext >&5
11493 +
11494 + fi
11495 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11496 +    ac_ext=cc
11497 + ac_cpp='$CXXCPP $CPPFLAGS'
11498 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11499 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11500 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11501 +
11502 +
11503 + fi
11504 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11505 + echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11506 +  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11507 +
11508 + cat >>confdefs.h <<\_ACEOF
11509 + #define HAVE_FSTREAM_ATTACH 1
11510 + _ACEOF
11511 +
11512 +  fi
11513 +
11514 +
11515 +
11516 +  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11517 + echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11518 + if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11519 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11520 + else
11521 +
11522 +    ac_cv_cxx_have_fstream_open=no
11523 +    ac_cv_cxx_fstream_open_prot=no
11524 +
11525 +
11526 +    ac_ext=cc
11527 + ac_cpp='$CXXCPP $CPPFLAGS'
11528 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11529 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11530 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11531 +
11532 +    # Try with 2 parameters
11533 +    cat >conftest.$ac_ext <<_ACEOF
11534 + /* confdefs.h.  */
11535 + _ACEOF
11536 + cat confdefs.h >>conftest.$ac_ext
11537 + cat >>conftest.$ac_ext <<_ACEOF
11538 + /* end confdefs.h.  */
11539 +
11540 + #ifdef HAVE_IOSTREAM
11541 + #include <fstream>
11542 + #else
11543 + #include <fstream.h>
11544 + #endif
11545 + #ifdef HAVE_STD_IOSTREAM
11546 + using namespace std;
11547 + #endif
11548 +
11549 + #ifdef FC_DUMMY_MAIN
11550 + #ifndef FC_DUMMY_MAIN_EQ_F77
11551 + #  ifdef __cplusplus
11552 +     extern "C"
11553 + #  endif
11554 +   int FC_DUMMY_MAIN() { return 1; }
11555 + #endif
11556 + #endif
11557 + int
11558 + main ()
11559 + {
11560 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11561 +  ;
11562 +  return 0;
11563 + }
11564 + _ACEOF
11565 + rm -f conftest.$ac_objext
11566 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11567 +  (eval $ac_compile) 2>conftest.er1
11568 +  ac_status=$?
11569 +  grep -v '^ *+' conftest.er1 >conftest.err
11570 +  rm -f conftest.er1
11571 +  cat conftest.err >&5
11572 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11573 +  (exit $ac_status); } &&
11574 +         { ac_try='test -z "$ac_cxx_werror_flag"
11575 +                         || test ! -s conftest.err'
11576 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11577 +  (eval $ac_try) 2>&5
11578 +  ac_status=$?
11579 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11580 +  (exit $ac_status); }; } &&
11581 +         { ac_try='test -s conftest.$ac_objext'
11582 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11583 +  (eval $ac_try) 2>&5
11584 +  ac_status=$?
11585 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11586 +  (exit $ac_status); }; }; then
11587 +  ac_cv_cxx_have_fstream_open=yes
11588 + else
11589 +  echo "$as_me: failed program was:" >&5
11590 + sed 's/^/| /' conftest.$ac_ext >&5
11591 +
11592 + fi
11593 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11594 +    # Try with mode parameter
11595 +    cat >conftest.$ac_ext <<_ACEOF
11596 + /* confdefs.h.  */
11597 + _ACEOF
11598 + cat confdefs.h >>conftest.$ac_ext
11599 + cat >>conftest.$ac_ext <<_ACEOF
11600 + /* end confdefs.h.  */
11601 +
11602 + #ifdef HAVE_IOSTREAM
11603 + #include <fstream>
11604 + #else
11605 + #include <fstream.h>
11606 + #endif
11607 + #ifdef HAVE_STD_IOSTREAM
11608 + using namespace std;
11609 + #endif
11610 +
11611 + #ifdef FC_DUMMY_MAIN
11612 + #ifndef FC_DUMMY_MAIN_EQ_F77
11613 + #  ifdef __cplusplus
11614 +     extern "C"
11615 + #  endif
11616 +   int FC_DUMMY_MAIN() { return 1; }
11617 + #endif
11618 + #endif
11619 + int
11620 + main ()
11621 + {
11622 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11623 +  ;
11624 +  return 0;
11625 + }
11626 + _ACEOF
11627 + rm -f conftest.$ac_objext
11628 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11629 +  (eval $ac_compile) 2>conftest.er1
11630 +  ac_status=$?
11631 +  grep -v '^ *+' conftest.er1 >conftest.err
11632 +  rm -f conftest.er1
11633 +  cat conftest.err >&5
11634 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11635 +  (exit $ac_status); } &&
11636 +         { ac_try='test -z "$ac_cxx_werror_flag"
11637 +                         || test ! -s conftest.err'
11638 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11639 +  (eval $ac_try) 2>&5
11640 +  ac_status=$?
11641 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11642 +  (exit $ac_status); }; } &&
11643 +         { ac_try='test -s conftest.$ac_objext'
11644 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11645 +  (eval $ac_try) 2>&5
11646 +  ac_status=$?
11647 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648 +  (exit $ac_status); }; }; then
11649 +  ac_cv_cxx_fstream_open_prot=yes
11650 + else
11651 +  echo "$as_me: failed program was:" >&5
11652 + sed 's/^/| /' conftest.$ac_ext >&5
11653 +
11654 + fi
11655 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11656 +    ac_ext=cc
11657 + ac_cpp='$CXXCPP $CPPFLAGS'
11658 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11659 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11660 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11661 +
11662 +
11663 + fi
11664 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11665 + echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11666 +  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11667 +
11668 + cat >>confdefs.h <<\_ACEOF
11669 + #define HAVE_FSTREAM_OPEN 1
11670 + _ACEOF
11671 +
11672 +  fi
11673 +  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11674 +
11675 + cat >>confdefs.h <<\_ACEOF
11676 + #define FSTREAM_OPEN_PROT 1
11677 + _ACEOF
11678 +
11679 +  fi
11680 +
11681 +
11682 +
11683 +
11684 +
11685 +
11686 +
11687 + for ac_header in ctype.h iostream fstream sstream strstream
11688 + do
11689 + as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11690 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
11691 +  echo "$as_me:$LINENO: checking for $ac_header" >&5
11692 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11693 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
11694 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11695 + fi
11696 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11697 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11698 + else
11699 +  # Is the header compilable?
11700 + echo "$as_me:$LINENO: checking $ac_header usability" >&5
11701 + echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11702 + cat >conftest.$ac_ext <<_ACEOF
11703 + /* confdefs.h.  */
11704 + _ACEOF
11705 + cat confdefs.h >>conftest.$ac_ext
11706 + cat >>conftest.$ac_ext <<_ACEOF
11707 + /* end confdefs.h.  */
11708 + $ac_includes_default
11709 + #include <$ac_header>
11710 + _ACEOF
11711 + rm -f conftest.$ac_objext
11712 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11713 +  (eval $ac_compile) 2>conftest.er1
11714 +  ac_status=$?
11715 +  grep -v '^ *+' conftest.er1 >conftest.err
11716 +  rm -f conftest.er1
11717 +  cat conftest.err >&5
11718 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11719 +  (exit $ac_status); } &&
11720 +         { ac_try='test -z "$ac_cxx_werror_flag"
11721 +                         || test ! -s conftest.err'
11722 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11723 +  (eval $ac_try) 2>&5
11724 +  ac_status=$?
11725 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11726 +  (exit $ac_status); }; } &&
11727 +         { ac_try='test -s conftest.$ac_objext'
11728 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11729 +  (eval $ac_try) 2>&5
11730 +  ac_status=$?
11731 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11732 +  (exit $ac_status); }; }; then
11733 +  ac_header_compiler=yes
11734 + else
11735 +  echo "$as_me: failed program was:" >&5
11736 + sed 's/^/| /' conftest.$ac_ext >&5
11737 +
11738 + ac_header_compiler=no
11739 + fi
11740 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11741 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11742 + echo "${ECHO_T}$ac_header_compiler" >&6
11743 +
11744 + # Is the header present?
11745 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
11746 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11747 + cat >conftest.$ac_ext <<_ACEOF
11748 + /* confdefs.h.  */
11749 + _ACEOF
11750 + cat confdefs.h >>conftest.$ac_ext
11751 + cat >>conftest.$ac_ext <<_ACEOF
11752 + /* end confdefs.h.  */
11753 + #include <$ac_header>
11754 + _ACEOF
11755 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11756 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11757 +  ac_status=$?
11758 +  grep -v '^ *+' conftest.er1 >conftest.err
11759 +  rm -f conftest.er1
11760 +  cat conftest.err >&5
11761 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11762 +  (exit $ac_status); } >/dev/null; then
11763 +  if test -s conftest.err; then
11764 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
11765 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11766 +  else
11767 +    ac_cpp_err=
11768 +  fi
11769 + else
11770 +  ac_cpp_err=yes
11771 + fi
11772 + if test -z "$ac_cpp_err"; then
11773 +  ac_header_preproc=yes
11774 + else
11775 +  echo "$as_me: failed program was:" >&5
11776 + sed 's/^/| /' conftest.$ac_ext >&5
11777 +
11778 +  ac_header_preproc=no
11779 + fi
11780 + rm -f conftest.err conftest.$ac_ext
11781 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11782 + echo "${ECHO_T}$ac_header_preproc" >&6
11783 +
11784 + # So?  What about this header?
11785 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11786 +  yes:no: )
11787 +    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11788 + echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11789 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11790 + echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11791 +    ac_header_preproc=yes
11792 +    ;;
11793 +  no:yes:* )
11794 +    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11795 + echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11796 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11797 + echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11798 +    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11799 + echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11800 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11801 + echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11802 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11803 + echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11804 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11805 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11806 +    (
11807 +      cat <<\_ASBOX
11808 + ## ------------------------------ ##
11809 + ## Report this to gezelter@nd.edu ##
11810 + ## ------------------------------ ##
11811 + _ASBOX
11812 +    ) |
11813 +      sed "s/^/$as_me: WARNING:     /" >&2
11814 +    ;;
11815 + esac
11816 + echo "$as_me:$LINENO: checking for $ac_header" >&5
11817 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11818 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
11819 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11820 + else
11821 +  eval "$as_ac_Header=\$ac_header_preproc"
11822 + fi
11823 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11824 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11825 +
11826 + fi
11827 + if test `eval echo '${'$as_ac_Header'}'` = yes; then
11828 +  cat >>confdefs.h <<_ACEOF
11829 + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11830 + _ACEOF
11831 +
11832 + fi
11833 +
11834 + done
11835 +
11836 + # AC_CPP_FUNC
11837 + # ------------------ #
11838 + # Checks to see if ANSI C99 CPP variable __func__ works.
11839 + # If not, perhaps __FUNCTION__ works instead.
11840 + # If not, we'll just define __func__ to "".
11841 + # AC_CPP_FUNC
11842 +
11843 +
11844 + echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11845 + echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11846 + if test "${ac_cv_cpp_func+set}" = set; then
11847 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11848 + else
11849 +  cat >conftest.$ac_ext <<_ACEOF
11850 + /* confdefs.h.  */
11851 + _ACEOF
11852 + cat confdefs.h >>conftest.$ac_ext
11853 + cat >>conftest.$ac_ext <<_ACEOF
11854 + /* end confdefs.h.  */
11855 +
11856 + #ifdef FC_DUMMY_MAIN
11857 + #ifndef FC_DUMMY_MAIN_EQ_F77
11858 + #  ifdef __cplusplus
11859 +     extern "C"
11860 + #  endif
11861 +   int FC_DUMMY_MAIN() { return 1; }
11862 + #endif
11863 + #endif
11864 + int
11865 + main ()
11866 + {
11867 + const char *foo = __func__;
11868 +  ;
11869 +  return 0;
11870 + }
11871 + _ACEOF
11872 + rm -f conftest.$ac_objext
11873 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11874 +  (eval $ac_compile) 2>conftest.er1
11875 +  ac_status=$?
11876 +  grep -v '^ *+' conftest.er1 >conftest.err
11877 +  rm -f conftest.er1
11878 +  cat conftest.err >&5
11879 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11880 +  (exit $ac_status); } &&
11881 +         { ac_try='test -z "$ac_cxx_werror_flag"
11882 +                         || test ! -s conftest.err'
11883 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11884 +  (eval $ac_try) 2>&5
11885 +  ac_status=$?
11886 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11887 +  (exit $ac_status); }; } &&
11888 +         { ac_try='test -s conftest.$ac_objext'
11889 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11890 +  (eval $ac_try) 2>&5
11891 +  ac_status=$?
11892 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11893 +  (exit $ac_status); }; }; then
11894 +  ac_cv_cpp_func=yes
11895 + else
11896 +  echo "$as_me: failed program was:" >&5
11897 + sed 's/^/| /' conftest.$ac_ext >&5
11898 +
11899 + cat >conftest.$ac_ext <<_ACEOF
11900 + /* confdefs.h.  */
11901 + _ACEOF
11902 + cat confdefs.h >>conftest.$ac_ext
11903 + cat >>conftest.$ac_ext <<_ACEOF
11904 + /* end confdefs.h.  */
11905 +
11906 + #ifdef FC_DUMMY_MAIN
11907 + #ifndef FC_DUMMY_MAIN_EQ_F77
11908 + #  ifdef __cplusplus
11909 +     extern "C"
11910 + #  endif
11911 +   int FC_DUMMY_MAIN() { return 1; }
11912 + #endif
11913 + #endif
11914 + int
11915 + main ()
11916 + {
11917 + const char *foo = __FUNCTION__;
11918 +  ;
11919 +  return 0;
11920 + }
11921 + _ACEOF
11922 + rm -f conftest.$ac_objext
11923 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11924 +  (eval $ac_compile) 2>conftest.er1
11925 +  ac_status=$?
11926 +  grep -v '^ *+' conftest.er1 >conftest.err
11927 +  rm -f conftest.er1
11928 +  cat conftest.err >&5
11929 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11930 +  (exit $ac_status); } &&
11931 +         { ac_try='test -z "$ac_cxx_werror_flag"
11932 +                         || test ! -s conftest.err'
11933 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11934 +  (eval $ac_try) 2>&5
11935 +  ac_status=$?
11936 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11937 +  (exit $ac_status); }; } &&
11938 +         { ac_try='test -s conftest.$ac_objext'
11939 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11940 +  (eval $ac_try) 2>&5
11941 +  ac_status=$?
11942 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11943 +  (exit $ac_status); }; }; then
11944 +  ac_cv_cpp_func=__FUNCTION__
11945 + else
11946 +  echo "$as_me: failed program was:" >&5
11947 + sed 's/^/| /' conftest.$ac_ext >&5
11948 +
11949 + ac_cv_cpp_func=no
11950 + fi
11951 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11952 + fi
11953 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11954 + fi
11955 + echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11956 + echo "${ECHO_T}$ac_cv_cpp_func" >&6
11957 + if test $ac_cv_cpp_func = __FUNCTION__; then
11958 +
11959 + cat >>confdefs.h <<\_ACEOF
11960 + #define __func__ __FUNCTION__
11961 + _ACEOF
11962 +
11963 + elif test $ac_cv_cpp_func = no; then
11964 +
11965 + cat >>confdefs.h <<\_ACEOF
11966 + #define __func__ ""
11967 + _ACEOF
11968 +
11969 + fi
11970 +
11971 +
11972 +
11973 +
11974 +
11975 + case $debug in
11976 +  1)
11977 +     ;;
11978 +  *)
11979 +
11980 +
11981 +
11982 +
11983 + # Try to determine "good" native compiler flags if none specified on command
11984 + # line
11985 +
11986 + if test "$ac_test_FFLAGS" != "set"; then
11987 +  FCFLAGS=""
11988 +  case "${host_cpu}-${host_os}" in
11989 +
11990 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11991 +                    FCFLAGS="-O3 -ip -no-prec-div"
11992 +                fi;;
11993 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11994 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11995 +                fi;;
11996 +   powerpc*-aix*)
11997 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11998 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11999 +                echo "*******************************************************"
12000 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12001 +                echo "*  recommended that you use                           *"
12002 +                echo "*                                                     *"
12003 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12004 +                echo "*                                 ^^^                 *"
12005 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12006 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12007 +                echo "*******************************************************"
12008 +        fi;;
12009 +   *darwin*)
12010 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12011 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12012 +        fi
12013 +        if test "$FC" = ifort; then
12014 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12015 +        fi;;
12016 +  esac
12017 +
12018 +  if test -n "$CPU_FLAGS"; then
12019 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12020 +  fi
12021 +
12022 +  if test -z "$FCFLAGS"; then
12023 +        echo ""
12024 +        echo "*********************************************************"
12025 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12026 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12027 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12028 +        echo "*********************************************************"
12029 +        echo ""
12030 +        FCFLAGS="-O3"
12031 +  fi
12032 +
12033 +
12034 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12035 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12036 + if test "${ac_guessed_f90flags+set}" = set; then
12037 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12038 + else
12039 +
12040 +
12041 +
12042 + ac_ext=${FC_SRCEXT-f}
12043 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12044 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12045 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12046 +
12047 + echo 'program main' > conftest.$ac_ext
12048 + echo 'end program main' >> conftest.$ac_ext
12049 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12050 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12051 +  (eval $ac_compile) 2>&5
12052 +  ac_status=$?
12053 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12054 +  (exit $ac_status); }; then
12055 +        ac_guessed_f90flags=yes
12056 + else
12057 +        ac_guessed_f90flags=no
12058 + fi
12059 + rm -f conftest*
12060 + ac_ext=cc
12061 + ac_cpp='$CXXCPP $CPPFLAGS'
12062 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12063 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12064 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12065 +
12066 +
12067 + fi
12068 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12069 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12070 + if test "$ac_guessed_f90flags" = yes; then
12071 +        :
12072 +
12073 + else
12074 +        :
12075 +
12076 +        echo ""
12077 +        echo "**********************************************************"
12078 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12079 +        echo "* your compiler.                                        *"
12080 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12081 +        echo "*********************************************************"
12082 +        echo ""
12083 +        FCFLAGS=""
12084 +
12085 + fi
12086 +
12087 +
12088 + fi
12089 +
12090 +
12091 +
12092 +
12093 +
12094 +
12095 +
12096 + echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12097 + echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12098 + if test "${ac_cv_prog_really_gcc+set}" = set; then
12099 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12100 + else
12101 +
12102 + cat > conftest.c <<EOF
12103 + #ifdef __GNUC__
12104 +  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12105 +     no;
12106 +  #else
12107 +     yes;
12108 +  #endif
12109 + #endif
12110 + EOF
12111 + if { ac_try='${CC-cc} -E conftest.c'
12112 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12113 +  (eval $ac_try) 2>&5
12114 +  ac_status=$?
12115 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12116 +  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12117 +  ac_cv_prog_really_gcc=yes
12118 + else
12119 +  ac_cv_prog_really_gcc=no
12120 + fi
12121 +
12122 + fi
12123 + echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
12124 + echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6
12125 + if test "$ac_cv_prog_really_gcc" = yes; then
12126 +        :
12127 +
12128 + else
12129 +        :
12130 +
12131 + fi
12132 +
12133 +
12134 + # Try to determine "good" native compiler flags if none specified on command
12135 + # line
12136 + if test "$ac_test_CFLAGS" != "set"; then
12137 +  CFLAGS=""
12138 +  case "${host_cpu}-${host_os}" in
12139 +
12140 +  *linux*) if test "$CC" = icc; then
12141 +                    CFLAGS="-O"
12142 +                fi;;
12143 +  sparc-solaris2*) if test "$CC" = cc; then
12144 +                    CFLAGS="-O -dalign"
12145 +                 fi;;
12146 +
12147 +  alpha*-osf*)  if test "$CC" = cc; then
12148 +                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
12149 +                fi;;
12150 +
12151 +  hppa*-hpux*)  if test "$CC" = cc; then
12152 +                    CFLAGS="-Ae +O3 +Oall"
12153 +                fi;;
12154 +
12155 +   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
12156 +                    CFLAGS="-O3 -qtune=auto -qansialias -w"
12157 +                fi;;
12158 +   powerpc*-aix*)
12159 +        if test "$CC" = cc -o "$CC" = xlc; then
12160 +                CFLAGS="-O3 -qtune=auto -qansialias -w"
12161 +                echo "*******************************************************"
12162 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12163 +                echo "*  recommended that you use                           *"
12164 +                echo "*                                                     *"
12165 +                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12166 +                echo "*                                 ^^^                 *"
12167 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12168 +                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12169 +                echo "*******************************************************"
12170 +        fi;;
12171 +   *darwin*)
12172 +        if test "$CC" = xlc -o "$CC" = cc; then
12173 +                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12174 +        fi
12175 +        if test "$CC" = icc; then
12176 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12177 +        fi;;
12178 +  esac
12179 +
12180 +  # use default flags for gcc on all systems
12181 +  if test $ac_cv_prog_really_gcc = yes; then
12182 +     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12183 +  fi
12184 +
12185 +  # test for gcc-specific flags:
12186 +  if test $ac_cv_prog_really_gcc = yes; then
12187 +    # -malign-double for x86 systems
12188 +
12189 +
12190 + echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12191 + echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12192 + if test "${ac_align_double+set}" = set; then
12193 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12194 + else
12195 +  echo 'void f(){}' > conftest.c
12196 + if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12197 +        ac_align_double=yes
12198 + else
12199 +        ac_align_double=no
12200 + fi
12201 + rm -f conftest*
12202 +
12203 + fi
12204 + echo "$as_me:$LINENO: result: $ac_align_double" >&5
12205 + echo "${ECHO_T}$ac_align_double" >&6
12206 + if test "$ac_align_double" = yes; then
12207 +        :
12208 +        CFLAGS="$CFLAGS -malign-double"
12209 + else
12210 +        :
12211 +
12212 + fi
12213 +
12214 +    # -fstrict-aliasing for gcc-2.95+
12215 +
12216 +
12217 + echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12218 + echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12219 + if test "${ac_fstrict_aliasing+set}" = set; then
12220 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12221 + else
12222 +  echo 'void f(){}' > conftest.c
12223 + if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12224 +        ac_fstrict_aliasing=yes
12225 + else
12226 +        ac_fstrict_aliasing=no
12227 + fi
12228 + rm -f conftest*
12229 +
12230 + fi
12231 + echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
12232 + echo "${ECHO_T}$ac_fstrict_aliasing" >&6
12233 + if test "$ac_fstrict_aliasing" = yes; then
12234 +        :
12235 +        CFLAGS="$CFLAGS -fstrict-aliasing"
12236 + else
12237 +        :
12238 +
12239 + fi
12240 +
12241 +  fi
12242 +
12243 +  CPU_FLAGS=""
12244 +  if test $ac_cv_prog_really_gcc = yes; then
12245 +                  case "${host_cpu}" in
12246 +          i586*)
12247 +
12248 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12249 + echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12250 + if test "${ac_cpu_pentium+set}" = set; then
12251 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12252 + else
12253 +  echo 'void f(){}' > conftest.c
12254 + if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12255 +        ac_cpu_pentium=yes
12256 + else
12257 +        ac_cpu_pentium=no
12258 + fi
12259 + rm -f conftest*
12260 +
12261 + fi
12262 + echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
12263 + echo "${ECHO_T}$ac_cpu_pentium" >&6
12264 + if test "$ac_cpu_pentium" = yes; then
12265 +        :
12266 +        CPU_FLAGS=-mcpu=pentium
12267 + else
12268 +        :
12269 +
12270 +
12271 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12272 + echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12273 + if test "${ac_pentium+set}" = set; then
12274 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12275 + else
12276 +  echo 'void f(){}' > conftest.c
12277 + if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12278 +        ac_pentium=yes
12279 + else
12280 +        ac_pentium=no
12281 + fi
12282 + rm -f conftest*
12283 +
12284 + fi
12285 + echo "$as_me:$LINENO: result: $ac_pentium" >&5
12286 + echo "${ECHO_T}$ac_pentium" >&6
12287 + if test "$ac_pentium" = yes; then
12288 +        :
12289 +        CPU_FLAGS=-mpentium
12290 + else
12291 +        :
12292 +
12293 + fi
12294 +
12295 + fi
12296 +
12297 +                  ;;
12298 +          i686*)
12299 +
12300 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12301 + echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12302 + if test "${ac_cpu_pentiumpro+set}" = set; then
12303 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12304 + else
12305 +  echo 'void f(){}' > conftest.c
12306 + if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12307 +        ac_cpu_pentiumpro=yes
12308 + else
12309 +        ac_cpu_pentiumpro=no
12310 + fi
12311 + rm -f conftest*
12312 +
12313 + fi
12314 + echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
12315 + echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
12316 + if test "$ac_cpu_pentiumpro" = yes; then
12317 +        :
12318 +        CPU_FLAGS=-mcpu=pentiumpro
12319 + else
12320 +        :
12321 +
12322 +
12323 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12324 + echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12325 + if test "${ac_pentiumpro+set}" = set; then
12326 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12327 + else
12328 +  echo 'void f(){}' > conftest.c
12329 + if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12330 +        ac_pentiumpro=yes
12331 + else
12332 +        ac_pentiumpro=no
12333 + fi
12334 + rm -f conftest*
12335 +
12336 + fi
12337 + echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
12338 + echo "${ECHO_T}$ac_pentiumpro" >&6
12339 + if test "$ac_pentiumpro" = yes; then
12340 +        :
12341 +        CPU_FLAGS=-mpentiumpro
12342 + else
12343 +        :
12344 +
12345 + fi
12346 +
12347 + fi
12348 +
12349 +                  ;;
12350 +          powerpc*)
12351 +                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
12352 +                is60x=`echo $cputype | egrep "^600-9e?$"`
12353 +                if test -n "$is60x"; then
12354 +
12355 +
12356 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12357 + echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12358 + if test "${ac_m_cpu_60x+set}" = set; then
12359 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12360 + else
12361 +  echo 'void f(){}' > conftest.c
12362 + if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12363 +        ac_m_cpu_60x=yes
12364 + else
12365 +        ac_m_cpu_60x=no
12366 + fi
12367 + rm -f conftest*
12368 +
12369 + fi
12370 + echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
12371 + echo "${ECHO_T}$ac_m_cpu_60x" >&6
12372 + if test "$ac_m_cpu_60x" = yes; then
12373 +        :
12374 +        CPU_FLAGS=-mcpu=$cputype
12375 + else
12376 +        :
12377 +
12378 + fi
12379 +
12380 +                elif test "$cputype" = 750; then
12381 +
12382 +
12383 + echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
12384 + echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6
12385 + if test "${ac_cv_prog_gcc_2_95+set}" = set; then
12386 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12387 + else
12388 +
12389 + cat > conftest.c <<EOF
12390 + #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12391 + #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12392 +     yes;
12393 + #  endif
12394 + #endif
12395 + EOF
12396 + if { ac_try='${CC-cc} -E conftest.c'
12397 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12398 +  (eval $ac_try) 2>&5
12399 +  ac_status=$?
12400 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12401 +  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12402 +  ac_cv_prog_gcc_2_95=yes
12403 + else
12404 +  ac_cv_prog_gcc_2_95=no
12405 + fi
12406 +
12407 + fi
12408 + echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
12409 + echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6
12410 + if test "$ac_cv_prog_gcc_2_95" = yes; then
12411 +        :
12412 +
12413 +
12414 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12415 + echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12416 + if test "${ac_m_cpu_750+set}" = set; then
12417 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12418 + else
12419 +  echo 'void f(){}' > conftest.c
12420 + if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12421 +        ac_m_cpu_750=yes
12422 + else
12423 +        ac_m_cpu_750=no
12424 + fi
12425 + rm -f conftest*
12426 +
12427 + fi
12428 + echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12429 + echo "${ECHO_T}$ac_m_cpu_750" >&6
12430 + if test "$ac_m_cpu_750" = yes; then
12431 +        :
12432 +        CPU_FLAGS=-mcpu=750
12433 + else
12434 +        :
12435 +
12436 + fi
12437 +
12438 + else
12439 +        :
12440 +
12441 + fi
12442 +
12443 +                fi
12444 +                if test -z "$CPU_FLAGS"; then
12445 +
12446 +
12447 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12448 + echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12449 + if test "${ac_m_cpu_powerpc+set}" = set; then
12450 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12451 + else
12452 +  echo 'void f(){}' > conftest.c
12453 + if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12454 +        ac_m_cpu_powerpc=yes
12455 + else
12456 +        ac_m_cpu_powerpc=no
12457 + fi
12458 + rm -f conftest*
12459 +
12460 + fi
12461 + echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12462 + echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12463 + if test "$ac_m_cpu_powerpc" = yes; then
12464 +        :
12465 +        CPU_FLAGS=-mcpu=powerpc
12466 + else
12467 +        :
12468 +
12469 + fi
12470 +
12471 +                fi
12472 +                if test -z "$CPU_FLAGS"; then
12473 +
12474 +
12475 + echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12476 + echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12477 + if test "${ac_m_powerpc+set}" = set; then
12478 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12479 + else
12480 +  echo 'void f(){}' > conftest.c
12481 + if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12482 +        ac_m_powerpc=yes
12483 + else
12484 +        ac_m_powerpc=no
12485 + fi
12486 + rm -f conftest*
12487 +
12488 + fi
12489 + echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12490 + echo "${ECHO_T}$ac_m_powerpc" >&6
12491 + if test "$ac_m_powerpc" = yes; then
12492 +        :
12493 +        CPU_FLAGS=-mpowerpc
12494 + else
12495 +        :
12496 +
12497 + fi
12498 +
12499 +                fi
12500 +          esac
12501 +  fi
12502 +
12503 +  if test -n "$CPU_FLAGS"; then
12504 +        CFLAGS="$CFLAGS $CPU_FLAGS"
12505 +  fi
12506 +
12507 +  if test -z "$CFLAGS"; then
12508 +        echo ""
12509 +        echo "********************************************************"
12510 +        echo "* WARNING: Don't know the best CFLAGS for this system  *"
12511 +        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
12512 +        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
12513 +        echo "********************************************************"
12514 +        echo ""
12515 +        CFLAGS="-O3"
12516 +  fi
12517 +
12518 +
12519 +
12520 + echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12521 + echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12522 + if test "${ac_guessed_cflags+set}" = set; then
12523 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12524 + else
12525 +  echo 'void f(){}' > conftest.c
12526 + if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12527 +        ac_guessed_cflags=yes
12528 + else
12529 +        ac_guessed_cflags=no
12530 + fi
12531 + rm -f conftest*
12532 +
12533 + fi
12534   echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
12535   echo "${ECHO_T}$ac_guessed_cflags" >&6
12536   if test "$ac_guessed_cflags" = yes; then
# Line 8748 | Line 12607 | if test "$ac_test_CXXFLAGS" != "set"; then
12607                      CXXFLAGS="-O"
12608                  fi;;
12609    sparc-solaris2*) if test "$CXX" = CC; then
12610 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12610 >                    CXXFLAGS="-features=extensions -O -dalign"
12611                   fi;;
12612     rs6000*-aix*)  if test "$CXX" = xlC; then
12613                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8769 | Line 12628 | if test "$ac_test_CXXFLAGS" != "set"; then
12628     *darwin*)
12629          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12630                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12631 +        fi
12632 +        if test "$CXX" = icpc; then
12633 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12634          fi;;
12635    esac
12636  
# Line 8782 | Line 12644 | if test "$ac_test_CXXFLAGS" != "set"; then
12644      # -malign-double for x86 systems
12645  
12646  
12647 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12648 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12647 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12648 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12649   if test "${ac_align_double+set}" = set; then
12650    echo $ECHO_N "(cached) $ECHO_C" >&6
12651   else
12652    echo 'void f(){}' > conftest.cpp
12653 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12653 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12654          ac_align_double=yes
12655   else
12656          ac_align_double=no
# Line 8809 | Line 12671 | fi
12671      # -fstrict-aliasing for gcc-2.95+
12672  
12673  
12674 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12675 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12674 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12675 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12676   if test "${ac_fstrict_aliasing+set}" = set; then
12677    echo $ECHO_N "(cached) $ECHO_C" >&6
12678   else
12679    echo 'void f(){}' > conftest.cpp
12680 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12680 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12681          ac_fstrict_aliasing=yes
12682   else
12683          ac_fstrict_aliasing=no
# Line 8840 | Line 12702 | fi
12702                    case "${host_cpu}" in
12703            i586*)
12704  
12705 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12706 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12705 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12706 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12707   if test "${ac_cpu_pentium+set}" = set; then
12708    echo $ECHO_N "(cached) $ECHO_C" >&6
12709   else
12710    echo 'void f(){}' > conftest.cpp
12711 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12711 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12712          ac_cpu_pentium=yes
12713   else
12714          ac_cpu_pentium=no
# Line 8863 | Line 12725 | else
12725          :
12726  
12727  
12728 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12729 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12728 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12729 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12730   if test "${ac_pentium+set}" = set; then
12731    echo $ECHO_N "(cached) $ECHO_C" >&6
12732   else
12733    echo 'void f(){}' > conftest.cpp
12734 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12734 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12735          ac_pentium=yes
12736   else
12737          ac_pentium=no
# Line 8892 | Line 12754 | fi
12754                    ;;
12755            i686*)
12756  
12757 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12758 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12757 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12758 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12759   if test "${ac_cpu_pentiumpro+set}" = set; then
12760    echo $ECHO_N "(cached) $ECHO_C" >&6
12761   else
12762    echo 'void f(){}' > conftest.cpp
12763 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12763 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12764          ac_cpu_pentiumpro=yes
12765   else
12766          ac_cpu_pentiumpro=no
# Line 8915 | Line 12777 | else
12777          :
12778  
12779  
12780 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12781 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12780 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12781 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12782   if test "${ac_pentiumpro+set}" = set; then
12783    echo $ECHO_N "(cached) $ECHO_C" >&6
12784   else
12785    echo 'void f(){}' > conftest.cpp
12786 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12786 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12787          ac_pentiumpro=yes
12788   else
12789          ac_pentiumpro=no
# Line 8948 | Line 12810 | fi
12810                  if test -n "$is60x"; then
12811  
12812  
12813 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12814 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12813 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12814 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12815   if test "${ac_m_cpu_60x+set}" = set; then
12816    echo $ECHO_N "(cached) $ECHO_C" >&6
12817   else
12818    echo 'void f(){}' > conftest.cpp
12819 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12819 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12820          ac_m_cpu_60x=yes
12821   else
12822          ac_m_cpu_60x=no
# Line 9006 | Line 12868 | if test "$ac_cv_prog_gxx_2_95" = yes; then
12868          :
12869  
12870  
12871 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12872 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12871 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12872 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12873   if test "${ac_m_cpu_750+set}" = set; then
12874    echo $ECHO_N "(cached) $ECHO_C" >&6
12875   else
12876    echo 'void f(){}' > conftest.cpp
12877 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12877 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12878          ac_m_cpu_750=yes
12879   else
12880          ac_m_cpu_750=no
# Line 9039 | Line 12901 | fi
12901                  if test -z "$CPU_FLAGS"; then
12902  
12903  
12904 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12905 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12904 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12905 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12906   if test "${ac_m_cpu_powerpc+set}" = set; then
12907    echo $ECHO_N "(cached) $ECHO_C" >&6
12908   else
12909    echo 'void f(){}' > conftest.cpp
12910 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12910 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12911          ac_m_cpu_powerpc=yes
12912   else
12913          ac_m_cpu_powerpc=no
# Line 9067 | Line 12929 | fi
12929                  if test -z "$CPU_FLAGS"; then
12930  
12931  
12932 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12933 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12932 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12933 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12934   if test "${ac_m_powerpc+set}" = set; then
12935    echo $ECHO_N "(cached) $ECHO_C" >&6
12936   else
12937    echo 'void f(){}' > conftest.cpp
12938 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12938 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12939          ac_m_powerpc=yes
12940   else
12941          ac_m_powerpc=no
# Line 9112 | Line 12974 | fi
12974  
12975  
12976  
12977 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12978 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
12977 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12978 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12979   if test "${ac_guessed_cxxflags+set}" = set; then
12980    echo $ECHO_N "(cached) $ECHO_C" >&6
12981   else
12982    echo 'void f(){}' > conftest.cpp
12983 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12983 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12984          ac_guessed_cxxflags=yes
12985   else
12986          ac_guessed_cxxflags=no
# Line 9142 | Line 13004 | else
13004          echo "**********************************************************"
13005          echo ""
13006          CXXFLAGS=""
9145
9146 fi
9147
9148
9149 fi
9150
9151
9152
9153
9154
9155 # Try to determine "good" native compiler flags if none specified on command
9156 # line
9157
9158 if test x"$F90FLAGS" = x ; then
9159  F90FLAGS=""
9160  case "${host_cpu}-${host_os}" in
9161
9162  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
9163                    F90FLAGS="-O"
9164                fi;;
9165   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
9166                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
9167                fi;;
9168   powerpc*-aix*)
9169        if test "$F90" = f90 -o "$F90" = xlf90; then
9170                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
9171                echo "*******************************************************"
9172                echo "*  You have AIX on an unknown powerpc system.  It is  *"
9173                echo "*  recommended that you use                           *"
9174                echo "*                                                     *"
9175                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
9176                echo "*                                 ^^^                 *"
9177                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
9178                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
9179                echo "*******************************************************"
9180        fi;;
9181   *darwin*)
9182        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
9183                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
9184        fi;;
9185  esac
9186
9187  if test -n "$CPU_FLAGS"; then
9188        F90FLAGS="$F90FLAGS $CPU_FLAGS"
9189  fi
9190
9191  if test -z "$F90FLAGS"; then
9192        echo ""
9193        echo "**********************************************************"
9194        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
9195        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9196        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
9197        echo "**********************************************************"
9198        echo ""
9199        F90FLAGS="-O3"
9200  fi
9201
9202
9203 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
9204 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
9205 if test "${ac_guessed_f90flags+set}" = set; then
9206  echo $ECHO_N "(cached) $ECHO_C" >&6
9207 else
9208
9209
9210
9211 ac_ext=f90
9212 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
9213 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9214 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
9215
9216 echo 'program main' > conftest.$ac_ext
9217 echo 'end program main' >> conftest.$ac_ext
9218 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
9219 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9220  (eval $ac_compile) 2>&5
9221  ac_status=$?
9222  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9223  (exit $ac_status); }; then
9224        ac_guessed_f90flags=yes
9225 else
9226        ac_guessed_f90flags=no
9227 fi
9228 rm -f conftest*
9229 ac_ext=c
9230 ac_cpp='$CPP $CPPFLAGS'
9231 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9232 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9233 ac_compiler_gnu=$ac_cv_c_compiler_gnu
13007  
9235
13008   fi
9237 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
9238 echo "${ECHO_T}$ac_guessed_f90flags" >&6
9239 if test "$ac_guessed_f90flags" = yes; then
9240        :
13009  
9242 else
9243        :
13010  
9245        echo ""
9246        echo "**********************************************************"
9247        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
9248        echo "* your compiler.                                         *"
9249        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9250        echo "**********************************************************"
9251        echo ""
9252        F90FLAGS=""
9253
13011   fi
13012  
9256
9257 fi
9258
13013       ;;
13014   esac
9261
9262 # Find a good install program.  We prefer a C program (faster),
9263 # so one script is as good as another.  But avoid the broken or
9264 # incompatible versions:
9265 # SysV /etc/install, /usr/sbin/install
9266 # SunOS /usr/etc/install
9267 # IRIX /sbin/install
9268 # AIX /bin/install
9269 # AmigaOS /C/install, which installs bootblocks on floppy discs
9270 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
9271 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
9272 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
9273 # OS/2's system install, which has a completely different semantic
9274 # ./install, which can be erroneously created by make from ./install.sh.
9275 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
9276 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
9277 if test -z "$INSTALL"; then
9278 if test "${ac_cv_path_install+set}" = set; then
9279  echo $ECHO_N "(cached) $ECHO_C" >&6
9280 else
9281  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9282 for as_dir in $PATH
9283 do
9284  IFS=$as_save_IFS
9285  test -z "$as_dir" && as_dir=.
9286  # Account for people who put trailing slashes in PATH elements.
9287 case $as_dir/ in
9288  ./ | .// | /cC/* | \
9289  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
9290  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
9291  /usr/ucb/* ) ;;
9292  *)
9293    # OSF1 and SCO ODT 3.0 have their own names for install.
9294    # Don't use installbsd from OSF since it installs stuff as root
9295    # by default.
9296    for ac_prog in ginstall scoinst install; do
9297      for ac_exec_ext in '' $ac_executable_extensions; do
9298        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
9299          if test $ac_prog = install &&
9300            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9301            # AIX install.  It has an incompatible calling convention.
9302            :
9303          elif test $ac_prog = install &&
9304            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9305            # program-specific install script used by HP pwplus--don't use.
9306            :
9307          else
9308            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
9309            break 3
9310          fi
9311        fi
9312      done
9313    done
9314    ;;
9315 esac
9316 done
9317
9318
9319 fi
9320  if test "${ac_cv_path_install+set}" = set; then
9321    INSTALL=$ac_cv_path_install
9322  else
9323    # As a last resort, use the slow shell script.  We don't cache a
9324    # path for INSTALL within a source directory, because that will
9325    # break other packages using the cache if that directory is
9326    # removed, or if the path is relative.
9327    INSTALL=$ac_install_sh
9328  fi
9329 fi
9330 echo "$as_me:$LINENO: result: $INSTALL" >&5
9331 echo "${ECHO_T}$INSTALL" >&6
9332
9333 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
9334 # It thinks the first close brace ends the variable substitution.
9335 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
9336
9337 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
9338
9339 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
9340
9341 echo "$as_me:$LINENO: checking whether ln -s works" >&5
9342 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
9343 LN_S=$as_ln_s
9344 if test "$LN_S" = "ln -s"; then
9345  echo "$as_me:$LINENO: result: yes" >&5
9346 echo "${ECHO_T}yes" >&6
9347 else
9348  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
9349 echo "${ECHO_T}no, using $LN_S" >&6
9350 fi
9351
9352 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
9353 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
9354 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
9355 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
9356  echo $ECHO_N "(cached) $ECHO_C" >&6
9357 else
9358  cat >conftest.make <<\_ACEOF
9359 all:
9360        @echo 'ac_maketemp="$(MAKE)"'
9361 _ACEOF
9362 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
9363 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
9364 if test -n "$ac_maketemp"; then
9365  eval ac_cv_prog_make_${ac_make}_set=yes
9366 else
9367  eval ac_cv_prog_make_${ac_make}_set=no
9368 fi
9369 rm -f conftest.make
9370 fi
9371 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
9372  echo "$as_me:$LINENO: result: yes" >&5
9373 echo "${ECHO_T}yes" >&6
9374  SET_MAKE=
9375 else
9376  echo "$as_me:$LINENO: result: no" >&5
9377 echo "${ECHO_T}no" >&6
9378  SET_MAKE="MAKE=${MAKE-make}"
9379 fi
13015  
9381 if test -n "$ac_tool_prefix"; then
9382  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
9383 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
9384 echo "$as_me:$LINENO: checking for $ac_word" >&5
9385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9386 if test "${ac_cv_prog_RANLIB+set}" = set; then
9387  echo $ECHO_N "(cached) $ECHO_C" >&6
9388 else
9389  if test -n "$RANLIB"; then
9390  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
9391 else
9392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9393 for as_dir in $PATH
9394 do
9395  IFS=$as_save_IFS
9396  test -z "$as_dir" && as_dir=.
9397  for ac_exec_ext in '' $ac_executable_extensions; do
9398  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9399    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
9400    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9401    break 2
9402  fi
9403 done
9404 done
13016  
9406 fi
9407 fi
9408 RANLIB=$ac_cv_prog_RANLIB
9409 if test -n "$RANLIB"; then
9410  echo "$as_me:$LINENO: result: $RANLIB" >&5
9411 echo "${ECHO_T}$RANLIB" >&6
9412 else
9413  echo "$as_me:$LINENO: result: no" >&5
9414 echo "${ECHO_T}no" >&6
9415 fi
9416
9417 fi
9418 if test -z "$ac_cv_prog_RANLIB"; then
9419  ac_ct_RANLIB=$RANLIB
9420  # Extract the first word of "ranlib", so it can be a program name with args.
9421 set dummy ranlib; ac_word=$2
9422 echo "$as_me:$LINENO: checking for $ac_word" >&5
9423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9424 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
9425  echo $ECHO_N "(cached) $ECHO_C" >&6
9426 else
9427  if test -n "$ac_ct_RANLIB"; then
9428  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
9429 else
9430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9431 for as_dir in $PATH
9432 do
9433  IFS=$as_save_IFS
9434  test -z "$as_dir" && as_dir=.
9435  for ac_exec_ext in '' $ac_executable_extensions; do
9436  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9437    ac_cv_prog_ac_ct_RANLIB="ranlib"
9438    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9439    break 2
9440  fi
9441 done
9442 done
9443
9444  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
9445 fi
9446 fi
9447 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
9448 if test -n "$ac_ct_RANLIB"; then
9449  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
9450 echo "${ECHO_T}$ac_ct_RANLIB" >&6
9451 else
9452  echo "$as_me:$LINENO: result: no" >&5
9453 echo "${ECHO_T}no" >&6
9454 fi
9455
9456  RANLIB=$ac_ct_RANLIB
9457 else
9458  RANLIB="$ac_cv_prog_RANLIB"
9459 fi
9460
9461 for ac_prog in 'bison -y' byacc
9462 do
9463  # Extract the first word of "$ac_prog", so it can be a program name with args.
9464 set dummy $ac_prog; ac_word=$2
9465 echo "$as_me:$LINENO: checking for $ac_word" >&5
9466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9467 if test "${ac_cv_prog_YACC+set}" = set; then
9468  echo $ECHO_N "(cached) $ECHO_C" >&6
9469 else
9470  if test -n "$YACC"; then
9471  ac_cv_prog_YACC="$YACC" # Let the user override the test.
9472 else
9473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9474 for as_dir in $PATH
9475 do
9476  IFS=$as_save_IFS
9477  test -z "$as_dir" && as_dir=.
9478  for ac_exec_ext in '' $ac_executable_extensions; do
9479  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9480    ac_cv_prog_YACC="$ac_prog"
9481    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9482    break 2
9483  fi
9484 done
9485 done
9486
9487 fi
9488 fi
9489 YACC=$ac_cv_prog_YACC
9490 if test -n "$YACC"; then
9491  echo "$as_me:$LINENO: result: $YACC" >&5
9492 echo "${ECHO_T}$YACC" >&6
9493 else
9494  echo "$as_me:$LINENO: result: no" >&5
9495 echo "${ECHO_T}no" >&6
9496 fi
9497
9498  test -n "$YACC" && break
9499 done
9500 test -n "$YACC" || YACC="yacc"
9501
9502 for ac_prog in flex lex
9503 do
9504  # Extract the first word of "$ac_prog", so it can be a program name with args.
9505 set dummy $ac_prog; ac_word=$2
9506 echo "$as_me:$LINENO: checking for $ac_word" >&5
9507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9508 if test "${ac_cv_prog_LEX+set}" = set; then
9509  echo $ECHO_N "(cached) $ECHO_C" >&6
9510 else
9511  if test -n "$LEX"; then
9512  ac_cv_prog_LEX="$LEX" # Let the user override the test.
9513 else
9514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9515 for as_dir in $PATH
9516 do
9517  IFS=$as_save_IFS
9518  test -z "$as_dir" && as_dir=.
9519  for ac_exec_ext in '' $ac_executable_extensions; do
9520  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9521    ac_cv_prog_LEX="$ac_prog"
9522    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9523    break 2
9524  fi
9525 done
9526 done
9527
9528 fi
9529 fi
9530 LEX=$ac_cv_prog_LEX
9531 if test -n "$LEX"; then
9532  echo "$as_me:$LINENO: result: $LEX" >&5
9533 echo "${ECHO_T}$LEX" >&6
9534 else
9535  echo "$as_me:$LINENO: result: no" >&5
9536 echo "${ECHO_T}no" >&6
9537 fi
9538
9539  test -n "$LEX" && break
9540 done
9541 test -n "$LEX" || LEX=":"
9542
9543 if test -z "$LEXLIB"
9544 then
9545  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
9546 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
9547 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
9548  echo $ECHO_N "(cached) $ECHO_C" >&6
9549 else
9550  ac_check_lib_save_LIBS=$LIBS
9551 LIBS="-lfl  $LIBS"
9552 cat >conftest.$ac_ext <<_ACEOF
9553 /* confdefs.h.  */
9554 _ACEOF
9555 cat confdefs.h >>conftest.$ac_ext
9556 cat >>conftest.$ac_ext <<_ACEOF
9557 /* end confdefs.h.  */
9558
9559 /* Override any gcc2 internal prototype to avoid an error.  */
9560 #ifdef __cplusplus
9561 extern "C"
9562 #endif
9563 /* We use char because int might match the return type of a gcc2
9564   builtin and then its argument prototype would still apply.  */
9565 char yywrap ();
9566 int
9567 main ()
9568 {
9569 yywrap ();
9570  ;
9571  return 0;
9572 }
9573 _ACEOF
9574 rm -f conftest.$ac_objext conftest$ac_exeext
9575 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9576  (eval $ac_link) 2>conftest.er1
9577  ac_status=$?
9578  grep -v '^ *+' conftest.er1 >conftest.err
9579  rm -f conftest.er1
9580  cat conftest.err >&5
9581  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9582  (exit $ac_status); } &&
9583         { ac_try='test -z "$ac_c_werror_flag"
9584                         || test ! -s conftest.err'
9585  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9586  (eval $ac_try) 2>&5
9587  ac_status=$?
9588  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9589  (exit $ac_status); }; } &&
9590         { ac_try='test -s conftest$ac_exeext'
9591  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9592  (eval $ac_try) 2>&5
9593  ac_status=$?
9594  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9595  (exit $ac_status); }; }; then
9596  ac_cv_lib_fl_yywrap=yes
9597 else
9598  echo "$as_me: failed program was:" >&5
9599 sed 's/^/| /' conftest.$ac_ext >&5
9600
9601 ac_cv_lib_fl_yywrap=no
9602 fi
9603 rm -f conftest.err conftest.$ac_objext \
9604      conftest$ac_exeext conftest.$ac_ext
9605 LIBS=$ac_check_lib_save_LIBS
9606 fi
9607 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
9608 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
9609 if test $ac_cv_lib_fl_yywrap = yes; then
9610  LEXLIB="-lfl"
9611 else
9612  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
9613 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
9614 if test "${ac_cv_lib_l_yywrap+set}" = set; then
9615  echo $ECHO_N "(cached) $ECHO_C" >&6
9616 else
9617  ac_check_lib_save_LIBS=$LIBS
9618 LIBS="-ll  $LIBS"
9619 cat >conftest.$ac_ext <<_ACEOF
9620 /* confdefs.h.  */
9621 _ACEOF
9622 cat confdefs.h >>conftest.$ac_ext
9623 cat >>conftest.$ac_ext <<_ACEOF
9624 /* end confdefs.h.  */
9625
9626 /* Override any gcc2 internal prototype to avoid an error.  */
9627 #ifdef __cplusplus
9628 extern "C"
9629 #endif
9630 /* We use char because int might match the return type of a gcc2
9631   builtin and then its argument prototype would still apply.  */
9632 char yywrap ();
9633 int
9634 main ()
9635 {
9636 yywrap ();
9637  ;
9638  return 0;
9639 }
9640 _ACEOF
9641 rm -f conftest.$ac_objext conftest$ac_exeext
9642 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9643  (eval $ac_link) 2>conftest.er1
9644  ac_status=$?
9645  grep -v '^ *+' conftest.er1 >conftest.err
9646  rm -f conftest.er1
9647  cat conftest.err >&5
9648  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9649  (exit $ac_status); } &&
9650         { ac_try='test -z "$ac_c_werror_flag"
9651                         || test ! -s conftest.err'
9652  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9653  (eval $ac_try) 2>&5
9654  ac_status=$?
9655  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9656  (exit $ac_status); }; } &&
9657         { ac_try='test -s conftest$ac_exeext'
9658  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9659  (eval $ac_try) 2>&5
9660  ac_status=$?
9661  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9662  (exit $ac_status); }; }; then
9663  ac_cv_lib_l_yywrap=yes
9664 else
9665  echo "$as_me: failed program was:" >&5
9666 sed 's/^/| /' conftest.$ac_ext >&5
9667
9668 ac_cv_lib_l_yywrap=no
9669 fi
9670 rm -f conftest.err conftest.$ac_objext \
9671      conftest$ac_exeext conftest.$ac_ext
9672 LIBS=$ac_check_lib_save_LIBS
9673 fi
9674 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9675 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9676 if test $ac_cv_lib_l_yywrap = yes; then
9677  LEXLIB="-ll"
9678 fi
9679
9680 fi
9681
9682 fi
9683
9684 if test "x$LEX" != "x:"; then
9685  echo "$as_me:$LINENO: checking lex output file root" >&5
9686 echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9687 if test "${ac_cv_prog_lex_root+set}" = set; then
9688  echo $ECHO_N "(cached) $ECHO_C" >&6
9689 else
9690  # The minimal lex program is just a single line: %%.  But some broken lexes
9691 # (Solaris, I think it was) want two %% lines, so accommodate them.
9692 cat >conftest.l <<_ACEOF
9693 %%
9694 %%
9695 _ACEOF
9696 { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9697  (eval $LEX conftest.l) 2>&5
9698  ac_status=$?
9699  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9700  (exit $ac_status); }
9701 if test -f lex.yy.c; then
9702  ac_cv_prog_lex_root=lex.yy
9703 elif test -f lexyy.c; then
9704  ac_cv_prog_lex_root=lexyy
9705 else
9706  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9707 echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9708   { (exit 1); exit 1; }; }
9709 fi
9710 fi
9711 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9712 echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9713 rm -f conftest.l
9714 LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
9715
9716 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9717 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9718 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9719  echo $ECHO_N "(cached) $ECHO_C" >&6
9720 else
9721  # POSIX says lex can declare yytext either as a pointer or an array; the
9722 # default is implementation-dependent. Figure out which it is, since
9723 # not all implementations provide the %pointer and %array declarations.
9724 ac_cv_prog_lex_yytext_pointer=no
9725 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9726 ac_save_LIBS=$LIBS
9727 LIBS="$LIBS $LEXLIB"
9728 cat >conftest.$ac_ext <<_ACEOF
9729 `cat $LEX_OUTPUT_ROOT.c`
9730 _ACEOF
9731 rm -f conftest.$ac_objext conftest$ac_exeext
9732 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9733  (eval $ac_link) 2>conftest.er1
9734  ac_status=$?
9735  grep -v '^ *+' conftest.er1 >conftest.err
9736  rm -f conftest.er1
9737  cat conftest.err >&5
9738  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9739  (exit $ac_status); } &&
9740         { ac_try='test -z "$ac_c_werror_flag"
9741                         || test ! -s conftest.err'
9742  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9743  (eval $ac_try) 2>&5
9744  ac_status=$?
9745  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9746  (exit $ac_status); }; } &&
9747         { ac_try='test -s conftest$ac_exeext'
9748  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9749  (eval $ac_try) 2>&5
9750  ac_status=$?
9751  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9752  (exit $ac_status); }; }; then
9753  ac_cv_prog_lex_yytext_pointer=yes
9754 else
9755  echo "$as_me: failed program was:" >&5
9756 sed 's/^/| /' conftest.$ac_ext >&5
9757
9758 fi
9759 rm -f conftest.err conftest.$ac_objext \
9760      conftest$ac_exeext conftest.$ac_ext
9761 LIBS=$ac_save_LIBS
9762 rm -f "${LEX_OUTPUT_ROOT}.c"
9763
9764 fi
9765 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9766 echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9767 if test $ac_cv_prog_lex_yytext_pointer = yes; then
9768
9769 cat >>confdefs.h <<\_ACEOF
9770 #define YYTEXT_POINTER 1
9771 _ACEOF
9772
9773 fi
9774
9775 fi
9776
9777   # Extract the first word of "perl", so it can be a program name with args.
9778 set dummy perl; ac_word=$2
9779 echo "$as_me:$LINENO: checking for $ac_word" >&5
9780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9781 if test "${ac_cv_path_PERLINTERP+set}" = set; then
9782  echo $ECHO_N "(cached) $ECHO_C" >&6
9783 else
9784  case $PERLINTERP in
9785  [\\/]* | ?:[\\/]*)
9786  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9787  ;;
9788  *)
9789  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9790 for as_dir in $PATH
9791 do
9792  IFS=$as_save_IFS
9793  test -z "$as_dir" && as_dir=.
9794  for ac_exec_ext in '' $ac_executable_extensions; do
9795  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9796    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9797    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9798    break 2
9799  fi
9800 done
9801 done
9802
9803  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9804  ;;
9805 esac
9806 fi
9807 PERLINTERP=$ac_cv_path_PERLINTERP
9808
9809 if test -n "$PERLINTERP"; then
9810  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9811 echo "${ECHO_T}$PERLINTERP" >&6
9812 else
9813  echo "$as_me:$LINENO: result: no" >&5
9814 echo "${ECHO_T}no" >&6
9815 fi
9816
9817   ac_cv_path_perlinterp="$PERLINTERP"
9818   _sHpB='#!'
9819
9820
9821 # Check whether --with-perl-shebang or --without-perl-shebang was given.
9822 if test "${with_perl_shebang+set}" = set; then
9823  withval="$with_perl_shebang"
9824  opt_perl_shebang="$withval"
9825 else
9826                opt_perl_shebang="not_set"
9827 fi;
9828   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9829 echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9830 if test "${ax_cv_opt_perl_shebang+set}" = set; then
9831  echo $ECHO_N "(cached) $ECHO_C" >&6
9832 else
9833   case "$opt_perl_shebang" in
9834                      not_set  ) ax_cv_opt_perl_shebang=''
9835                               ;;
9836                         *     )
9837        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9838                    esac
9839
9840 fi
9841 echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9842 echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9843   if test "A$ax_cv_opt_perl_shebang" != "A"
9844     then
9845       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9846       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9847              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9848 echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
9849
9850 # Automatic detection of sharpbang formula starts here
9851     else
9852   _somian_shbangperl=`$PERLINTERP -V:startperl`
9853   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9854   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9855 echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9856 if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9857  echo $ECHO_N "(cached) $ECHO_C" >&6
9858 else
9859  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9860        if test "x$_somian_kspb_perl" == x
9861          then _somian_ksbp_warn_empty='durnit'
9862          else
9863          case "A$_somian_kspb_perl" in
9864                 A#!*perl* )
9865           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9866                        ;;
9867                     A*    )  _somian_ksbp_warn_defau='trouble'
9868                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9869          esac
9870        fi
9871
9872 fi
9873 echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
9874 echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
9875 # The above prints Checking ... result message to user.
9876   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9877
9878    if test A${_somian_ksbp_warn_empty+set} == Aset
9879      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9880 echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9881    fi
9882 # Inform user after printing result value
9883    if test A${_somian_ksbp_warn_defau+set} == Aset
9884      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9885 echo "$as_me: Maybe Not good -" >&6;}
9886           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9887 echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9888      else { echo "$as_me:$LINENO: OK Good result - " >&5
9889 echo "$as_me: OK Good result - " >&6;}
9890           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9891 echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9892    fi
9893  fi
9894
9895 # Extract the first word of "ar", so it can be a program name with args.
9896 set dummy ar; ac_word=$2
9897 echo "$as_me:$LINENO: checking for $ac_word" >&5
9898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9899 if test "${ac_cv_prog_AR+set}" = set; then
9900  echo $ECHO_N "(cached) $ECHO_C" >&6
9901 else
9902  if test -n "$AR"; then
9903  ac_cv_prog_AR="$AR" # Let the user override the test.
9904 else
9905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9906 for as_dir in $PATH
9907 do
9908  IFS=$as_save_IFS
9909  test -z "$as_dir" && as_dir=.
9910  for ac_exec_ext in '' $ac_executable_extensions; do
9911  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9912    ac_cv_prog_AR="ar"
9913    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9914    break 2
9915  fi
9916 done
9917 done
9918
9919  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
9920 fi
9921 fi
9922 AR=$ac_cv_prog_AR
9923 if test -n "$AR"; then
9924  echo "$as_me:$LINENO: result: $AR" >&5
9925 echo "${ECHO_T}$AR" >&6
9926 else
9927  echo "$as_me:$LINENO: result: no" >&5
9928 echo "${ECHO_T}no" >&6
9929 fi
9930
9931 if test "$AR" = "NONE"; then
9932  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9933 echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9934   { (exit 1); exit 1; }; }
9935  cat >confcache <<\_ACEOF
9936 # This file is a shell script that caches the results of configure
9937 # tests run on this system so they can be shared between configure
9938 # scripts and configure runs, see configure's option --config-cache.
9939 # It is not useful on other systems.  If it contains results you don't
9940 # want to keep, you may remove or edit it.
9941 #
9942 # config.status only pays attention to the cache file if you give it
9943 # the --recheck option to rerun configure.
9944 #
9945 # `ac_cv_env_foo' variables (set or unset) will be overridden when
9946 # loading this file, other *unset* `ac_cv_foo' will be assigned the
9947 # following values.
9948
9949 _ACEOF
9950
9951 # The following way of writing the cache mishandles newlines in values,
9952 # but we know of no workaround that is simple, portable, and efficient.
9953 # So, don't put newlines in cache variables' values.
9954 # Ultrix sh set writes to stderr and can't be redirected directly,
9955 # and sets the high bit in the cache file unless we assign to the vars.
9956 {
9957  (set) 2>&1 |
9958    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9959    *ac_space=\ *)
9960      # `set' does not quote correctly, so add quotes (double-quote
9961      # substitution turns \\\\ into \\, and sed turns \\ into \).
9962      sed -n \
9963        "s/'/'\\\\''/g;
9964          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9965      ;;
9966    *)
9967      # `set' quotes correctly as required by POSIX, so do not add quotes.
9968      sed -n \
9969        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9970      ;;
9971    esac;
9972 } |
9973  sed '
9974     t clear
9975     : clear
9976     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9977     t end
9978     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9979     : end' >>confcache
9980 if diff $cache_file confcache >/dev/null 2>&1; then :; else
9981  if test -w $cache_file; then
9982    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9983    cat confcache >$cache_file
9984  else
9985    echo "not updating unwritable cache $cache_file"
9986  fi
9987 fi
9988 rm -f confcache
9989  exit 1
9990 fi
9991
9992 # Extract the first word of "ps", so it can be a program name with args.
9993 set dummy ps; ac_word=$2
9994 echo "$as_me:$LINENO: checking for $ac_word" >&5
9995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9996 if test "${ac_cv_path_PS+set}" = set; then
9997  echo $ECHO_N "(cached) $ECHO_C" >&6
9998 else
9999  case $PS in
10000  [\\/]* | ?:[\\/]*)
10001  ac_cv_path_PS="$PS" # Let the user override the test with a path.
10002  ;;
10003  *)
10004  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10005 for as_dir in $PATH
10006 do
10007  IFS=$as_save_IFS
10008  test -z "$as_dir" && as_dir=.
10009  for ac_exec_ext in '' $ac_executable_extensions; do
10010  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10011    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
10012    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10013    break 2
10014  fi
10015 done
10016 done
10017
10018  ;;
10019 esac
10020 fi
10021 PS=$ac_cv_path_PS
10022
10023 if test -n "$PS"; then
10024  echo "$as_me:$LINENO: result: $PS" >&5
10025 echo "${ECHO_T}$PS" >&6
10026 else
10027  echo "$as_me:$LINENO: result: no" >&5
10028 echo "${ECHO_T}no" >&6
10029 fi
10030
10031 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
10032 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
10033 if test "${ac_cv_prog_ps_syntax+set}" = set; then
10034  echo $ECHO_N "(cached) $ECHO_C" >&6
10035 else
10036
10037        if $PS ax -o rss > /dev/null 2>&1; then
10038                ac_cv_prog_ps_ax=yes
10039        else
10040                ac_cv_prog_ps_ax=no
10041        fi
10042        if $PS -ef -o rss > /dev/null 2>&1; then
10043                ac_cv_prog_ps_ef=yes
10044        else
10045                ac_cv_prog_ps_ef=no
10046        fi
10047        if test "$ac_cv_prog_ps_ax" = yes; then
10048                ac_cv_prog_ps_syntax=BSD
10049        else
10050                if test "$ac_cv_prog_ps_ef" = yes; then
10051                        ac_cv_prog_ps_syntax=POSIX
10052                else
10053                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
10054 echo "$as_me: error: Could not determine ps syntax" >&2;}
10055   { (exit 1); exit 1; }; }
10056                fi
10057        fi
10058
10059 fi
10060 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
10061 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
10062
10063
10064 cat >>confdefs.h <<_ACEOF
10065 #define PSCOMMAND $PS
10066 _ACEOF
10067
10068
13017   cat >>confdefs.h <<\_ACEOF
13018   #define OBAPI
13019   _ACEOF
13020  
13021  
13022  
10075 if test "$ac_cv_prog_ps_syntax" = BSD; then
13023  
10077 cat >>confdefs.h <<\_ACEOF
10078 #define PSTYPE_IS_BSD 1
10079 _ACEOF
10080
10081 else
10082   if test "$ac_cv_prog_ps_syntax" = POSIX; then
10083
10084 cat >>confdefs.h <<\_ACEOF
10085 #define PSTYPE_IS_POSIX 1
10086 _ACEOF
10087
10088   else
10089       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
10090 echo "$as_me: error: Unknown ps syntax type!" >&2;}
10091   { (exit 1); exit 1; }; }
10092   fi
10093 fi
10094
10095
13024   # Check whether --with-mpi or --without-mpi was given.
13025   if test "${with_mpi+set}" = set; then
13026    withval="$with_mpi"
# Line 10118 | Line 13046 | MPI_INC_DIR="$MPI/include"
13046  
13047  
13048  
13049 + ac_ext=c
13050 + ac_cpp='$CPP $CPPFLAGS'
13051 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13052 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13053 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13054 +
13055   echo "$as_me:$LINENO: checking for mpi.h" >&5
13056   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13057   have_mpi_h=0
13058   rm -f conftest*
13059 < echo '#include <mpi.h>' > conftest.cc
13060 < if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13059 > echo '#include <mpi.h>' > conftest.c
13060 > if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13061          echo "$as_me:$LINENO: result: yes" >&5
13062   echo "${ECHO_T}yes" >&6
13063          have_mpi_h=1
# Line 10146 | Line 13080 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13080  
13081   echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13082   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13083 +
13084 +
13085 + ac_ext=${FC_SRCEXT-f}
13086 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13087 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13088 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13089 +
13090 + ac_save_ext=$ac_ext
13091 + ac_ext=F90
13092 + ac_save_FCFLAGS=$FCFLAGS
13093   have_mpif_h=0
13094   rm -f conftest*
13095 < cat >conftest.f90 <<EOF
13095 > cat >conftest.$ac_ext <<EOF
13096   program main
13097     include 'mpif.h'
13098   end
13099   EOF
13100 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13100 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13101          echo "$as_me:$LINENO: result: yes" >&5
13102   echo "${ECHO_T}yes" >&6
13103          MPI_F90_INC="$MPI_INC_DIR"
# Line 10175 | Line 13119 | fi
13119   _ACEOF
13120  
13121   fi
13122 + FCFLAGS=$ac_save_FCFLAGS
13123 + ac_ext=$ac_save_ext
13124 + ac_ext=c
13125 + ac_cpp='$CPP $CPPFLAGS'
13126 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13127 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13128 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13129  
13130 +
13131   ac_ext=c
13132   ac_cpp='$CPP $CPPFLAGS'
13133   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 10183 | Line 13135 | ac_save_LDFLAGS=$LDFLAGS
13135   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13136  
13137   ac_save_LDFLAGS=$LDFLAGS
13138 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13138 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13139  
13140   if test x = x"$MPI_LIB"; then
13141          echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
# Line 10207 | Line 13159 | char MPI_Init ();
13159   /* We use char because int might match the return type of a gcc2
13160     builtin and then its argument prototype would still apply.  */
13161   char MPI_Init ();
13162 + #ifdef FC_DUMMY_MAIN
13163 + #ifndef FC_DUMMY_MAIN_EQ_F77
13164 + #  ifdef __cplusplus
13165 +     extern "C"
13166 + #  endif
13167 +   int FC_DUMMY_MAIN() { return 1; }
13168 + #endif
13169 + #endif
13170   int
13171   main ()
13172   {
# Line 10255 | Line 13215 | fi
13215   fi
13216  
13217   fi
13218 + $as_unset ac_cv_lib_mpich_MPI_Init
13219   if test x = x"$MPI_LIB"; then
13220 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13221 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13222 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13220 >        echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13221 > echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13222 > if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13223    echo $ECHO_N "(cached) $ECHO_C" >&6
13224   else
13225    ac_check_lib_save_LIBS=$LIBS
13226 < LIBS="-lmpi  $LIBS"
13226 > LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13227   cat >conftest.$ac_ext <<_ACEOF
13228   /* confdefs.h.  */
13229   _ACEOF
# Line 10277 | Line 13238 | char MPI_Init ();
13238   /* We use char because int might match the return type of a gcc2
13239     builtin and then its argument prototype would still apply.  */
13240   char MPI_Init ();
13241 + #ifdef FC_DUMMY_MAIN
13242 + #ifndef FC_DUMMY_MAIN_EQ_F77
13243 + #  ifdef __cplusplus
13244 +     extern "C"
13245 + #  endif
13246 +   int FC_DUMMY_MAIN() { return 1; }
13247 + #endif
13248 + #endif
13249   int
13250   main ()
13251   {
# Line 10307 | Line 13276 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13276    ac_status=$?
13277    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13278    (exit $ac_status); }; }; then
13279 <  ac_cv_lib_mpi_MPI_Init=yes
13279 >  ac_cv_lib_pmpich_MPI_Init=yes
13280   else
13281    echo "$as_me: failed program was:" >&5
13282   sed 's/^/| /' conftest.$ac_ext >&5
13283  
13284 < ac_cv_lib_mpi_MPI_Init=no
13284 > ac_cv_lib_pmpich_MPI_Init=no
13285   fi
13286   rm -f conftest.err conftest.$ac_objext \
13287        conftest$ac_exeext conftest.$ac_ext
13288   LIBS=$ac_check_lib_save_LIBS
13289   fi
13290 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13291 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13292 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13293 <  MPI_LIB="-lmpi"
13290 > echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13291 > echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13292 > if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13293 >  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13294   fi
13295  
13296   fi
10328 $as_unset ac_cv_lib_mpi_MPI_Init
13297   if test x = x"$MPI_LIB"; then
13298          echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13299   echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
# Line 10333 | Line 13301 | else
13301    echo $ECHO_N "(cached) $ECHO_C" >&6
13302   else
13303    ac_check_lib_save_LIBS=$LIBS
13304 < LIBS="-lmpi "-llam" $LIBS"
13304 > LIBS="-lmpi  $LIBS"
13305   cat >conftest.$ac_ext <<_ACEOF
13306   /* confdefs.h.  */
13307   _ACEOF
# Line 10348 | Line 13316 | char MPI_Init ();
13316   /* We use char because int might match the return type of a gcc2
13317     builtin and then its argument prototype would still apply.  */
13318   char MPI_Init ();
13319 + #ifdef FC_DUMMY_MAIN
13320 + #ifndef FC_DUMMY_MAIN_EQ_F77
13321 + #  ifdef __cplusplus
13322 +     extern "C"
13323 + #  endif
13324 +   int FC_DUMMY_MAIN() { return 1; }
13325 + #endif
13326 + #endif
13327   int
13328   main ()
13329   {
# Line 10392 | Line 13368 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13368   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13369   echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13370   if test $ac_cv_lib_mpi_MPI_Init = yes; then
13371 <  MPI_LIB="-lmpi -llam"
13371 >  MPI_LIB="-lmpi"
13372   fi
13373  
13374   fi
13375 < $as_unset ac_cv_lib_mpich_MPI_Init
13375 > $as_unset ac_cv_lib_mpi_MPI_Init
13376   if test x = x"$MPI_LIB"; then
13377 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13378 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13379 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13377 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13378 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13379 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13380    echo $ECHO_N "(cached) $ECHO_C" >&6
13381   else
13382    ac_check_lib_save_LIBS=$LIBS
13383 < LIBS="-lmpich "-lpmpich" $LIBS"
13383 > LIBS="-lmpi -llam $LIBS"
13384   cat >conftest.$ac_ext <<_ACEOF
13385   /* confdefs.h.  */
13386   _ACEOF
# Line 10419 | Line 13395 | char MPI_Init ();
13395   /* We use char because int might match the return type of a gcc2
13396     builtin and then its argument prototype would still apply.  */
13397   char MPI_Init ();
13398 + #ifdef FC_DUMMY_MAIN
13399 + #ifndef FC_DUMMY_MAIN_EQ_F77
13400 + #  ifdef __cplusplus
13401 +     extern "C"
13402 + #  endif
13403 +   int FC_DUMMY_MAIN() { return 1; }
13404 + #endif
13405 + #endif
13406   int
13407   main ()
13408   {
# Line 10449 | Line 13433 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13433    ac_status=$?
13434    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13435    (exit $ac_status); }; }; then
13436 <  ac_cv_lib_mpich_MPI_Init=yes
13436 >  ac_cv_lib_mpi_MPI_Init=yes
13437   else
13438    echo "$as_me: failed program was:" >&5
13439   sed 's/^/| /' conftest.$ac_ext >&5
13440  
13441 < ac_cv_lib_mpich_MPI_Init=no
13441 > ac_cv_lib_mpi_MPI_Init=no
13442   fi
13443   rm -f conftest.err conftest.$ac_objext \
13444        conftest$ac_exeext conftest.$ac_ext
13445   LIBS=$ac_check_lib_save_LIBS
13446   fi
13447 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13448 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13449 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13450 <  MPI_LIB="-lmpich -lpmpich"
13447 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13448 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13449 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13450 >  MPI_LIB="-lmpi -llam"
13451   fi
13452  
13453   fi
10470
13454   $as_unset ac_cv_lib_mpi_MPI_Init
13455   if test x = x"$MPI_LIB"; then
13456   echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
# Line 10491 | Line 13474 | char MPI_Init ();
13474   /* We use char because int might match the return type of a gcc2
13475     builtin and then its argument prototype would still apply.  */
13476   char MPI_Init ();
13477 + #ifdef FC_DUMMY_MAIN
13478 + #ifndef FC_DUMMY_MAIN_EQ_F77
13479 + #  ifdef __cplusplus
13480 +     extern "C"
13481 + #  endif
13482 +   int FC_DUMMY_MAIN() { return 1; }
13483 + #endif
13484 + #endif
13485   int
13486   main ()
13487   {
# Line 10567 | Line 13558 | fi
13558  
13559  
13560  
13561 + acx_cgal_found=no
13562  
13563 < USE_CGAL=no
13564 < cgal_makefile=auto
13563 > # Check whether --with-cgalmakefile or --without-cgalmakefile was given.
13564 > if test "${with_cgalmakefile+set}" = set; then
13565 >  withval="$with_cgalmakefile"
13566  
10574 # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
10575 if test "${with_cgal_makefile+set}" = set; then
10576  withval="$with_cgal_makefile"
10577  cgal_makefile="$withval"
13567   fi;
13568 + case $with_cgalmakefile in
13569 +        yes | "") ;;
13570 +        no) acx_cgal_found=disable ;;
13571 +        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13572 +        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13573 + esac
13574  
13575 < if test "x$cgal_makefile" != xno; then
13575 > if test "$acx_cgal_found" == no; then
13576 >    echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
13577 > echo $ECHO_N "checking CGAL_MAKEFILE... $ECHO_C" >&6
13578  
13579 <  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
10583 <    cgal_makefile="$CGAL_MAKEFILE"
10584 <  fi
13579 >    if test \! -z "$CGAL_MAKEFILE"; then
13580  
13581 <  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13582 < echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13581 >        if test -e "$CGAL_MAKEFILE"; then
13582 >            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
13583  
13584 <  if test -f "$cgal_makefile"; then
13584 > cat > $tname << _ACEOF
13585 > include $CGAL_MAKEFILE
13586  
13587 <    cat >config.tmp.Makefile <<EOF
13588 < include $cgal_makefile
10593 < default:
10594 <        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
10595 <        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
10596 <        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
10597 <        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
10598 <        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
10599 <        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
10600 <        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
10601 <        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
10602 <        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
10603 <        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
10604 <        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
10605 <        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
10606 < EOF
13587 > cppflags:
13588 >        @echo \$(CGAL_CXXFLAGS)
13589  
13590 <    make -s -f config.tmp.Makefile
13591 <    . config.tmp.cgalvariables
13592 <
13593 <    rm -f config.tmp.Makefile config.tmp.cgalvariables
13594 <
13595 <    if test "x$CGAL_INCLDIR" = "x"; then
13596 <      CGAL_INCLDIR=""
13590 > cxxflags:
13591 >        @echo
13592 > ldflags:
13593 >        @echo \$(CGAL_LDFLAGS)
13594 > _ACEOF
13595 >            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
13596 >            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
13597 >            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
13598 >            for i in $CGAL_LDFLAGST; do
13599 >                if test `echo $i| grep -c ^-l`; then
13600 >                    CGAL_LIBS="$CGAL_LIBS $i"
13601 >                else
13602 >                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
13603 >                fi
13604 >            done
13605 >            rm -f $tname
13606 >            echo "$as_me:$LINENO: result: yes" >&5
13607 > echo "${ECHO_T}yes" >&6
13608 >            acx_cgal_found=yes
13609 >                                   else
13610 >            echo "$as_me:$LINENO: result: invalid" >&5
13611 > echo "${ECHO_T}invalid" >&6
13612 >            { { echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
13613 > echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
13614 >   { (exit 1); exit 1; }; }
13615 >        fi
13616 >    else
13617 >        echo "$as_me:$LINENO: result: not defined" >&5
13618 > echo "${ECHO_T}not defined" >&6
13619      fi
13620 + fi
13621  
13622 <    if test "x$CGAL_LIBDIR" = "x"; then
13623 <      CGAL_LIBDIR=""
13624 <    fi
13625 <
13626 <    if test "x$CGAL_RLIBDIR" = "x"; then
10622 <      CGAL_RLIBDIR=""
10623 <    fi
10624 <
10625 <    if test "x$LEDA_INCLDIR" = "x"; then
10626 <      LEDA_INCLDIR=""
10627 <    fi
10628 <
10629 <    if test "x$LEDA_LIBDIR" = "x"; then
10630 <      LEDA_LIBDIR=""
10631 <    fi
10632 <
10633 <    if test "x$LEDA_RLIBDIR" = "x"; then
10634 <      LEDA_RLIBDIR=""
10635 <    fi
10636 <
10637 <    if test "x$GMP_INCLDIR" = "x"; then
10638 <      GMP_INCLDIR=""
10639 <    fi
10640 <
10641 <    if test "x$GMP_LIBDIR" = "x"; then
10642 <      GMP_LIBDIR=""
10643 <    fi
10644 <
10645 <    if test "x$GMP_RLIBDIR" = "x"; then
10646 <      GMP_RLIBDIR=""
10647 <    fi
10648 <
10649 <    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
10650 < echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
10651 <    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
10652 < echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
10653 <    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
10654 < echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
10655 <    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
10656 < echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
10657 <    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
10658 < echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
10659 <    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
10660 < echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
10661 <    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
10662 < echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
10663 <    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
10664 < echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
10665 <    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
10666 < echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
10667 <
10668 <    ac_ext=cc
10669 < ac_cpp='$CXXCPP $CPPFLAGS'
10670 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10671 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10672 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10673 <
10674 <    save_CXXFLAGS="$CXXFLAGS"
10675 <    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
10676 <    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10677 <  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
10678 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
10679 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13622 > if test "$acx_cgal_found" == no; then
13623 >        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13624 >  echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13625 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13626 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13627    echo $ECHO_N "(cached) $ECHO_C" >&6
13628   fi
13629 < echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13630 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13629 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13630 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13631   else
13632    # Is the header compilable?
13633 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13634 < echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13633 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
13634 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... $ECHO_C" >&6
13635   cat >conftest.$ac_ext <<_ACEOF
13636   /* confdefs.h.  */
13637   _ACEOF
# Line 10692 | Line 13639 | $ac_includes_default
13639   cat >>conftest.$ac_ext <<_ACEOF
13640   /* end confdefs.h.  */
13641   $ac_includes_default
13642 < #include <CGAL/Cartesian.h>
13642 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13643   _ACEOF
13644   rm -f conftest.$ac_objext
13645   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 10703 | Line 13650 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13650    cat conftest.err >&5
13651    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13652    (exit $ac_status); } &&
13653 <         { ac_try='test -z "$ac_cxx_werror_flag"
13653 >         { ac_try='test -z "$ac_c_werror_flag"
13654                           || test ! -s conftest.err'
13655    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13656    (eval $ac_try) 2>&5
# Line 10728 | Line 13675 | echo "${ECHO_T}$ac_header_compiler" >&6
13675   echo "${ECHO_T}$ac_header_compiler" >&6
13676  
13677   # Is the header present?
13678 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13679 < echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13678 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
13679 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... $ECHO_C" >&6
13680   cat >conftest.$ac_ext <<_ACEOF
13681   /* confdefs.h.  */
13682   _ACEOF
13683   cat confdefs.h >>conftest.$ac_ext
13684   cat >>conftest.$ac_ext <<_ACEOF
13685   /* end confdefs.h.  */
13686 < #include <CGAL/Cartesian.h>
13686 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13687   _ACEOF
13688   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13689    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 10747 | Line 13694 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13694    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13695    (exit $ac_status); } >/dev/null; then
13696    if test -s conftest.err; then
13697 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
13698 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13697 >    ac_cpp_err=$ac_c_preproc_warn_flag
13698 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13699    else
13700      ac_cpp_err=
13701    fi
# Line 10768 | Line 13715 | echo "${ECHO_T}$ac_header_preproc" >&6
13715   echo "${ECHO_T}$ac_header_preproc" >&6
13716  
13717   # So?  What about this header?
13718 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13718 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13719    yes:no: )
13720 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13721 < echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13722 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13723 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13720 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
13721 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13722 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
13723 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
13724      ac_header_preproc=yes
13725      ;;
13726    no:yes:* )
13727 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13728 < echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13729 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13730 < echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13731 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13732 < echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13733 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13734 < echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13735 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13736 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13737 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13738 < echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13727 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
13728 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
13729 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
13730 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
13731 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
13732 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
13733 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
13734 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13735 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
13736 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
13737 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
13738 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
13739      (
13740        cat <<\_ASBOX
13741   ## ------------------------------ ##
# Line 10799 | Line 13746 | esac
13746        sed "s/^/$as_me: WARNING:     /" >&2
13747      ;;
13748   esac
13749 < echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13750 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13751 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13749 > echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13750 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13751 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13752    echo $ECHO_N "(cached) $ECHO_C" >&6
13753   else
13754 <  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13754 >  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
13755   fi
13756 < echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13757 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13756 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13757 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13758  
13759   fi
13760 < if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13761 <  cgal=yes
13760 > if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
13761 >  cgal_have_header=yes
13762   else
13763 <  cgal=no
13763 >  cgal_have_header=no
13764   fi
13765  
13766  
13767 <    CXXFLAGS="$save_CXXFLAGS"
13767 >        if test "$cgal_have_header" == yes; then
13768 >                echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
13769 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
13770 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
13771 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13772 > else
13773 >  ac_check_lib_save_LIBS=$LIBS
13774 > LIBS="-lCGAL  $LIBS"
13775 > cat >conftest.$ac_ext <<_ACEOF
13776 > /* confdefs.h.  */
13777 > _ACEOF
13778 > cat confdefs.h >>conftest.$ac_ext
13779 > cat >>conftest.$ac_ext <<_ACEOF
13780 > /* end confdefs.h.  */
13781  
10822    if test "x$cgal" = xyes; then
10823      echo "$as_me:$LINENO: checking for CGAL version" >&5
10824 echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
10825      LOCATION=${CGAL_INCLDIR}
10826      LOCATION=${LOCATION:-/usr/include}
10827      if test -f $LOCATION/CGAL/version.h; then
10828        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
10829      else
10830        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
10831      fi
10832      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
10833        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
10834 echo "${ECHO_T}($CGAL_VERSION) yes" >&6
10835      else
10836        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
10837 echo "${ECHO_T}($CGAL_VERSION) no" >&6
10838        cgal=no
10839      fi
10840    fi
13782  
13783 <    if test "x$cgal" = xyes; then
13784 <      CGAL_LIBS="-lCGAL"
13785 <      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13786 < echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13787 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13788 <        CGAL_USES_LEDA=yes
13789 <        echo "$as_me:$LINENO: result: yes" >&5
13790 < echo "${ECHO_T}yes" >&6
13791 <        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13792 <      else
13793 <        echo "$as_me:$LINENO: result: no" >&5
13794 < echo "${ECHO_T}no" >&6
13795 <        CGAL_USES_LEDA=no
13796 <      fi
13783 > #ifdef FC_DUMMY_MAIN
13784 > #ifndef FC_DUMMY_MAIN_EQ_F77
13785 > #  ifdef __cplusplus
13786 >     extern "C"
13787 > #  endif
13788 >   int FC_DUMMY_MAIN() { return 1; }
13789 > #endif
13790 > #endif
13791 > int
13792 > main ()
13793 > {
13794 > main ();
13795 >  ;
13796 >  return 0;
13797 > }
13798 > _ACEOF
13799 > rm -f conftest.$ac_objext conftest$ac_exeext
13800 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13801 >  (eval $ac_link) 2>conftest.er1
13802 >  ac_status=$?
13803 >  grep -v '^ *+' conftest.er1 >conftest.err
13804 >  rm -f conftest.er1
13805 >  cat conftest.err >&5
13806 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13807 >  (exit $ac_status); } &&
13808 >         { ac_try='test -z "$ac_c_werror_flag"
13809 >                         || test ! -s conftest.err'
13810 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13811 >  (eval $ac_try) 2>&5
13812 >  ac_status=$?
13813 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13814 >  (exit $ac_status); }; } &&
13815 >         { ac_try='test -s conftest$ac_exeext'
13816 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13817 >  (eval $ac_try) 2>&5
13818 >  ac_status=$?
13819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13820 >  (exit $ac_status); }; }; then
13821 >  ac_cv_lib_CGAL_main=yes
13822 > else
13823 >  echo "$as_me: failed program was:" >&5
13824 > sed 's/^/| /' conftest.$ac_ext >&5
13825  
13826 <      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13827 < echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13828 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13829 <        CGAL_USES_GMP=yes
13830 <        echo "$as_me:$LINENO: result: yes" >&5
13831 < echo "${ECHO_T}yes" >&6
13832 <        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13833 <      else
13834 <        echo "$as_me:$LINENO: result: no" >&5
13835 < echo "${ECHO_T}no" >&6
13836 <        CGAL_USES_GMP=no
13837 <      fi
13826 > ac_cv_lib_CGAL_main=no
13827 > fi
13828 > rm -f conftest.err conftest.$ac_objext \
13829 >      conftest$ac_exeext conftest.$ac_ext
13830 > LIBS=$ac_check_lib_save_LIBS
13831 > fi
13832 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
13833 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
13834 > if test $ac_cv_lib_CGAL_main = yes; then
13835 >  cgal_have_lib=yes
13836 > else
13837 >  cgal_have_lib=no
13838 > fi
13839  
13840 <      CGAL_LIBS="$CGAL_LIBS -lm"
13840 >                if test "$cgal_have_lib" == no; then
13841 >                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
13842 >                        echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
13843 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
13844 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
13845 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13846 > else
13847 >  ac_check_lib_save_LIBS=$LIBS
13848 > LIBS="-lCGAL  $LIBS"
13849 > cat >conftest.$ac_ext <<_ACEOF
13850 > /* confdefs.h.  */
13851 > _ACEOF
13852 > cat confdefs.h >>conftest.$ac_ext
13853 > cat >>conftest.$ac_ext <<_ACEOF
13854 > /* end confdefs.h.  */
13855  
10872      CGAL_CXXFLAGS="-ftemplate-depth-50"
13856  
13857 <      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13858 < echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13859 <      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13860 < echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13861 <      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13862 < echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13863 <      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13864 < echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13865 <      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13866 < echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13867 <      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13868 < echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13869 <      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13870 < echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13871 <    fi
13857 > #ifdef FC_DUMMY_MAIN
13858 > #ifndef FC_DUMMY_MAIN_EQ_F77
13859 > #  ifdef __cplusplus
13860 >     extern "C"
13861 > #  endif
13862 >   int FC_DUMMY_MAIN() { return 1; }
13863 > #endif
13864 > #endif
13865 > int
13866 > main ()
13867 > {
13868 > main ();
13869 >  ;
13870 >  return 0;
13871 > }
13872 > _ACEOF
13873 > rm -f conftest.$ac_objext conftest$ac_exeext
13874 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13875 >  (eval $ac_link) 2>conftest.er1
13876 >  ac_status=$?
13877 >  grep -v '^ *+' conftest.er1 >conftest.err
13878 >  rm -f conftest.er1
13879 >  cat conftest.err >&5
13880 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13881 >  (exit $ac_status); } &&
13882 >         { ac_try='test -z "$ac_c_werror_flag"
13883 >                         || test ! -s conftest.err'
13884 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13885 >  (eval $ac_try) 2>&5
13886 >  ac_status=$?
13887 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13888 >  (exit $ac_status); }; } &&
13889 >         { ac_try='test -s conftest$ac_exeext'
13890 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13891 >  (eval $ac_try) 2>&5
13892 >  ac_status=$?
13893 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13894 >  (exit $ac_status); }; }; then
13895 >  ac_cv_lib_CGAL_main=yes
13896 > else
13897 >  echo "$as_me: failed program was:" >&5
13898 > sed 's/^/| /' conftest.$ac_ext >&5
13899  
13900 <    if test "x$cgal" = xyes; then
13901 <      save_LIBS="$LIBS"
13902 <      LIBS="$LIBS -L$CGAL_LIBDIR"
13903 <      if test "x$CGAL_USES_LEDA" = xyes; then
13904 <        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13905 <      fi
13906 <      # if test "x$CGAL_USES_GMP" = xyes; then
13907 <      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13908 <      # fi
13909 <      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13910 < echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13911 < save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13912 < CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13913 < save_LIBS_CHECK_CXX_LIB="$LIBS"
13914 < LIBS="-lCGAL  $LIBS"
13900 > ac_cv_lib_CGAL_main=no
13901 > fi
13902 > rm -f conftest.err conftest.$ac_objext \
13903 >      conftest$ac_exeext conftest.$ac_ext
13904 > LIBS=$ac_check_lib_save_LIBS
13905 > fi
13906 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
13907 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
13908 > if test $ac_cv_lib_CGAL_main = yes; then
13909 >  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
13910 >                                                  cgal_have_lib=yes
13911 > else
13912 >  cgal_have_lib=no
13913 > fi
13914 >
13915 >                        LIBS="$save_LIBS"
13916 >                else
13917 >                        CGAL_LIBS="-lCGAL"
13918 >                        echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
13919 > echo $ECHO_N "checking for main in -lmpfr... $ECHO_C" >&6
13920 > if test "${ac_cv_lib_mpfr_main+set}" = set; then
13921 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13922 > else
13923 >  ac_check_lib_save_LIBS=$LIBS
13924 > LIBS="-lmpfr  $LIBS"
13925   cat >conftest.$ac_ext <<_ACEOF
13926   /* confdefs.h.  */
13927   _ACEOF
13928   cat confdefs.h >>conftest.$ac_ext
13929   cat >>conftest.$ac_ext <<_ACEOF
13930   /* end confdefs.h.  */
13931 < #include <CGAL/Cartesian.h>
13931 >
13932 >
13933 > #ifdef FC_DUMMY_MAIN
13934 > #ifndef FC_DUMMY_MAIN_EQ_F77
13935 > #  ifdef __cplusplus
13936 >     extern "C"
13937 > #  endif
13938 >   int FC_DUMMY_MAIN() { return 1; }
13939 > #endif
13940 > #endif
13941   int
13942   main ()
13943   {
13944 < ::CGAL::Cartesian<int>::Point_2 P
13944 > main ();
13945    ;
13946    return 0;
13947   }
# Line 10926 | Line 13955 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13955    cat conftest.err >&5
13956    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13957    (exit $ac_status); } &&
13958 <         { ac_try='test -z "$ac_cxx_werror_flag"
13958 >         { ac_try='test -z "$ac_c_werror_flag"
13959                           || test ! -s conftest.err'
13960    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13961    (eval $ac_try) 2>&5
# Line 10939 | Line 13968 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13968    ac_status=$?
13969    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13970    (exit $ac_status); }; }; then
13971 <  echo "$as_me:$LINENO: result: yes" >&5
10943 < echo "${ECHO_T}yes" >&6
10944 < cgal=yes
13971 >  ac_cv_lib_mpfr_main=yes
13972   else
13973    echo "$as_me: failed program was:" >&5
13974   sed 's/^/| /' conftest.$ac_ext >&5
13975  
13976 < echo "$as_me:$LINENO: result: no" >&5
10950 < echo "${ECHO_T}no" >&6
10951 < cgal=no
13976 > ac_cv_lib_mpfr_main=no
13977   fi
13978   rm -f conftest.err conftest.$ac_objext \
13979        conftest$ac_exeext conftest.$ac_ext
13980 < CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13981 < LIBS="$save_LIBS_CHECK_CXX_LIB"
13982 <      LIBS="$save_LIBS"
13983 <    fi
13980 > LIBS=$ac_check_lib_save_LIBS
13981 > fi
13982 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
13983 > echo "${ECHO_T}$ac_cv_lib_mpfr_main" >&6
13984 > if test $ac_cv_lib_mpfr_main = yes; then
13985 >  CGAL_LIBS="$CGAL_LIBS -lmpfr"
13986 > fi
13987  
13988 <  fi
13989 <  ac_ext=c
13990 < ac_cpp='$CPP $CPPFLAGS'
13991 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13992 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13993 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13988 >                        echo "$as_me:$LINENO: checking for main in -lgmp" >&5
13989 > echo $ECHO_N "checking for main in -lgmp... $ECHO_C" >&6
13990 > if test "${ac_cv_lib_gmp_main+set}" = set; then
13991 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13992 > else
13993 >  ac_check_lib_save_LIBS=$LIBS
13994 > LIBS="-lgmp  $LIBS"
13995 > cat >conftest.$ac_ext <<_ACEOF
13996 > /* confdefs.h.  */
13997 > _ACEOF
13998 > cat confdefs.h >>conftest.$ac_ext
13999 > cat >>conftest.$ac_ext <<_ACEOF
14000 > /* end confdefs.h.  */
14001  
14002  
14003 + #ifdef FC_DUMMY_MAIN
14004 + #ifndef FC_DUMMY_MAIN_EQ_F77
14005 + #  ifdef __cplusplus
14006 +     extern "C"
14007 + #  endif
14008 +   int FC_DUMMY_MAIN() { return 1; }
14009 + #endif
14010 + #endif
14011 + int
14012 + main ()
14013 + {
14014 + main ();
14015 +  ;
14016 +  return 0;
14017 + }
14018 + _ACEOF
14019 + rm -f conftest.$ac_objext conftest$ac_exeext
14020 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14021 +  (eval $ac_link) 2>conftest.er1
14022 +  ac_status=$?
14023 +  grep -v '^ *+' conftest.er1 >conftest.err
14024 +  rm -f conftest.er1
14025 +  cat conftest.err >&5
14026 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14027 +  (exit $ac_status); } &&
14028 +         { ac_try='test -z "$ac_c_werror_flag"
14029 +                         || test ! -s conftest.err'
14030 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14031 +  (eval $ac_try) 2>&5
14032 +  ac_status=$?
14033 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14034 +  (exit $ac_status); }; } &&
14035 +         { ac_try='test -s conftest$ac_exeext'
14036 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14037 +  (eval $ac_try) 2>&5
14038 +  ac_status=$?
14039 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14040 +  (exit $ac_status); }; }; then
14041 +  ac_cv_lib_gmp_main=yes
14042 + else
14043 +  echo "$as_me: failed program was:" >&5
14044 + sed 's/^/| /' conftest.$ac_ext >&5
14045 +
14046 + ac_cv_lib_gmp_main=no
14047   fi
14048 + rm -f conftest.err conftest.$ac_objext \
14049 +      conftest$ac_exeext conftest.$ac_ext
14050 + LIBS=$ac_check_lib_save_LIBS
14051 + fi
14052 + echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
14053 + echo "${ECHO_T}$ac_cv_lib_gmp_main" >&6
14054 + if test $ac_cv_lib_gmp_main = yes; then
14055 +  CGAL_LIBS="$CGAL_LIBS -lgmp"
14056 + fi
14057  
14058 < if test "x$cgal" = xyes; then
14059 <  USE_CGAL=yes
14060 <
14061 < cat >>confdefs.h <<\_ACEOF
14062 < #define HAVE_CGAL 1
14058 >                        echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
14059 > echo $ECHO_N "checking for main in -lgmpxx... $ECHO_C" >&6
14060 > if test "${ac_cv_lib_gmpxx_main+set}" = set; then
14061 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14062 > else
14063 >  ac_check_lib_save_LIBS=$LIBS
14064 > LIBS="-lgmpxx  $LIBS"
14065 > cat >conftest.$ac_ext <<_ACEOF
14066 > /* confdefs.h.  */
14067   _ACEOF
14068 + cat confdefs.h >>conftest.$ac_ext
14069 + cat >>conftest.$ac_ext <<_ACEOF
14070 + /* end confdefs.h.  */
14071  
14072  
14073 < cat >>confdefs.h <<_ACEOF
14074 < #define CGAL_VERSION $CGAL_VERSION
14073 > #ifdef FC_DUMMY_MAIN
14074 > #ifndef FC_DUMMY_MAIN_EQ_F77
14075 > #  ifdef __cplusplus
14076 >     extern "C"
14077 > #  endif
14078 >   int FC_DUMMY_MAIN() { return 1; }
14079 > #endif
14080 > #endif
14081 > int
14082 > main ()
14083 > {
14084 > main ();
14085 >  ;
14086 >  return 0;
14087 > }
14088   _ACEOF
14089 + rm -f conftest.$ac_objext conftest$ac_exeext
14090 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14091 +  (eval $ac_link) 2>conftest.er1
14092 +  ac_status=$?
14093 +  grep -v '^ *+' conftest.er1 >conftest.err
14094 +  rm -f conftest.er1
14095 +  cat conftest.err >&5
14096 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14097 +  (exit $ac_status); } &&
14098 +         { ac_try='test -z "$ac_c_werror_flag"
14099 +                         || test ! -s conftest.err'
14100 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14101 +  (eval $ac_try) 2>&5
14102 +  ac_status=$?
14103 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14104 +  (exit $ac_status); }; } &&
14105 +         { ac_try='test -s conftest$ac_exeext'
14106 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14107 +  (eval $ac_try) 2>&5
14108 +  ac_status=$?
14109 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14110 +  (exit $ac_status); }; }; then
14111 +  ac_cv_lib_gmpxx_main=yes
14112 + else
14113 +  echo "$as_me: failed program was:" >&5
14114 + sed 's/^/| /' conftest.$ac_ext >&5
14115  
14116 <  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
14117 <    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14118 < echo "$as_me: WARNING: *****************************************************" >&2;}
14119 <    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
14120 < echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
14121 <    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
14122 < echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
14123 <    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14124 < echo "$as_me: WARNING: *****************************************************" >&2;}
14125 <  fi
14116 > ac_cv_lib_gmpxx_main=no
14117 > fi
14118 > rm -f conftest.err conftest.$ac_objext \
14119 >      conftest$ac_exeext conftest.$ac_ext
14120 > LIBS=$ac_check_lib_save_LIBS
14121 > fi
14122 > echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
14123 > echo "${ECHO_T}$ac_cv_lib_gmpxx_main" >&6
14124 > if test $ac_cv_lib_gmpxx_main = yes; then
14125 >  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
14126 > fi
14127 >
14128 >                fi
14129 >
14130 >                if test "$cgal_have_lib" == yes; then
14131 >                        acx_cgal_found=yes
14132 >                fi
14133 >        fi
14134 >        if test "$acx_cgal_found" == yes; then
14135 >                echo "$as_me:$LINENO: checking for main in -lCore" >&5
14136 > echo $ECHO_N "checking for main in -lCore... $ECHO_C" >&6
14137 > if test "${ac_cv_lib_Core_main+set}" = set; then
14138 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14139 > else
14140 >  ac_check_lib_save_LIBS=$LIBS
14141 > LIBS="-lCore  $LIBS"
14142 > cat >conftest.$ac_ext <<_ACEOF
14143 > /* confdefs.h.  */
14144 > _ACEOF
14145 > cat confdefs.h >>conftest.$ac_ext
14146 > cat >>conftest.$ac_ext <<_ACEOF
14147 > /* end confdefs.h.  */
14148 >
14149 >
14150 > #ifdef FC_DUMMY_MAIN
14151 > #ifndef FC_DUMMY_MAIN_EQ_F77
14152 > #  ifdef __cplusplus
14153 >     extern "C"
14154 > #  endif
14155 >   int FC_DUMMY_MAIN() { return 1; }
14156 > #endif
14157 > #endif
14158 > int
14159 > main ()
14160 > {
14161 > main ();
14162 >  ;
14163 >  return 0;
14164 > }
14165 > _ACEOF
14166 > rm -f conftest.$ac_objext conftest$ac_exeext
14167 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14168 >  (eval $ac_link) 2>conftest.er1
14169 >  ac_status=$?
14170 >  grep -v '^ *+' conftest.er1 >conftest.err
14171 >  rm -f conftest.er1
14172 >  cat conftest.err >&5
14173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14174 >  (exit $ac_status); } &&
14175 >         { ac_try='test -z "$ac_c_werror_flag"
14176 >                         || test ! -s conftest.err'
14177 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14178 >  (eval $ac_try) 2>&5
14179 >  ac_status=$?
14180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14181 >  (exit $ac_status); }; } &&
14182 >         { ac_try='test -s conftest$ac_exeext'
14183 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14184 >  (eval $ac_try) 2>&5
14185 >  ac_status=$?
14186 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14187 >  (exit $ac_status); }; }; then
14188 >  ac_cv_lib_Core_main=yes
14189   else
14190 <   if test "x$cgal_makefile" != xno; then
14191 <    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
14192 < echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
14193 <  fi
10997 <  CGAL_INCLDIR=
10998 <  CGAL_LIBDIR=
10999 <  CGAL_RLIBDIR=
11000 <  CGAL_DEFINES=
11001 <  CGAL_CXXFLAGS=
11002 <  CGAL_LIBS=
14190 >  echo "$as_me: failed program was:" >&5
14191 > sed 's/^/| /' conftest.$ac_ext >&5
14192 >
14193 > ac_cv_lib_Core_main=no
14194   fi
14195 + rm -f conftest.err conftest.$ac_objext \
14196 +      conftest$ac_exeext conftest.$ac_ext
14197 + LIBS=$ac_check_lib_save_LIBS
14198 + fi
14199 + echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
14200 + echo "${ECHO_T}$ac_cv_lib_Core_main" >&6
14201 + if test $ac_cv_lib_Core_main = yes; then
14202 +  CGAL_LIBS="$CGAL_LIBS -lCore"
14203 + fi
14204  
14205 +        fi
14206 + fi
14207  
11006 CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
14208  
11008 CGAL_LIB_DIR=${CGAL_LIBDIR}
14209  
14210 < CGAL_RLIB_DIR=${CGAL_RLIBDIR}
14210 > echo "$as_me:$LINENO: checking CGAL" >&5
14211 > echo $ECHO_N "checking CGAL... $ECHO_C" >&6
14212 > if test "$acx_cgal_found" == yes; then
14213 >        echo "$as_me:$LINENO: result: yes" >&5
14214 > echo "${ECHO_T}yes" >&6;
14215  
14216 + else
14217 +        echo "$as_me:$LINENO: result: no" >&5
14218 + echo "${ECHO_T}no" >&6
14219  
14220 + fi
14221  
14222 + if test "$acx_cgal_found" == yes; then
14223 +        USE_CGAL=yes
14224  
14225 + cat >>confdefs.h <<\_ACEOF
14226 + #define HAVE_CGAL 1
14227 + _ACEOF
14228  
14229  
14230  
14231 +
14232 +
14233 +
14234 + fi
14235 +
14236 +
14237 +
14238   # Check whether --enable-doxygen or --disable-doxygen was given.
14239   if test "${enable_doxygen+set}" = set; then
14240    enableval="$enable_doxygen"
# Line 11149 | Line 14369 | fi
14369   else
14370          enable_dot=yes
14371   fi
11152
11153
11154
11155
11156
11157
11158
11159 OBJEXT=".$OBJEXT"
11160
11161 OOPSE=oopse
11162
11163 if test "x${prefix}" = "xNONE"
11164 then
11165  OOPSE_HOME=${ac_default_prefix}/oopse
11166 else
11167  OOPSE_HOME=${prefix}/oopse
11168 fi
11169 # Check whether --enable-oopse-home or --disable-oopse-home was given.
11170 if test "${enable_oopse_home+set}" = set; then
11171  enableval="$enable_oopse_home"
11172  OOPSE_HOME="${enableval}"
11173 fi;
14372  
11175 case "x$INSTALL" in
11176   x/*) ;;
11177   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
11178 esac
14373  
11180 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14374  
11182 CFLAGS=${CFLAGS-""}
11183 CXXFLAGS=${CXXFLAGS-""}
11184 CPPFLAGS=${CPPFLAGS-""}
11185 FFLAGS=${FFLAGS-""}
11186 F90FLAGS=${F90FLAGS-""}
11187 LDFLAGS=${LDFLAGS-""}
11188 DEBUG=${DEBUG-"-g"}
14375  
11190 case $debug in
11191  1)
11192     FFLAGS="$DEBUG $FFLAGS"
11193     F90FLAGS="$DEBUG $F90FLAGS"
11194     ;;
11195  *)
11196     ;;
11197 esac
11198
11199
11200
14376  
14377  
14378  
# Line 11213 | Line 14388 | esac
14388  
14389  
14390  
14391 <          ac_config_headers="$ac_config_headers src/config.h"
11217 <
11218 <                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14391 >                                                  ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/applications/staticProps/Makefile scripts/filepp"
14392  
14393  
14394   cat >confcache <<\_ACEOF
# Line 11580 | Line 14753 | cat >&5 <<_CSEOF
14753   } >&5
14754   cat >&5 <<_CSEOF
14755  
14756 < This file was extended by OOPSE $as_me 2.0, which was
14756 > This file was extended by OOPSE $as_me 4.0, which was
14757   generated by GNU Autoconf 2.59.  Invocation command line was
14758  
14759    CONFIG_FILES    = $CONFIG_FILES
# Line 11643 | Line 14816 | ac_cs_version="\\
14816  
14817   cat >>$CONFIG_STATUS <<_ACEOF
14818   ac_cs_version="\\
14819 < OOPSE config.status 2.0
14819 > OOPSE config.status 4.0
14820   configured by $0, generated by GNU Autoconf 2.59,
14821    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14822  
# Line 11748 | Line 14921 | do
14921    # Handling of arguments.
14922    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14923    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14924 <  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14924 >  "src/math/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
14925 >  "src/applications/staticProps/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/staticProps/Makefile" ;;
14926    "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14927    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14928    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
# Line 11837 | Line 15011 | s,@LIBS@,$LIBS,;t t
15011   s,@ECHO_N@,$ECHO_N,;t t
15012   s,@ECHO_T@,$ECHO_T,;t t
15013   s,@LIBS@,$LIBS,;t t
11840 s,@PROGNAME@,$PROGNAME,;t t
11841 s,@debug@,$debug,;t t
15014   s,@build@,$build,;t t
15015   s,@build_cpu@,$build_cpu,;t t
15016   s,@build_vendor@,$build_vendor,;t t
# Line 11847 | Line 15019 | s,@host_os@,$host_os,;t t
15019   s,@host_cpu@,$host_cpu,;t t
15020   s,@host_vendor@,$host_vendor,;t t
15021   s,@host_os@,$host_os,;t t
15022 < s,@CC@,$CC,;t t
15023 < s,@CFLAGS@,$CFLAGS,;t t
15022 > s,@PROGNAME@,$PROGNAME,;t t
15023 > s,@debug@,$debug,;t t
15024 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
15025 > s,@CXX@,$CXX,;t t
15026 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15027   s,@LDFLAGS@,$LDFLAGS,;t t
15028   s,@CPPFLAGS@,$CPPFLAGS,;t t
15029 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15029 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15030   s,@EXEEXT@,$EXEEXT,;t t
15031   s,@OBJEXT@,$OBJEXT,;t t
15032 < s,@CXX@,$CXX,;t t
15033 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15034 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15035 < s,@CPP@,$CPP,;t t
15036 < s,@EGREP@,$EGREP,;t t
15037 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15038 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15039 < s,@F90@,$F90,;t t
11865 < s,@F90FLAGS@,$F90FLAGS,;t t
11866 < s,@ac_ct_F90@,$ac_ct_F90,;t t
11867 < s,@PREPFLAG@,$PREPFLAG,;t t
11868 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11869 < s,@F90LIBS@,$F90LIBS,;t t
11870 < s,@F90_FUNC@,$F90_FUNC,;t t
11871 < s,@F90_FUNC_@,$F90_FUNC_,;t t
11872 < s,@MOD@,$MOD,;t t
11873 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11874 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11875 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11876 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
11877 < s,@CXXCPP@,$CXXCPP,;t t
11878 < s,@LIBOBJS@,$LIBOBJS,;t t
11879 < s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11880 < s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11881 < s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15032 > s,@CC@,$CC,;t t
15033 > s,@CFLAGS@,$CFLAGS,;t t
15034 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15035 > s,@FC@,$FC,;t t
15036 > s,@FCFLAGS@,$FCFLAGS,;t t
15037 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15038 > s,@CPP@,$CPP,;t t
15039 > s,@EGREP@,$EGREP,;t t
15040   s,@LN_S@,$LN_S,;t t
15041   s,@SET_MAKE@,$SET_MAKE,;t t
15042   s,@RANLIB@,$RANLIB,;t t
15043   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11886 s,@YACC@,$YACC,;t t
11887 s,@LEX@,$LEX,;t t
11888 s,@LEXLIB@,$LEXLIB,;t t
11889 s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15044   s,@PERLINTERP@,$PERLINTERP,;t t
15045   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15046 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15047 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15048 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15049   s,@AR@,$AR,;t t
15050   s,@PS@,$PS,;t t
15051 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15052 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15053 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15054 + s,@FCLIBS@,$FCLIBS,;t t
15055 + s,@FC_FUNC@,$FC_FUNC,;t t
15056 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15057 + s,@MOD@,$MOD,;t t
15058 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15059 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15060 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15061 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15062 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
15063 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
15064 + s,@ZLIB@,$ZLIB,;t t
15065 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
15066 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
15067 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
15068 + s,@LIBOBJS@,$LIBOBJS,;t t
15069 + s,@POW_LIB@,$POW_LIB,;t t
15070 + s,@CXXCPP@,$CXXCPP,;t t
15071 + s,@__func__@,$__func__,;t t
15072   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15073   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15074   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11898 | Line 15076 | s,@USE_CGAL@,$USE_CGAL,;t t
15076   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15077   s,@USE_MPI@,$USE_MPI,;t t
15078   s,@USE_CGAL@,$USE_CGAL,;t t
11901 s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
11902 s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
11903 s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
11904 s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
15079   s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15080 + s,@CGAL_LDFLAGS@,$CGAL_LDFLAGS,;t t
15081 + s,@CGAL_CPPFLAGS@,$CGAL_CPPFLAGS,;t t
15082   s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15083   s,@DOXYGEN@,$DOXYGEN,;t t
15084   s,@DOT@,$DOT,;t t
# Line 11915 | Line 15091 | s,@SUBDIRS@,$SUBDIRS,;t t
15091   s,@OOPSE@,$OOPSE,;t t
15092   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15093   s,@SUBDIRS@,$SUBDIRS,;t t
11918 s,@FFLAGS@,$FFLAGS,;t t
15094   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15095   CEOF
15096  
# Line 12157 | Line 15332 | s,@INSTALL@,$ac_INSTALL,;t t
15332    case $ac_file in
15333      make/Makefile ) chmod 0755 scripts/* ;;
15334      src/utils/Makefile ) chmod 0755 scripts/* ;;
15335 <    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15335 >    src/math/Makefile ) chmod 0755 scripts/* ;;
15336 >    src/applications/staticProps/Makefile ) chmod 0755 scripts/* ;;
15337      scripts/filepp ) chmod 0755 scripts/* ;;
15338    esac
15339   done

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines