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

Comparing trunk/OOPSE-4/configure (file contents):
Revision 2505 by gezelter, Fri Dec 9 17:11:12 2005 UTC vs.
Revision 2998 by gezelter, Mon Sep 4 13:37:15 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_VERSION='2.0'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX 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_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 < ac_env_CC_set=${CC+set}
757 < ac_env_CC_value=$CC
758 < ac_cv_env_CC_set=${CC+set}
759 < ac_cv_env_CC_value=$CC
760 < ac_env_CFLAGS_set=${CFLAGS+set}
761 < ac_env_CFLAGS_value=$CFLAGS
762 < ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 < ac_cv_env_CFLAGS_value=$CFLAGS
756 > ac_env_CXX_set=${CXX+set}
757 > ac_env_CXX_value=$CXX
758 > ac_cv_env_CXX_set=${CXX+set}
759 > ac_cv_env_CXX_value=$CXX
760 > ac_env_CXXFLAGS_set=${CXXFLAGS+set}
761 > ac_env_CXXFLAGS_value=$CXXFLAGS
762 > ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763 > ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764   ac_env_LDFLAGS_set=${LDFLAGS+set}
765   ac_env_LDFLAGS_value=$LDFLAGS
766   ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
# Line 769 | Line 769 | ac_env_CXX_set=${CXX+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_CXX_set=${CXX+set}
773 < ac_env_CXX_value=$CXX
774 < ac_cv_env_CXX_set=${CXX+set}
775 < ac_cv_env_CXX_value=$CXX
776 < ac_env_CXXFLAGS_set=${CXXFLAGS+set}
777 < ac_env_CXXFLAGS_value=$CXXFLAGS
778 < ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
779 < ac_cv_env_CXXFLAGS_value=$CXXFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 ac_env_F90_set=${F90+set}
785 ac_env_F90_value=$F90
786 ac_cv_env_F90_set=${F90+set}
787 ac_cv_env_F90_value=$F90
788 ac_env_F90FLAGS_set=${F90FLAGS+set}
789 ac_env_F90FLAGS_value=$F90FLAGS
790 ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874 +  --enable-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
892  
893   Some influential environment variables:
894 <  CC          C compiler command
895 <  CFLAGS      C compiler flags
894 >  CXX         C++ compiler command
895 >  CXXFLAGS    C++ compiler flags
896    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
897                nonstandard directory <lib dir>
898    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
899                headers in a nonstandard directory <include dir>
900 <  CXX         C++ compiler command
901 <  CXXFLAGS    C++ compiler flags
900 >  CC          C compiler command
901 >  CFLAGS      C compiler flags
902 >  FC          Fortran compiler command
903 >  FCFLAGS     Fortran compiler flags
904    CPP         C preprocessor
900  F90         Fortran 90 compiler command
901  F90FLAGS    Fortran 90 compiler flags
905    CXXCPP      C++ preprocessor
906  
907   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1003 | OOPSE configure 2.0
1003   test -n "$ac_init_help" && exit 0
1004   if $ac_init_version; then
1005    cat <<\_ACEOF
1006 < OOPSE configure 2.0
1006 > OOPSE configure 3.0
1007   generated by GNU Autoconf 2.59
1008  
1009   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1017 | It was created by OOPSE $as_me 2.0, which was
1017   This file contains any messages produced by compilers while
1018   running configure, to aid debugging if configure makes a mistake.
1019  
1020 < It was created by OOPSE $as_me 2.0, which was
1020 > It was created by OOPSE $as_me 3.0, which was
1021   generated by GNU Autoconf 2.59.  Invocation command line was
1022  
1023    $ $0 $@
# Line 1376 | Line 1379 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1379   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1380  
1381  
1382 < # 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).
1382 >          ac_config_headers="$ac_config_headers src/config.h"
1383  
1384  
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
1385  
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
1386  
1387  
1388  
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
1389  
1390  
1391  
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1392  
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1393  
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1394  
1395  
1396  
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1397  
1398  
1399  
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1400  
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1401  
1402  
1403  
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1404  
1405  
1406  
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1407  
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1408  
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1541
1542
1543
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1546
1547
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1550
1551
1552
1553 # ------------------------ #
1554 # 2c. Fortran 95 sources.  #
1555 # ------------------------ #
1556
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1559
1560
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1563
1564
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1567
1568
1569
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1573
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1409  
1410  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1411  
1412  
1413  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1414  
1415  
1416  
1592 # AC_PROG_F90([COMPILERS...])
1593 # ---------------------------
1594 # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 # for.
1596 #
1597 # Compilers are ordered by
1598 #  1. F90, F95
1599 #  2. Good/tested native compilers, bad/untested native compilers
1600 #
1601 # pgf90 is the Portland Group F90 compilers.
1602 # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1603 # lf95 is the Lahey-Fujitsu compiler.
1604 # epcf90 is the "Edinburgh Portable Compiler" F90.
1605 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1606 # AC_PROG_F90
1417  
1418  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1419  
1420  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1421  
1422  
1423  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1424  
1425  
1426  
1627 # AC_PROG_F95([COMPILERS...])
1628 # ---------------------------
1629 # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 # for.
1427   #
1632 # Compilers are ordered by
1633 #  1. Good/tested native compilers, bad/untested native compilers
1428   #
1429 < # 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
1429 > #
1430  
1431  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1432  
1433  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1434  
1435  
1436 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1437 < # -------------------------------------------------
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 < # --------------
1436 > # AC_F90_MODULE_NAMES
1437 > # -------------------
1438   #
1439 < # 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 < # ----------------------
1439 > # Figure out how the Fortran 90 compiler constructs module file names
1440   #
1441 < # 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
1441 > # AC_F90_MODULE_NAMES
1442  
1443  
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
1444  
1717 # The replacement is empty.
1718
1719
1720
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
1728
1729
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
1445  
1446  
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1447  
1448  
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
1449  
1450  
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
1451  
1452  
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
1453  
1454  
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
1455  
1809 # The replacement is empty.
1456  
1457  
1458  
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
1459  
1460  
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
1461  
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
1462  
1463  
1464  
# Line 1885 | Line 1512 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1512  
1513  
1514  
1888 #
1889 #
1890 #
1515  
1516  
1517  
# Line 1896 | Line 1520 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1520  
1521  
1522  
1899 # set program name
1900 PROGNAME="oopse"
1523  
1524  
1903 # there are two ways to do debugging.  One with the --enable-debug flag
1904 # and one using the DEBUG environment variable
1525  
1906 debug=0
1907 # Check whether --enable-debug or --disable-debug was given.
1908 if test "${enable_debug+set}" = set; then
1909  enableval="$enable_debug"
1910  debug=1
1911 fi;
1912 if test "${DEBUG}"; then
1526  
1914 cat >>confdefs.h <<\_ACEOF
1915 #define debug 1
1916 _ACEOF
1527  
1918  msg="$msg, debug mode"
1919 fi
1528  
1529  
1530   # who am i
# Line 1977 | Line 1585 | ac_ext=c
1585  
1586  
1587  
1588 < ac_ext=c
1589 < ac_cpp='$CPP $CPPFLAGS'
1590 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1591 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1592 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1588 > # set program name
1589 > PROGNAME="oopse"
1590 >
1591 >
1592 >
1593 >
1594 > OBJEXT=".$OBJEXT"
1595 >
1596 > OOPSE=oopse
1597 >
1598 > if test "x${prefix}" = "xNONE"
1599 > then
1600 >  OOPSE_HOME=${ac_default_prefix}/oopse
1601 > else
1602 >  OOPSE_HOME=${prefix}/oopse
1603 > fi
1604 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1605 > if test "${enable_oopse_home+set}" = set; then
1606 >  enableval="$enable_oopse_home"
1607 >  OOPSE_HOME="${enableval}"
1608 > fi;
1609 >
1610 > # there are two ways to do debugging.  One with the --enable-debug flag
1611 > # and one using the DEBUG environment variable
1612 >
1613 > debug=0
1614 > # Check whether --enable-debug or --disable-debug was given.
1615 > if test "${enable_debug+set}" = set; then
1616 >  enableval="$enable_debug"
1617 >  debug=1
1618 > fi;
1619 > if test "${DEBUG}"; then
1620 >
1621 > cat >>confdefs.h <<\_ACEOF
1622 > #define debug 1
1623 > _ACEOF
1624 >
1625 >  msg="$msg, debug mode"
1626 > fi
1627 >
1628 >
1629 > # Check whether --enable-single or --disable-single was given.
1630 > if test "${enable_single+set}" = set; then
1631 >  enableval="$enable_single"
1632 >  ok=$enableval
1633 > else
1634 >  ok=no
1635 > fi;
1636 > # Check whether --enable-float or --disable-float was given.
1637 > if test "${enable_float+set}" = set; then
1638 >  enableval="$enable_float"
1639 >  ok=$enableval
1640 > fi;
1641 > if test "$ok" = "yes"; then
1642 >
1643 > cat >>confdefs.h <<\_ACEOF
1644 > #define SINGLE_PRECISION 1
1645 > _ACEOF
1646 >
1647 >        USE_SINGLE_PRECISION=yes
1648 >
1649 > fi
1650 >
1651 > # Checks for programs.
1652 > ac_ext=cc
1653 > ac_cpp='$CXXCPP $CPPFLAGS'
1654 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1655 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1656 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1657   if test -n "$ac_tool_prefix"; then
1658 <  for ac_prog in pathcc icc xlc gcc cc
1658 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1659    do
1660      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1661   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1662   echo "$as_me:$LINENO: checking for $ac_word" >&5
1663   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1664 < if test "${ac_cv_prog_CC+set}" = set; then
1664 > if test "${ac_cv_prog_CXX+set}" = set; then
1665    echo $ECHO_N "(cached) $ECHO_C" >&6
1666   else
1667 <  if test -n "$CC"; then
1668 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1667 >  if test -n "$CXX"; then
1668 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1669   else
1670   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1671   for as_dir in $PATH
# Line 2002 | Line 1674 | do
1674    test -z "$as_dir" && as_dir=.
1675    for ac_exec_ext in '' $ac_executable_extensions; do
1676    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1677 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1677 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1678      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1679      break 2
1680    fi
# Line 2011 | Line 1683 | CC=$ac_cv_prog_CC
1683  
1684   fi
1685   fi
1686 < CC=$ac_cv_prog_CC
1687 < if test -n "$CC"; then
1688 <  echo "$as_me:$LINENO: result: $CC" >&5
1689 < echo "${ECHO_T}$CC" >&6
1686 > CXX=$ac_cv_prog_CXX
1687 > if test -n "$CXX"; then
1688 >  echo "$as_me:$LINENO: result: $CXX" >&5
1689 > echo "${ECHO_T}$CXX" >&6
1690   else
1691    echo "$as_me:$LINENO: result: no" >&5
1692   echo "${ECHO_T}no" >&6
1693   fi
1694  
1695 <    test -n "$CC" && break
1695 >    test -n "$CXX" && break
1696    done
1697   fi
1698 < if test -z "$CC"; then
1699 <  ac_ct_CC=$CC
1700 <  for ac_prog in pathcc icc xlc gcc cc
1698 > if test -z "$CXX"; then
1699 >  ac_ct_CXX=$CXX
1700 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1701   do
1702    # Extract the first word of "$ac_prog", so it can be a program name with args.
1703   set dummy $ac_prog; ac_word=$2
1704   echo "$as_me:$LINENO: checking for $ac_word" >&5
1705   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1706 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1706 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1707    echo $ECHO_N "(cached) $ECHO_C" >&6
1708   else
1709 <  if test -n "$ac_ct_CC"; then
1710 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1709 >  if test -n "$ac_ct_CXX"; then
1710 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1711   else
1712   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1713   for as_dir in $PATH
# Line 2044 | Line 1716 | do
1716    test -z "$as_dir" && as_dir=.
1717    for ac_exec_ext in '' $ac_executable_extensions; do
1718    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1719 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1719 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1720      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1721      break 2
1722    fi
# Line 2053 | Line 1725 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1725  
1726   fi
1727   fi
1728 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1729 < if test -n "$ac_ct_CC"; then
1730 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1731 < echo "${ECHO_T}$ac_ct_CC" >&6
1728 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1729 > if test -n "$ac_ct_CXX"; then
1730 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1731 > echo "${ECHO_T}$ac_ct_CXX" >&6
1732   else
1733    echo "$as_me:$LINENO: result: no" >&5
1734   echo "${ECHO_T}no" >&6
1735   fi
1736  
1737 <  test -n "$ac_ct_CC" && break
1737 >  test -n "$ac_ct_CXX" && break
1738   done
1739 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1740  
1741 <  CC=$ac_ct_CC
1741 >  CXX=$ac_ct_CXX
1742   fi
1743  
1744  
2072 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2073 See \`config.log' for more details." >&5
2074 echo "$as_me: error: no acceptable C compiler found in \$PATH
2075 See \`config.log' for more details." >&2;}
2076   { (exit 1); exit 1; }; }
2077
1745   # Provide some information about the compiler.
1746   echo "$as_me:$LINENO:" \
1747 <     "checking for C compiler version" >&5
1747 >     "checking for C++ compiler version" >&5
1748   ac_compiler=`set X $ac_compile; echo $2`
1749   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1750    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2115 | Line 1782 | echo "$as_me:$LINENO: checking for C compiler default
1782   # Try to create an executable without -o first, disregard a.out.
1783   # It will help us diagnose broken compilers, and finding out an intuition
1784   # of exeext.
1785 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1786 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1785 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1786 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1787   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1788   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1789    (eval $ac_link_default) 2>&5
# Line 2159 | Line 1826 | sed 's/^/| /' conftest.$ac_ext >&5
1826    echo "$as_me: failed program was:" >&5
1827   sed 's/^/| /' conftest.$ac_ext >&5
1828  
1829 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1829 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1830   See \`config.log' for more details." >&5
1831 < echo "$as_me: error: C compiler cannot create executables
1831 > echo "$as_me: error: C++ compiler cannot create executables
1832   See \`config.log' for more details." >&2;}
1833     { (exit 77); exit 77; }; }
1834   fi
# Line 2172 | Line 1839 | echo "$as_me:$LINENO: checking whether the C compiler
1839  
1840   # Check the compiler produces executables we can run.  If not, either
1841   # the compiler is broken, or we cross compile.
1842 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1843 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1842 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1843 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1844   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1845   # If not cross compiling, check that we can run a simple program.
1846   if test "$cross_compiling" != yes; then
# Line 2188 | Line 1855 | if test "$cross_compiling" != yes; then
1855      if test "$cross_compiling" = maybe; then
1856          cross_compiling=yes
1857      else
1858 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1858 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1859   If you meant to cross compile, use \`--host'.
1860   See \`config.log' for more details." >&5
1861 < echo "$as_me: error: cannot run C compiled programs.
1861 > echo "$as_me: error: cannot run C++ compiled programs.
1862   If you meant to cross compile, use \`--host'.
1863   See \`config.log' for more details." >&2;}
1864     { (exit 1); exit 1; }; }
# Line 2296 | Line 1963 | echo "$as_me:$LINENO: checking whether we are using th
1963   echo "${ECHO_T}$ac_cv_objext" >&6
1964   OBJEXT=$ac_cv_objext
1965   ac_objext=$OBJEXT
1966 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1967 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1968 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1969 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1970 + else
1971 +  cat >conftest.$ac_ext <<_ACEOF
1972 + /* confdefs.h.  */
1973 + _ACEOF
1974 + cat confdefs.h >>conftest.$ac_ext
1975 + cat >>conftest.$ac_ext <<_ACEOF
1976 + /* end confdefs.h.  */
1977 +
1978 + int
1979 + main ()
1980 + {
1981 + #ifndef __GNUC__
1982 +       choke me
1983 + #endif
1984 +
1985 +  ;
1986 +  return 0;
1987 + }
1988 + _ACEOF
1989 + rm -f conftest.$ac_objext
1990 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1991 +  (eval $ac_compile) 2>conftest.er1
1992 +  ac_status=$?
1993 +  grep -v '^ *+' conftest.er1 >conftest.err
1994 +  rm -f conftest.er1
1995 +  cat conftest.err >&5
1996 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1997 +  (exit $ac_status); } &&
1998 +         { ac_try='test -z "$ac_cxx_werror_flag"
1999 +                         || test ! -s conftest.err'
2000 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2001 +  (eval $ac_try) 2>&5
2002 +  ac_status=$?
2003 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2004 +  (exit $ac_status); }; } &&
2005 +         { ac_try='test -s conftest.$ac_objext'
2006 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2007 +  (eval $ac_try) 2>&5
2008 +  ac_status=$?
2009 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2010 +  (exit $ac_status); }; }; then
2011 +  ac_compiler_gnu=yes
2012 + else
2013 +  echo "$as_me: failed program was:" >&5
2014 + sed 's/^/| /' conftest.$ac_ext >&5
2015 +
2016 + ac_compiler_gnu=no
2017 + fi
2018 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2019 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2020 +
2021 + fi
2022 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2023 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2024 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2025 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2026 + ac_save_CXXFLAGS=$CXXFLAGS
2027 + CXXFLAGS="-g"
2028 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2029 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2030 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2031 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2032 + else
2033 +  cat >conftest.$ac_ext <<_ACEOF
2034 + /* confdefs.h.  */
2035 + _ACEOF
2036 + cat confdefs.h >>conftest.$ac_ext
2037 + cat >>conftest.$ac_ext <<_ACEOF
2038 + /* end confdefs.h.  */
2039 +
2040 + int
2041 + main ()
2042 + {
2043 +
2044 +  ;
2045 +  return 0;
2046 + }
2047 + _ACEOF
2048 + rm -f conftest.$ac_objext
2049 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2050 +  (eval $ac_compile) 2>conftest.er1
2051 +  ac_status=$?
2052 +  grep -v '^ *+' conftest.er1 >conftest.err
2053 +  rm -f conftest.er1
2054 +  cat conftest.err >&5
2055 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2056 +  (exit $ac_status); } &&
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
2061 +  ac_status=$?
2062 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2063 +  (exit $ac_status); }; } &&
2064 +         { ac_try='test -s conftest.$ac_objext'
2065 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2066 +  (eval $ac_try) 2>&5
2067 +  ac_status=$?
2068 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2069 +  (exit $ac_status); }; }; then
2070 +  ac_cv_prog_cxx_g=yes
2071 + else
2072 +  echo "$as_me: failed program was:" >&5
2073 + sed 's/^/| /' conftest.$ac_ext >&5
2074 +
2075 + ac_cv_prog_cxx_g=no
2076 + fi
2077 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2078 + fi
2079 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2080 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2081 + if test "$ac_test_CXXFLAGS" = set; then
2082 +  CXXFLAGS=$ac_save_CXXFLAGS
2083 + elif test $ac_cv_prog_cxx_g = yes; then
2084 +  if test "$GXX" = yes; then
2085 +    CXXFLAGS="-g -O2"
2086 +  else
2087 +    CXXFLAGS="-g"
2088 +  fi
2089 + else
2090 +  if test "$GXX" = yes; then
2091 +    CXXFLAGS="-O2"
2092 +  else
2093 +    CXXFLAGS=
2094 +  fi
2095 + fi
2096 + for ac_declaration in \
2097 +   '' \
2098 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2099 +   'extern "C" void std::exit (int); using std::exit;' \
2100 +   'extern "C" void exit (int) throw ();' \
2101 +   'extern "C" void exit (int);' \
2102 +   'void exit (int);'
2103 + do
2104 +  cat >conftest.$ac_ext <<_ACEOF
2105 + /* confdefs.h.  */
2106 + _ACEOF
2107 + cat confdefs.h >>conftest.$ac_ext
2108 + cat >>conftest.$ac_ext <<_ACEOF
2109 + /* end confdefs.h.  */
2110 + $ac_declaration
2111 + #include <stdlib.h>
2112 + int
2113 + main ()
2114 + {
2115 + exit (42);
2116 +  ;
2117 +  return 0;
2118 + }
2119 + _ACEOF
2120 + rm -f conftest.$ac_objext
2121 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2122 +  (eval $ac_compile) 2>conftest.er1
2123 +  ac_status=$?
2124 +  grep -v '^ *+' conftest.er1 >conftest.err
2125 +  rm -f conftest.er1
2126 +  cat conftest.err >&5
2127 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2128 +  (exit $ac_status); } &&
2129 +         { ac_try='test -z "$ac_cxx_werror_flag"
2130 +                         || test ! -s conftest.err'
2131 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2132 +  (eval $ac_try) 2>&5
2133 +  ac_status=$?
2134 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2135 +  (exit $ac_status); }; } &&
2136 +         { ac_try='test -s conftest.$ac_objext'
2137 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2138 +  (eval $ac_try) 2>&5
2139 +  ac_status=$?
2140 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2141 +  (exit $ac_status); }; }; then
2142 +  :
2143 + else
2144 +  echo "$as_me: failed program was:" >&5
2145 + sed 's/^/| /' conftest.$ac_ext >&5
2146 +
2147 + continue
2148 + fi
2149 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2150 +  cat >conftest.$ac_ext <<_ACEOF
2151 + /* confdefs.h.  */
2152 + _ACEOF
2153 + cat confdefs.h >>conftest.$ac_ext
2154 + cat >>conftest.$ac_ext <<_ACEOF
2155 + /* end confdefs.h.  */
2156 + $ac_declaration
2157 + int
2158 + main ()
2159 + {
2160 + exit (42);
2161 +  ;
2162 +  return 0;
2163 + }
2164 + _ACEOF
2165 + rm -f conftest.$ac_objext
2166 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2167 +  (eval $ac_compile) 2>conftest.er1
2168 +  ac_status=$?
2169 +  grep -v '^ *+' conftest.er1 >conftest.err
2170 +  rm -f conftest.er1
2171 +  cat conftest.err >&5
2172 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2173 +  (exit $ac_status); } &&
2174 +         { ac_try='test -z "$ac_cxx_werror_flag"
2175 +                         || test ! -s conftest.err'
2176 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2177 +  (eval $ac_try) 2>&5
2178 +  ac_status=$?
2179 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2180 +  (exit $ac_status); }; } &&
2181 +         { ac_try='test -s conftest.$ac_objext'
2182 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2183 +  (eval $ac_try) 2>&5
2184 +  ac_status=$?
2185 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2186 +  (exit $ac_status); }; }; then
2187 +  break
2188 + else
2189 +  echo "$as_me: failed program was:" >&5
2190 + sed 's/^/| /' conftest.$ac_ext >&5
2191 +
2192 + fi
2193 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2194 + done
2195 + rm -f conftest*
2196 + if test -n "$ac_declaration"; then
2197 +  echo '#ifdef __cplusplus' >>confdefs.h
2198 +  echo $ac_declaration      >>confdefs.h
2199 +  echo '#endif'             >>confdefs.h
2200 + fi
2201 +
2202 + ac_ext=c
2203 + ac_cpp='$CPP $CPPFLAGS'
2204 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2205 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2206 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2207 +
2208 + ac_ext=c
2209 + ac_cpp='$CPP $CPPFLAGS'
2210 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2211 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2212 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2213 + if test -n "$ac_tool_prefix"; then
2214 +  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2215 +  do
2216 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2217 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2218 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2219 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2220 + if test "${ac_cv_prog_CC+set}" = set; then
2221 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2222 + else
2223 +  if test -n "$CC"; then
2224 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2225 + else
2226 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2227 + for as_dir in $PATH
2228 + do
2229 +  IFS=$as_save_IFS
2230 +  test -z "$as_dir" && as_dir=.
2231 +  for ac_exec_ext in '' $ac_executable_extensions; do
2232 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2233 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2234 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2235 +    break 2
2236 +  fi
2237 + done
2238 + done
2239 +
2240 + fi
2241 + fi
2242 + CC=$ac_cv_prog_CC
2243 + if test -n "$CC"; then
2244 +  echo "$as_me:$LINENO: result: $CC" >&5
2245 + echo "${ECHO_T}$CC" >&6
2246 + else
2247 +  echo "$as_me:$LINENO: result: no" >&5
2248 + echo "${ECHO_T}no" >&6
2249 + fi
2250 +
2251 +    test -n "$CC" && break
2252 +  done
2253 + fi
2254 + if test -z "$CC"; then
2255 +  ac_ct_CC=$CC
2256 +  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2257 + do
2258 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2259 + set dummy $ac_prog; ac_word=$2
2260 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2261 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2262 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2263 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2264 + else
2265 +  if test -n "$ac_ct_CC"; then
2266 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2267 + else
2268 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2269 + for as_dir in $PATH
2270 + do
2271 +  IFS=$as_save_IFS
2272 +  test -z "$as_dir" && as_dir=.
2273 +  for ac_exec_ext in '' $ac_executable_extensions; do
2274 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2275 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2276 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2277 +    break 2
2278 +  fi
2279 + done
2280 + done
2281 +
2282 + fi
2283 + fi
2284 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2285 + if test -n "$ac_ct_CC"; then
2286 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2287 + echo "${ECHO_T}$ac_ct_CC" >&6
2288 + else
2289 +  echo "$as_me:$LINENO: result: no" >&5
2290 + echo "${ECHO_T}no" >&6
2291 + fi
2292 +
2293 +  test -n "$ac_ct_CC" && break
2294 + done
2295 +
2296 +  CC=$ac_ct_CC
2297 + fi
2298 +
2299 +
2300 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2301 + See \`config.log' for more details." >&5
2302 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2303 + See \`config.log' for more details." >&2;}
2304 +   { (exit 1); exit 1; }; }
2305 +
2306 + # Provide some information about the compiler.
2307 + echo "$as_me:$LINENO:" \
2308 +     "checking for C compiler version" >&5
2309 + ac_compiler=`set X $ac_compile; echo $2`
2310 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2311 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2312 +  ac_status=$?
2313 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2314 +  (exit $ac_status); }
2315 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2316 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2317 +  ac_status=$?
2318 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2319 +  (exit $ac_status); }
2320 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2321 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2322 +  ac_status=$?
2323 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2324 +  (exit $ac_status); }
2325 +
2326   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2327   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2328   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2690 | Line 2717 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2717   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2718   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2719  
2720 <
2721 < ac_ext=cc
2722 < ac_cpp='$CXXCPP $CPPFLAGS'
2723 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2697 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2698 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2720 > ac_ext=${FC_SRCEXT-f}
2721 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2722 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2723 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2724   if test -n "$ac_tool_prefix"; then
2725 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2725 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2726    do
2727      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2728   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2729   echo "$as_me:$LINENO: checking for $ac_word" >&5
2730   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2731 < if test "${ac_cv_prog_CXX+set}" = set; then
2731 > if test "${ac_cv_prog_FC+set}" = set; then
2732    echo $ECHO_N "(cached) $ECHO_C" >&6
2733   else
2734 <  if test -n "$CXX"; then
2735 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2734 >  if test -n "$FC"; then
2735 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2736   else
2737   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2738   for as_dir in $PATH
# Line 2716 | Line 2741 | do
2741    test -z "$as_dir" && as_dir=.
2742    for ac_exec_ext in '' $ac_executable_extensions; do
2743    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2744 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2744 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2745      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2746      break 2
2747    fi
# Line 2725 | Line 2750 | CXX=$ac_cv_prog_CXX
2750  
2751   fi
2752   fi
2753 < CXX=$ac_cv_prog_CXX
2754 < if test -n "$CXX"; then
2755 <  echo "$as_me:$LINENO: result: $CXX" >&5
2756 < echo "${ECHO_T}$CXX" >&6
2753 > FC=$ac_cv_prog_FC
2754 > if test -n "$FC"; then
2755 >  echo "$as_me:$LINENO: result: $FC" >&5
2756 > echo "${ECHO_T}$FC" >&6
2757   else
2758    echo "$as_me:$LINENO: result: no" >&5
2759   echo "${ECHO_T}no" >&6
2760   fi
2761  
2762 <    test -n "$CXX" && break
2762 >    test -n "$FC" && break
2763    done
2764   fi
2765 < if test -z "$CXX"; then
2766 <  ac_ct_CXX=$CXX
2767 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2765 > if test -z "$FC"; then
2766 >  ac_ct_FC=$FC
2767 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2768   do
2769    # Extract the first word of "$ac_prog", so it can be a program name with args.
2770   set dummy $ac_prog; ac_word=$2
2771   echo "$as_me:$LINENO: checking for $ac_word" >&5
2772   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2773 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2773 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2774    echo $ECHO_N "(cached) $ECHO_C" >&6
2775   else
2776 <  if test -n "$ac_ct_CXX"; then
2777 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2776 >  if test -n "$ac_ct_FC"; then
2777 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2778   else
2779   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2780   for as_dir in $PATH
# Line 2758 | Line 2783 | do
2783    test -z "$as_dir" && as_dir=.
2784    for ac_exec_ext in '' $ac_executable_extensions; do
2785    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2786 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2786 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2787      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2788      break 2
2789    fi
# Line 2767 | Line 2792 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2792  
2793   fi
2794   fi
2795 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2796 < if test -n "$ac_ct_CXX"; then
2797 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2798 < echo "${ECHO_T}$ac_ct_CXX" >&6
2795 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2796 > if test -n "$ac_ct_FC"; then
2797 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2798 > echo "${ECHO_T}$ac_ct_FC" >&6
2799   else
2800    echo "$as_me:$LINENO: result: no" >&5
2801   echo "${ECHO_T}no" >&6
2802   fi
2803  
2804 <  test -n "$ac_ct_CXX" && break
2804 >  test -n "$ac_ct_FC" && break
2805   done
2781 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2806  
2807 <  CXX=$ac_ct_CXX
2807 >  FC=$ac_ct_FC
2808   fi
2809  
2810  
2811   # Provide some information about the compiler.
2812 < echo "$as_me:$LINENO:" \
2813 <     "checking for C++ compiler version" >&5
2812 > echo "$as_me:2812:" \
2813 >     "checking for Fortran compiler version" >&5
2814   ac_compiler=`set X $ac_compile; echo $2`
2815   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2816    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2803 | Line 2827 | ac_compiler=`set X $ac_compile; echo $2`
2827    ac_status=$?
2828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2829    (exit $ac_status); }
2830 + rm -f a.out
2831  
2832 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2833 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2834 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2832 > # If we don't use `.F' as extension, the preprocessor is not run on the
2833 > # input file.  (Note that this only needs to work for GNU compilers.)
2834 > ac_save_ext=$ac_ext
2835 > ac_ext=F
2836 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2837 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2838 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2839    echo $ECHO_N "(cached) $ECHO_C" >&6
2840   else
2841    cat >conftest.$ac_ext <<_ACEOF
2842 < /* confdefs.h.  */
2814 < _ACEOF
2815 < cat confdefs.h >>conftest.$ac_ext
2816 < cat >>conftest.$ac_ext <<_ACEOF
2817 < /* end confdefs.h.  */
2818 <
2819 < int
2820 < main ()
2821 < {
2842 >      program main
2843   #ifndef __GNUC__
2844         choke me
2845   #endif
2846  
2847 <  ;
2827 <  return 0;
2828 < }
2847 >      end
2848   _ACEOF
2849   rm -f conftest.$ac_objext
2850   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2836 | Line 2855 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2855    cat conftest.err >&5
2856    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2857    (exit $ac_status); } &&
2858 <         { ac_try='test -z "$ac_cxx_werror_flag"
2858 >         { ac_try='test -z "$ac_fc_werror_flag"
2859                           || test ! -s conftest.err'
2860    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2861    (eval $ac_try) 2>&5
# Line 2857 | Line 2876 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2876   ac_compiler_gnu=no
2877   fi
2878   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2879 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2879 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2880  
2881   fi
2882 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2883 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2884 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2885 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2886 < ac_save_CXXFLAGS=$CXXFLAGS
2887 < CXXFLAGS="-g"
2888 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2889 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2890 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2882 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2883 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2884 > ac_ext=$ac_save_ext
2885 > ac_test_FFLAGS=${FCFLAGS+set}
2886 > ac_save_FFLAGS=$FCFLAGS
2887 > FCFLAGS=
2888 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2889 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2890 > if test "${ac_cv_prog_fc_g+set}" = set; then
2891    echo $ECHO_N "(cached) $ECHO_C" >&6
2892   else
2893 <  cat >conftest.$ac_ext <<_ACEOF
2894 < /* confdefs.h.  */
2895 < _ACEOF
2877 < cat confdefs.h >>conftest.$ac_ext
2878 < cat >>conftest.$ac_ext <<_ACEOF
2879 < /* end confdefs.h.  */
2893 >  FCFLAGS=-g
2894 > cat >conftest.$ac_ext <<_ACEOF
2895 >      program main
2896  
2897 < int
2882 < main ()
2883 < {
2884 <
2885 <  ;
2886 <  return 0;
2887 < }
2897 >      end
2898   _ACEOF
2899   rm -f conftest.$ac_objext
2900   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2895 | Line 2905 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2905    cat conftest.err >&5
2906    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2907    (exit $ac_status); } &&
2908 <         { ac_try='test -z "$ac_cxx_werror_flag"
2908 >         { ac_try='test -z "$ac_fc_werror_flag"
2909                           || test ! -s conftest.err'
2910    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2911    (eval $ac_try) 2>&5
# Line 2908 | Line 2918 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2918    ac_status=$?
2919    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920    (exit $ac_status); }; }; then
2921 <  ac_cv_prog_cxx_g=yes
2921 >  ac_cv_prog_fc_g=yes
2922   else
2923    echo "$as_me: failed program was:" >&5
2924   sed 's/^/| /' conftest.$ac_ext >&5
2925  
2926 < ac_cv_prog_cxx_g=no
2926 > ac_cv_prog_fc_g=no
2927   fi
2928   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2929 +
2930   fi
2931 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2932 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2933 < if test "$ac_test_CXXFLAGS" = set; then
2934 <  CXXFLAGS=$ac_save_CXXFLAGS
2935 < elif test $ac_cv_prog_cxx_g = yes; then
2936 <  if test "$GXX" = yes; then
2937 <    CXXFLAGS="-g -O2"
2931 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2932 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2933 > if test "$ac_test_FFLAGS" = set; then
2934 >  FCFLAGS=$ac_save_FFLAGS
2935 > elif test $ac_cv_prog_fc_g = yes; then
2936 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2937 >    FCFLAGS="-g -O2"
2938    else
2939 <    CXXFLAGS="-g"
2939 >    FCFLAGS="-g"
2940    fi
2941   else
2942 <  if test "$GXX" = yes; then
2943 <    CXXFLAGS="-O2"
2942 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2943 >    FCFLAGS="-O2"
2944    else
2945 <    CXXFLAGS=
2945 >    FCFLAGS=
2946    fi
2936 fi
2937 for ac_declaration in \
2938   '' \
2939   'extern "C" void std::exit (int) throw (); using std::exit;' \
2940   'extern "C" void std::exit (int); using std::exit;' \
2941   'extern "C" void exit (int) throw ();' \
2942   'extern "C" void exit (int);' \
2943   'void exit (int);'
2944 do
2945  cat >conftest.$ac_ext <<_ACEOF
2946 /* confdefs.h.  */
2947 _ACEOF
2948 cat confdefs.h >>conftest.$ac_ext
2949 cat >>conftest.$ac_ext <<_ACEOF
2950 /* end confdefs.h.  */
2951 $ac_declaration
2952 #include <stdlib.h>
2953 int
2954 main ()
2955 {
2956 exit (42);
2957  ;
2958  return 0;
2959 }
2960 _ACEOF
2961 rm -f conftest.$ac_objext
2962 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2963  (eval $ac_compile) 2>conftest.er1
2964  ac_status=$?
2965  grep -v '^ *+' conftest.er1 >conftest.err
2966  rm -f conftest.er1
2967  cat conftest.err >&5
2968  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2969  (exit $ac_status); } &&
2970         { ac_try='test -z "$ac_cxx_werror_flag"
2971                         || test ! -s conftest.err'
2972  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2973  (eval $ac_try) 2>&5
2974  ac_status=$?
2975  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2976  (exit $ac_status); }; } &&
2977         { ac_try='test -s conftest.$ac_objext'
2978  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2979  (eval $ac_try) 2>&5
2980  ac_status=$?
2981  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2982  (exit $ac_status); }; }; then
2983  :
2984 else
2985  echo "$as_me: failed program was:" >&5
2986 sed 's/^/| /' conftest.$ac_ext >&5
2987
2988 continue
2947   fi
2990 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2991  cat >conftest.$ac_ext <<_ACEOF
2992 /* confdefs.h.  */
2993 _ACEOF
2994 cat confdefs.h >>conftest.$ac_ext
2995 cat >>conftest.$ac_ext <<_ACEOF
2996 /* end confdefs.h.  */
2997 $ac_declaration
2998 int
2999 main ()
3000 {
3001 exit (42);
3002  ;
3003  return 0;
3004 }
3005 _ACEOF
3006 rm -f conftest.$ac_objext
3007 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3008  (eval $ac_compile) 2>conftest.er1
3009  ac_status=$?
3010  grep -v '^ *+' conftest.er1 >conftest.err
3011  rm -f conftest.er1
3012  cat conftest.err >&5
3013  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3014  (exit $ac_status); } &&
3015         { ac_try='test -z "$ac_cxx_werror_flag"
3016                         || test ! -s conftest.err'
3017  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3018  (eval $ac_try) 2>&5
3019  ac_status=$?
3020  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3021  (exit $ac_status); }; } &&
3022         { ac_try='test -s conftest.$ac_objext'
3023  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3024  (eval $ac_try) 2>&5
3025  ac_status=$?
3026  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3027  (exit $ac_status); }; }; then
3028  break
3029 else
3030  echo "$as_me: failed program was:" >&5
3031 sed 's/^/| /' conftest.$ac_ext >&5
3032
3033 fi
3034 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3035 done
3036 rm -f conftest*
3037 if test -n "$ac_declaration"; then
3038  echo '#ifdef __cplusplus' >>confdefs.h
3039  echo $ac_declaration      >>confdefs.h
3040  echo '#endif'             >>confdefs.h
3041 fi
2948  
2949   ac_ext=c
2950   ac_cpp='$CPP $CPPFLAGS'
# Line 3046 | Line 2952 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2952   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2953   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2954  
3049
2955   ac_ext=c
2956   ac_cpp='$CPP $CPPFLAGS'
2957   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 3281 | Line 3186 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3186   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3187   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3188  
3284
3189   echo "$as_me:$LINENO: checking for egrep" >&5
3190   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3191   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3297 | Line 3201 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3201   EGREP=$ac_cv_prog_egrep
3202  
3203  
3204 + echo "$as_me:$LINENO: checking whether ln -s works" >&5
3205 + echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3206 + LN_S=$as_ln_s
3207 + if test "$LN_S" = "ln -s"; then
3208 +  echo "$as_me:$LINENO: result: yes" >&5
3209 + echo "${ECHO_T}yes" >&6
3210 + else
3211 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3212 + echo "${ECHO_T}no, using $LN_S" >&6
3213 + fi
3214  
3215 < OOPSE_TEMPLATE_FLAGS=""
3216 < if test $ac_cv_cxx_compiler_gnu = no; then
3217 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3218 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3219 <  echo 'void f(){}' > conftest.cc
3220 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3221 <    echo "$as_me:$LINENO: result: yes" >&5
3215 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3216 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3217 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3218 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3219 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3220 > else
3221 >  cat >conftest.make <<\_ACEOF
3222 > all:
3223 >        @echo 'ac_maketemp="$(MAKE)"'
3224 > _ACEOF
3225 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3226 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3227 > if test -n "$ac_maketemp"; then
3228 >  eval ac_cv_prog_make_${ac_make}_set=yes
3229 > else
3230 >  eval ac_cv_prog_make_${ac_make}_set=no
3231 > fi
3232 > rm -f conftest.make
3233 > fi
3234 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3235 >  echo "$as_me:$LINENO: result: yes" >&5
3236   echo "${ECHO_T}yes" >&6
3237 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3238 <  else
3239 <    echo "$as_me:$LINENO: result: no" >&5
3237 >  SET_MAKE=
3238 > else
3239 >  echo "$as_me:$LINENO: result: no" >&5
3240   echo "${ECHO_T}no" >&6
3241 +  SET_MAKE="MAKE=${MAKE-make}"
3242 + fi
3243 +
3244 + if test -n "$ac_tool_prefix"; then
3245 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3246 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3247 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3248 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3249 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3250 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3251 + else
3252 +  if test -n "$RANLIB"; then
3253 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3254 + else
3255 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3256 + for as_dir in $PATH
3257 + do
3258 +  IFS=$as_save_IFS
3259 +  test -z "$as_dir" && as_dir=.
3260 +  for ac_exec_ext in '' $ac_executable_extensions; do
3261 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3262 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3263 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3264 +    break 2
3265    fi
3266 <  rm -f conftest*
3267 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3268 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3269 <  echo 'void f(){}' > conftest.cc
3270 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3271 <    echo "$as_me:$LINENO: result: yes" >&5
3272 < echo "${ECHO_T}yes" >&6
3273 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3274 <  else
3275 <    echo "$as_me:$LINENO: result: no" >&5
3266 > done
3267 > done
3268 >
3269 > fi
3270 > fi
3271 > RANLIB=$ac_cv_prog_RANLIB
3272 > if test -n "$RANLIB"; then
3273 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3274 > echo "${ECHO_T}$RANLIB" >&6
3275 > else
3276 >  echo "$as_me:$LINENO: result: no" >&5
3277   echo "${ECHO_T}no" >&6
3278 + fi
3279 +
3280 + fi
3281 + if test -z "$ac_cv_prog_RANLIB"; then
3282 +  ac_ct_RANLIB=$RANLIB
3283 +  # Extract the first word of "ranlib", so it can be a program name with args.
3284 + set dummy ranlib; ac_word=$2
3285 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3286 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3287 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3288 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3289 + else
3290 +  if test -n "$ac_ct_RANLIB"; then
3291 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3292 + else
3293 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3294 + for as_dir in $PATH
3295 + do
3296 +  IFS=$as_save_IFS
3297 +  test -z "$as_dir" && as_dir=.
3298 +  for ac_exec_ext in '' $ac_executable_extensions; do
3299 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3300 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3301 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3302 +    break 2
3303    fi
3304 <  rm -f conftest*
3305 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3306 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3307 <  echo 'void f(){}' > conftest.cc
3308 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3309 <    echo "$as_me:$LINENO: result: yes" >&5
3310 < echo "${ECHO_T}yes" >&6
3311 <    OOPSE_TEMPLATE_FLAGS="-pto"
3312 <  else
3313 <    echo "$as_me:$LINENO: result: no" >&5
3304 > done
3305 > done
3306 >
3307 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3308 > fi
3309 > fi
3310 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3311 > if test -n "$ac_ct_RANLIB"; then
3312 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3313 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3314 > else
3315 >  echo "$as_me:$LINENO: result: no" >&5
3316   echo "${ECHO_T}no" >&6
3317 + fi
3318 +
3319 +  RANLIB=$ac_ct_RANLIB
3320 + else
3321 +  RANLIB="$ac_cv_prog_RANLIB"
3322 + fi
3323 +
3324 +
3325 +   # Extract the first word of "perl", so it can be a program name with args.
3326 + set dummy perl; ac_word=$2
3327 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3328 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3329 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3330 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3331 + else
3332 +  case $PERLINTERP in
3333 +  [\\/]* | ?:[\\/]*)
3334 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3335 +  ;;
3336 +  *)
3337 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3338 + for as_dir in $PATH
3339 + do
3340 +  IFS=$as_save_IFS
3341 +  test -z "$as_dir" && as_dir=.
3342 +  for ac_exec_ext in '' $ac_executable_extensions; do
3343 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3344 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3345 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3346 +    break 2
3347    fi
3348 <  rm -f conftest*
3349 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3340 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3341 <  echo 'void f(){}' > conftest.cc
3342 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3343 <    echo "$as_me:$LINENO: result: yes" >&5
3344 < echo "${ECHO_T}yes" >&6
3348 > done
3349 > done
3350  
3351 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3352 +  ;;
3353 + esac
3354 + fi
3355 + PERLINTERP=$ac_cv_path_PERLINTERP
3356  
3357 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3358 <  else
3359 <    echo "$as_me:$LINENO: result: no" >&5
3357 > if test -n "$PERLINTERP"; then
3358 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3359 > echo "${ECHO_T}$PERLINTERP" >&6
3360 > else
3361 >  echo "$as_me:$LINENO: result: no" >&5
3362   echo "${ECHO_T}no" >&6
3363 + fi
3364 +
3365 +   ac_cv_path_perlinterp="$PERLINTERP"
3366 +   _sHpB='#!'
3367 +
3368 +
3369 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3370 + if test "${with_perl_shebang+set}" = set; then
3371 +  withval="$with_perl_shebang"
3372 +  opt_perl_shebang="$withval"
3373 + else
3374 +                opt_perl_shebang="not_set"
3375 + fi;
3376 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3377 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3378 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3379 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3380 + else
3381 +   case "$opt_perl_shebang" in
3382 +                      not_set  ) ax_cv_opt_perl_shebang=''
3383 +                               ;;
3384 +                         *     )
3385 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3386 +                    esac
3387 +
3388 + fi
3389 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3390 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3391 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3392 +     then
3393 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3394 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3395 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3396 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3397 +
3398 + # Automatic detection of sharpbang formula starts here
3399 +     else
3400 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3401 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3402 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3403 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3404 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3405 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3406 + else
3407 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3408 +        if test "x$_somian_kspb_perl" == x
3409 +          then _somian_ksbp_warn_empty='durnit'
3410 +          else
3411 +          case "A$_somian_kspb_perl" in
3412 +                 A#!*perl* )
3413 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3414 +                        ;;
3415 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3416 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3417 +          esac
3418 +        fi
3419 +
3420 + fi
3421 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3422 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3423 + # The above prints Checking ... result message to user.
3424 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3425 +
3426 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3427 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3428 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3429 +    fi
3430 + # Inform user after printing result value
3431 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3432 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3433 + echo "$as_me: Maybe Not good -" >&6;}
3434 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3435 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3436 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3437 + echo "$as_me: OK Good result - " >&6;}
3438 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3439 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3440 +    fi
3441    fi
3442 +
3443 + # Find a good install program.  We prefer a C program (faster),
3444 + # so one script is as good as another.  But avoid the broken or
3445 + # incompatible versions:
3446 + # SysV /etc/install, /usr/sbin/install
3447 + # SunOS /usr/etc/install
3448 + # IRIX /sbin/install
3449 + # AIX /bin/install
3450 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3451 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3452 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3453 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3454 + # OS/2's system install, which has a completely different semantic
3455 + # ./install, which can be erroneously created by make from ./install.sh.
3456 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3457 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3458 + if test -z "$INSTALL"; then
3459 + if test "${ac_cv_path_install+set}" = set; then
3460 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3461 + else
3462 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3463 + for as_dir in $PATH
3464 + do
3465 +  IFS=$as_save_IFS
3466 +  test -z "$as_dir" && as_dir=.
3467 +  # Account for people who put trailing slashes in PATH elements.
3468 + case $as_dir/ in
3469 +  ./ | .// | /cC/* | \
3470 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3471 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3472 +  /usr/ucb/* ) ;;
3473 +  *)
3474 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3475 +    # Don't use installbsd from OSF since it installs stuff as root
3476 +    # by default.
3477 +    for ac_prog in ginstall scoinst install; do
3478 +      for ac_exec_ext in '' $ac_executable_extensions; do
3479 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3480 +          if test $ac_prog = install &&
3481 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3482 +            # AIX install.  It has an incompatible calling convention.
3483 +            :
3484 +          elif test $ac_prog = install &&
3485 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3486 +            # program-specific install script used by HP pwplus--don't use.
3487 +            :
3488 +          else
3489 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3490 +            break 3
3491 +          fi
3492 +        fi
3493 +      done
3494 +    done
3495 +    ;;
3496 + esac
3497 + done
3498 +
3499 +
3500   fi
3501 +  if test "${ac_cv_path_install+set}" = set; then
3502 +    INSTALL=$ac_cv_path_install
3503 +  else
3504 +    # As a last resort, use the slow shell script.  We don't cache a
3505 +    # path for INSTALL within a source directory, because that will
3506 +    # break other packages using the cache if that directory is
3507 +    # removed, or if the path is relative.
3508 +    INSTALL=$ac_install_sh
3509 +  fi
3510 + fi
3511 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3512 + echo "${ECHO_T}$INSTALL" >&6
3513  
3514 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3515 + # It thinks the first close brace ends the variable substitution.
3516 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3517  
3518 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3519  
3520 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3521  
3522 < ac_ext=f90
3523 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3524 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3525 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3526 < if test -n "$ac_tool_prefix"; then
3527 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3528 <  do
3364 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3365 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3522 > case "x$INSTALL" in
3523 >   x/*) ;;
3524 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3525 > esac
3526 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3527 > # Extract the first word of "ar", so it can be a program name with args.
3528 > set dummy ar; ac_word=$2
3529   echo "$as_me:$LINENO: checking for $ac_word" >&5
3530   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3531 < if test "${ac_cv_prog_F90+set}" = set; then
3531 > if test "${ac_cv_prog_AR+set}" = set; then
3532    echo $ECHO_N "(cached) $ECHO_C" >&6
3533   else
3534 <  if test -n "$F90"; then
3535 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3534 >  if test -n "$AR"; then
3535 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3536   else
3537   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3538   for as_dir in $PATH
# Line 3378 | Line 3541 | do
3541    test -z "$as_dir" && as_dir=.
3542    for ac_exec_ext in '' $ac_executable_extensions; do
3543    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3544 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3544 >    ac_cv_prog_AR="ar"
3545      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3546      break 2
3547    fi
3548   done
3549   done
3550  
3551 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3552   fi
3553   fi
3554 < F90=$ac_cv_prog_F90
3555 < if test -n "$F90"; then
3556 <  echo "$as_me:$LINENO: result: $F90" >&5
3557 < echo "${ECHO_T}$F90" >&6
3554 > AR=$ac_cv_prog_AR
3555 > if test -n "$AR"; then
3556 >  echo "$as_me:$LINENO: result: $AR" >&5
3557 > echo "${ECHO_T}$AR" >&6
3558   else
3559    echo "$as_me:$LINENO: result: no" >&5
3560   echo "${ECHO_T}no" >&6
3561   fi
3562  
3563 <    test -n "$F90" && break
3564 <  done
3563 > if test "$AR" = "NONE"; then
3564 >  cat >confcache <<\_ACEOF
3565 > # This file is a shell script that caches the results of configure
3566 > # tests run on this system so they can be shared between configure
3567 > # scripts and configure runs, see configure's option --config-cache.
3568 > # It is not useful on other systems.  If it contains results you don't
3569 > # want to keep, you may remove or edit it.
3570 > #
3571 > # config.status only pays attention to the cache file if you give it
3572 > # the --recheck option to rerun configure.
3573 > #
3574 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3575 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3576 > # following values.
3577 >
3578 > _ACEOF
3579 >
3580 > # The following way of writing the cache mishandles newlines in values,
3581 > # but we know of no workaround that is simple, portable, and efficient.
3582 > # So, don't put newlines in cache variables' values.
3583 > # Ultrix sh set writes to stderr and can't be redirected directly,
3584 > # and sets the high bit in the cache file unless we assign to the vars.
3585 > {
3586 >  (set) 2>&1 |
3587 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3588 >    *ac_space=\ *)
3589 >      # `set' does not quote correctly, so add quotes (double-quote
3590 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3591 >      sed -n \
3592 >        "s/'/'\\\\''/g;
3593 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3594 >      ;;
3595 >    *)
3596 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3597 >      sed -n \
3598 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3599 >      ;;
3600 >    esac;
3601 > } |
3602 >  sed '
3603 >     t clear
3604 >     : clear
3605 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3606 >     t end
3607 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3608 >     : end' >>confcache
3609 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3610 >  if test -w $cache_file; then
3611 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3612 >    cat confcache >$cache_file
3613 >  else
3614 >    echo "not updating unwritable cache $cache_file"
3615 >  fi
3616   fi
3617 < if test -z "$F90"; then
3618 <  ac_ct_F90=$F90
3619 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3620 < do
3621 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3407 < set dummy $ac_prog; ac_word=$2
3617 > rm -f confcache
3618 >  exit 1
3619 > fi
3620 > # Extract the first word of "ps", so it can be a program name with args.
3621 > set dummy ps; ac_word=$2
3622   echo "$as_me:$LINENO: checking for $ac_word" >&5
3623   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3624 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3624 > if test "${ac_cv_path_PS+set}" = set; then
3625    echo $ECHO_N "(cached) $ECHO_C" >&6
3626   else
3627 <  if test -n "$ac_ct_F90"; then
3628 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3629 < else
3630 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3627 >  case $PS in
3628 >  [\\/]* | ?:[\\/]*)
3629 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3630 >  ;;
3631 >  *)
3632 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3633   for as_dir in $PATH
3634   do
3635    IFS=$as_save_IFS
3636    test -z "$as_dir" && as_dir=.
3637    for ac_exec_ext in '' $ac_executable_extensions; do
3638    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3639 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3639 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3640      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3641      break 2
3642    fi
3643   done
3644   done
3645  
3646 +  ;;
3647 + esac
3648   fi
3649 < fi
3650 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3651 < if test -n "$ac_ct_F90"; then
3652 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3653 < echo "${ECHO_T}$ac_ct_F90" >&6
3649 > PS=$ac_cv_path_PS
3650 >
3651 > if test -n "$PS"; then
3652 >  echo "$as_me:$LINENO: result: $PS" >&5
3653 > echo "${ECHO_T}$PS" >&6
3654   else
3655    echo "$as_me:$LINENO: result: no" >&5
3656   echo "${ECHO_T}no" >&6
3657   fi
3658  
3659 <  test -n "$ac_ct_F90" && break
3660 < done
3659 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3660 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3661 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3662 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3663 > else
3664  
3665 <  F90=$ac_ct_F90
3665 >        if $PS ax -o rss > /dev/null 2>&1; then
3666 >                ac_cv_prog_ps_ax=yes
3667 >        else
3668 >                ac_cv_prog_ps_ax=no
3669 >        fi
3670 >        if $PS -ef -o rss > /dev/null 2>&1; then
3671 >                ac_cv_prog_ps_ef=yes
3672 >        else
3673 >                ac_cv_prog_ps_ef=no
3674 >        fi
3675 >        if test "$ac_cv_prog_ps_ax" = yes; then
3676 >                ac_cv_prog_ps_syntax=BSD
3677 >        else
3678 >                if test "$ac_cv_prog_ps_ef" = yes; then
3679 >                        ac_cv_prog_ps_syntax=POSIX
3680 >                else
3681 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3682 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3683 >   { (exit 1); exit 1; }; }
3684 >                fi
3685 >        fi
3686 >
3687   fi
3688 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3689 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3690  
3691 + cat >>confdefs.h <<_ACEOF
3692 + #define PSCOMMAND $PS
3693 + _ACEOF
3694  
3695 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3696 < # input file.
3697 < ac_save_ext=$ac_ext
3698 < ac_ext=F90
3699 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3700 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3454 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3455 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3695 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3696 >
3697 > cat >>confdefs.h <<\_ACEOF
3698 > #define PSTYPE_IS_BSD 1
3699 > _ACEOF
3700 >
3701   else
3702 <  cat >conftest.$ac_ext <<_ACEOF
3702 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3703  
3704 < program main
3704 > cat >>confdefs.h <<\_ACEOF
3705 > #define PSTYPE_IS_POSIX 1
3706 > _ACEOF
3707  
3708 < #ifndef __GNUC__
3709 <       choke me
3710 < #endif
3708 >   else
3709 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3710 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3711 >   { (exit 1); exit 1; }; }
3712 >   fi
3713 > fi
3714  
3715 < end program main
3715 > ac_ext=${FC_SRCEXT-f}
3716 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3717 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3718 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3719  
3720 +
3721 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3722 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3723 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3724 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3725 + else
3726 +  ac_ext=F90
3727 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3728 + FCFLAGS_SRCEXT=""
3729 + ac_cv_fc_srcext_F90=unknown
3730 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3731 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3732 +  cat >conftest.$ac_ext <<_ACEOF
3733 +      program main
3734 +
3735 +      end
3736   _ACEOF
3737   rm -f conftest.$ac_objext
3738   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3474 | Line 3743 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3743    cat conftest.err >&5
3744    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745    (exit $ac_status); } &&
3746 <         { ac_try='test -z "$ac_f90_werror_flag"
3746 >         { ac_try='test -z "$ac_fc_werror_flag"
3747                           || test ! -s conftest.err'
3748    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3749    (eval $ac_try) 2>&5
# Line 3487 | Line 3756 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3756    ac_status=$?
3757    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758    (exit $ac_status); }; }; then
3759 <  ac_compiler_gnu=yes
3759 >  ac_cv_fc_srcext_F90=$ac_flag; break
3760   else
3761    echo "$as_me: failed program was:" >&5
3762   sed 's/^/| /' conftest.$ac_ext >&5
3763  
3764 < ac_compiler_gnu=no
3496 < fi
3764 > fi
3765   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3766 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3766 > done
3767 > rm -f conftest.$ac_objext conftest.F90
3768 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3769  
3770   fi
3771 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3772 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3773 < ac_ext=$ac_save_ext
3774 < G95=`test $ac_compiler_gnu = yes && echo yes`
3775 < ac_ext=c
3776 < ac_cpp='$CPP $CPPFLAGS'
3777 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3778 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3779 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3771 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3772 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3773 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3774 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3775 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3776 >   { (exit 1); exit 1; }; }
3777 > else
3778 >  FC_SRCEXT=F90
3779 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3780 >    FCFLAGS_SRCEXT=""
3781 >    FCFLAGS_F90=""
3782 >  else
3783 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3784 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3785 >  fi
3786  
3787  
3788 + fi
3789  
3790  
3791  
3792 +
3793 +
3794   # Try to determine native compiler flags that allow us to use F90 suffix
3795   # for preprocessed f90 source.
3796  
# Line 3519 | Line 3798 | if test "$ac_test_PREPFLAG" != "set"; then
3798    PREPFLAG=""
3799    case "${host_cpu}-${host_os}" in
3800  
3801 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3801 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3802                      PREPFLAG="-fpp1 "
3803                  fi;;
3804 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3804 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3805                      PREPFLAG="-qsuffix=cpp=F90 "
3806                  fi;;
3807    *darwin*)
3808 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3808 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3809                  PREPFLAG="-qsuffix=cpp=F90 "
3810          fi;;
3811    esac
# Line 3541 | Line 3820 | echo $ECHO_N "checking to make sure F90 preprocessor f
3820   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3821  
3822  
3823 <  ac_ext=f90
3824 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3825 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3826 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3823 >  ac_ext=${FC_SRCEXT-f}
3824 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3825 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3826 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3827  
3828    ac_save_ext=$ac_ext
3829    ac_ext=F90
3830 <  ac_save_F90FLAGS=$F90FLAGS
3830 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3831  
3832    if test "$PREPFLAG"; then
3833 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3833 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3834   fi
3835  
3836      cat >conftest.$ac_ext <<_ACEOF
3837  
3838  
3839 < program main
3561 <
3839 > program conftest
3840    integer :: i
3841    i = 1
3842 + end program conftest
3843  
3565
3566 end program main
3567
3844   _ACEOF
3845   rm -f conftest.$ac_objext
3846   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3575 | Line 3851 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3851    cat conftest.err >&5
3852    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853    (exit $ac_status); } &&
3854 <         { ac_try='test -z "$ac_f90_werror_flag"
3854 >         { ac_try='test -z "$ac_fc_werror_flag"
3855                           || test ! -s conftest.err'
3856    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3857    (eval $ac_try) 2>&5
# Line 3597 | Line 3873 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3873   fi
3874   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3875  
3876 <  F90FLAGS=$ac_save_F90FLAGS
3876 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3877    ac_ext=$ac_save_ext
3878 <  ac_ext=c
3879 < ac_cpp='$CPP $CPPFLAGS'
3880 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3881 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3606 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3878 >  ac_ext=${FC_SRCEXT-f}
3879 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3880 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3881 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3882  
3883  
3884    if test "$prepflagworks" = 1; then
3885      echo "$as_me:$LINENO: result: yes" >&5
3886   echo "${ECHO_T}yes" >&6
3887 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3888  
3889    else
3890      echo "$as_me:$LINENO: result: no" >&5
# Line 3630 | Line 3906 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3906    PREPDEFFLAG=""
3907    case "${host_cpu}-${host_os}" in
3908  
3909 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3909 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3910                      PREPDEFFLAG=" "
3911                  fi;;
3912 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3912 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3913                      PREPDEFFLAG="-WF,"
3914                  fi;;
3915    *darwin*)
3916 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3916 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3917                  PREPDEFFLAG="-WF,"
3918          fi;;
3919    esac
# Line 3652 | Line 3928 | echo $ECHO_N "checking to make sure F90 preprocessor d
3928   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3929  
3930  
3931 <  ac_ext=f90
3932 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3933 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3934 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3931 >  ac_ext=${FC_SRCEXT-f}
3932 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3933 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3934 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3935  
3936    ac_save_ext=$ac_ext
3937    ac_ext=F90
3938 <  ac_save_F90FLAGS=$F90FLAGS
3938 >  ac_save_FCFLAGS=$FCFLAGS
3939  
3940    if test "$PREPDEFFLAG"; then
3941 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3941 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3942   fi
3943  
3944      cat >conftest.$ac_ext <<_ACEOF
3945  
3946  
3947 < program main
3672 <
3947 > program conftest
3948    integer :: i
3949   #ifdef TEST
3950    i = 1
3951   #else
3952    choke me
3953   #endif
3954 + end program conftest
3955  
3680
3681 end program main
3682
3956   _ACEOF
3957   rm -f conftest.$ac_objext
3958   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3690 | Line 3963 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3963    cat conftest.err >&5
3964    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965    (exit $ac_status); } &&
3966 <         { ac_try='test -z "$ac_f90_werror_flag"
3966 >         { ac_try='test -z "$ac_fc_werror_flag"
3967                           || test ! -s conftest.err'
3968    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969    (eval $ac_try) 2>&5
# Line 3712 | Line 3985 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3985   fi
3986   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3987  
3988 <  F90FLAGS=$ac_save_F90FLAGS
3988 >  FCFLAGS=$ac_save_FCFLAGS
3989    ac_ext=$ac_save_ext
3990 <  ac_ext=c
3991 < ac_cpp='$CPP $CPPFLAGS'
3992 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3993 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3721 < ac_compiler_gnu=$ac_cv_c_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  
3724
3996    if test "$prepdefflagworks" = 1; then
3997      echo "$as_me:$LINENO: result: yes" >&5
3998   echo "${ECHO_T}yes" >&6
# Line 3735 | Line 4006 | ac_ext=f90
4006    fi
4007   fi
4008  
4009 < ac_ext=f90
4010 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4011 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4012 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4013 <
4014 <
4015 <
3745 < ac_ext=f90
3746 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3747 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3748 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3749 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3750 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3751 < if test "${ac_cv_prog_f90_v+set}" = set; then
4009 > ac_ext=${FC_SRCEXT-f}
4010 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4011 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4012 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4013 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4014 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4015 > if test "${ac_cv_prog_fc_v+set}" = set; then
4016    echo $ECHO_N "(cached) $ECHO_C" >&6
4017   else
4018 +  cat >conftest.$ac_ext <<_ACEOF
4019 +      program main
4020  
4021 < cat >conftest.$ac_ext <<_ACEOF
3756 <
3757 < program main
3758 <
3759 <
3760 < end program main
3761 <
4021 >      end
4022   _ACEOF
4023   rm -f conftest.$ac_objext
4024   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3769 | Line 4029 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4029    cat conftest.err >&5
4030    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031    (exit $ac_status); } &&
4032 <         { ac_try='test -z "$ac_f90_werror_flag"
4032 >         { ac_try='test -z "$ac_fc_werror_flag"
4033                           || test ! -s conftest.err'
4034    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4035    (eval $ac_try) 2>&5
# Line 3782 | Line 4042 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4042    ac_status=$?
4043    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044    (exit $ac_status); }; }; then
4045 <  ac_cv_prog_f90_v=
4045 >  ac_cv_prog_fc_v=
4046   # Try some options frequently used verbose output
4047   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4048 <  ac_ext=f90
4049 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3790 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3791 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4048 >  cat >conftest.$ac_ext <<_ACEOF
4049 >      program main
4050  
4051 < cat >conftest.$ac_ext <<_ACEOF
3794 <
3795 < program main
3796 <
3797 <
3798 < end program main
3799 <
4051 >      end
4052   _ACEOF
4053  
4054   # Compile and link our simple test program by passing a flag (argument
4055 < # 1 to this macro) to the Fortran 90 compiler in order to get
4056 < # "verbose" output that we can then parse for the Fortran 90 linker
4055 > # 1 to this macro) to the Fortran compiler in order to get
4056 > # "verbose" output that we can then parse for the Fortran linker
4057   # flags.
4058 < ac_save_F90FLAGS=$F90FLAGS
4059 < F90FLAGS="$F90FLAGS $ac_verb"
4058 > ac_save_FFLAGS=$FCFLAGS
4059 > FCFLAGS="$FCFLAGS $ac_verb"
4060 > (eval echo $as_me:4060: \"$ac_link\") >&5
4061 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4062 > echo "$ac_fc_v_output" >&5
4063 > FCFLAGS=$ac_save_FFLAGS
4064  
4065 < (eval echo $as_me:3809: \"$ac_link\") >&5
3810 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3811 < echo "$ac_f90_v_output" >&5
3812 < F90FLAGS=$ac_save_F90FLAGS
4065 > rm -f conftest*
4066  
4067 < rm -f conftest.*
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
4067 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4068 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4069 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4070 > ac_fc_v_output="`echo $ac_fc_v_output |
4071 >        grep 'LPATH is:' |
4072 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4073  
4074 < # If we are using xlf then replace all the commas with spaces.
4075 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4076 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4077 < fi
4074 > case $ac_fc_v_output in
4075 >  # If we are using xlf then replace all the commas with spaces.
4076 >  *xlfentry*)
4077 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4078  
4079 < # If we are using Cray Fortran then delete quotes.
4080 < # Use "\"" instead of '"' for font-lock-mode.
4081 < # FIXME: a more general fix for quoted arguments with spaces?
4082 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4083 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4084 < fi
4079 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4080 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4081 >  *mGLOB_options_string*)
4082 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4083 >
4084 >  # If we are using Cray Fortran then delete quotes.
4085 >  # Use "\"" instead of '"' for font-lock-mode.
4086 >  # FIXME: a more general fix for quoted arguments with spaces?
4087 >  *cft90*)
4088 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4089 > esac
4090 >
4091 >
4092    # look for -l* and *.a constructs in the output
4093 <  for ac_arg in $ac_f90_v_output; do
4093 >  for ac_arg in $ac_fc_v_output; do
4094       case $ac_arg in
4095          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4096 <          ac_cv_prog_f90_v=$ac_verb
4096 >          ac_cv_prog_fc_v=$ac_verb
4097            break 2 ;;
4098       esac
4099    done
4100   done
4101 < if test -z "$ac_cv_prog_f90_v"; then
4102 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4103 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4101 > if test -z "$ac_cv_prog_fc_v"; then
4102 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4103 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4104   fi
4105   else
4106    echo "$as_me: failed program was:" >&5
# Line 3851 | Line 4112 | echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4112   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4113  
4114   fi
4115 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4116 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4117 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4118 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4119 < if test "${ac_cv_flibs+set}" = set; then
4115 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4116 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4117 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4118 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4119 > if test "${ac_cv_fc_libs+set}" = set; then
4120    echo $ECHO_N "(cached) $ECHO_C" >&6
4121   else
4122 <  if test "x$F90LIBS" != "x"; then
4123 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4124 < else
4122 >  if test "x$FCLIBS" != "x"; then
4123 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4124 > else
4125  
3865 ac_ext=f90
3866 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3867 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3868 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3869
4126   cat >conftest.$ac_ext <<_ACEOF
4127 +      program main
4128  
4129 < program main
3873 <
3874 <
3875 < end program main
3876 <
4129 >      end
4130   _ACEOF
4131  
4132   # Compile and link our simple test program by passing a flag (argument
4133 < # 1 to this macro) to the Fortran 90 compiler in order to get
4134 < # "verbose" output that we can then parse for the Fortran 90 linker
4133 > # 1 to this macro) to the Fortran compiler in order to get
4134 > # "verbose" output that we can then parse for the Fortran linker
4135   # flags.
4136 < ac_save_F90FLAGS=$F90FLAGS
4137 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4136 > ac_save_FFLAGS=$FCFLAGS
4137 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4138 > (eval echo $as_me:4138: \"$ac_link\") >&5
4139 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4140 > echo "$ac_fc_v_output" >&5
4141 > FCFLAGS=$ac_save_FFLAGS
4142  
4143 < (eval echo $as_me:3886: \"$ac_link\") >&5
3887 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3888 < echo "$ac_f90_v_output" >&5
3889 < F90FLAGS=$ac_save_F90FLAGS
4143 > rm -f conftest*
4144  
4145 < rm -f conftest.*
4146 < ac_ext=f90
4147 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4148 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4149 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4145 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4146 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4147 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4148 > ac_fc_v_output="`echo $ac_fc_v_output |
4149 >        grep 'LPATH is:' |
4150 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4151  
4152 < # If we are using xlf then replace all the commas with spaces.
4153 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4154 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4155 < fi
4152 > case $ac_fc_v_output in
4153 >  # If we are using xlf then replace all the commas with spaces.
4154 >  *xlfentry*)
4155 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4156  
4157 < # If we are using Cray Fortran then delete quotes.
4158 < # Use "\"" instead of '"' for font-lock-mode.
4159 < # FIXME: a more general fix for quoted arguments with spaces?
4160 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3906 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3907 < fi
4157 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4158 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4159 >  *mGLOB_options_string*)
4160 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4161  
4162 < ac_cv_f90libs=
4162 >  # If we are using Cray Fortran then delete quotes.
4163 >  # Use "\"" instead of '"' for font-lock-mode.
4164 >  # FIXME: a more general fix for quoted arguments with spaces?
4165 >  *cft90*)
4166 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4167 > esac
4168  
4169 +
4170 +
4171 + ac_cv_fc_libs=
4172 +
4173   # Save positional arguments (if any)
4174   ac_save_positional="$@"
4175  
4176 < set X $ac_f90_v_output
4176 > set X $ac_fc_v_output
4177   while test $# != 1; do
4178    shift
4179    ac_arg=$1
4180    case $ac_arg in
4181          [\\/]*.a | ?:[\\/]*.a)
4182              ac_exists=false
4183 <  for ac_i in $ac_cv_f90libs; do
4183 >  for ac_i in $ac_cv_fc_libs; do
4184      if test x"$ac_arg" = x"$ac_i"; then
4185        ac_exists=true
4186        break
# Line 3928 | Line 4190 | else
4190    if test x"$ac_exists" = xtrue; then
4191    :
4192   else
4193 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4193 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4194   fi
4195  
4196            ;;
4197          -bI:*)
4198              ac_exists=false
4199 <  for ac_i in $ac_cv_f90libs; do
4199 >  for ac_i in $ac_cv_fc_libs; do
4200      if test x"$ac_arg" = x"$ac_i"; then
4201        ac_exists=true
4202        break
# Line 3946 | Line 4208 | else
4208   else
4209    if test "$ac_compiler_gnu" = yes; then
4210    for ac_link_opt in $ac_arg; do
4211 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4211 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4212    done
4213   else
4214 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4214 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4215   fi
4216   fi
4217  
4218            ;;
4219            # Ignore these flags.
4220 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4220 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4221            ;;
4222          -lkernel32)
4223 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4223 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4224            ;;
4225          -[LRuY])
4226            # These flags, when seen by themselves, take an argument.
4227            # We remove the space between option and argument and re-iterate
4228            # unless we find an empty arg or a new option (starting with -)
4229            case $2 in
4230 <             "" | -*);;
4231 <             *)
4230 >             "" | -*);;
4231 >             *)
4232                  ac_arg="$ac_arg$2"
3971
4233                  shift; shift
4234                  set X $ac_arg "$@"
4235                  ;;
# Line 3977 | Line 4238 | fi
4238          -YP,*)
4239            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4240                ac_exists=false
4241 <  for ac_i in $ac_cv_f90libs; do
4241 >  for ac_i in $ac_cv_fc_libs; do
4242      if test x"$ac_j" = x"$ac_i"; then
4243        ac_exists=true
4244        break
# Line 3988 | Line 4249 | else
4249    :
4250   else
4251    ac_arg="$ac_arg $ac_j"
4252 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4252 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4253   fi
4254  
4255            done
4256            ;;
4257          -[lLR]*)
4258              ac_exists=false
4259 <  for ac_i in $ac_cv_f90libs; do
4259 >  for ac_i in $ac_cv_fc_libs; do
4260      if test x"$ac_arg" = x"$ac_i"; then
4261        ac_exists=true
4262        break
# Line 4005 | Line 4266 | else
4266    if test x"$ac_exists" = xtrue; then
4267    :
4268   else
4269 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4269 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4270   fi
4271  
4272            ;;
# Line 4020 | Line 4281 | case `(uname -sr) 2>/dev/null` in
4281   # must begin with a "/").
4282   case `(uname -sr) 2>/dev/null` in
4283     "SunOS 5"*)
4284 <      ac_ld_run_path=`echo $ac_f90_v_output |
4284 >      ac_ld_run_path=`echo $ac_fc_v_output |
4285                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4286        test "x$ac_ld_run_path" != x &&
4026
4287          if test "$ac_compiler_gnu" = yes; then
4288    for ac_link_opt in $ac_ld_run_path; do
4289 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4289 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4290    done
4291   else
4292 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4292 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4293   fi
4294        ;;
4295   esac
4296 < fi # test "x$F90LIBS" = "x"
4296 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4297  
4298   fi
4299 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4300 < echo "${ECHO_T}$ac_cv_flibs" >&6
4301 < F90LIBS="$ac_cv_f90libs"
4299 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4300 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4301 > FCLIBS="$ac_cv_fc_libs"
4302  
4043 ac_ext=f90
4044 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4045 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4046 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4303  
4304 + ac_ext=${FC_SRCEXT-f}
4305 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4306 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4307 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4308  
4309 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4310 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4311 < if test "${ac_cv_f90_mangling+set}" = set; then
4309 >
4310 > ac_ext=${FC_SRCEXT-f}
4311 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4312 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4313 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4314 >
4315 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4316 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4317 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4318    echo $ECHO_N "(cached) $ECHO_C" >&6
4319   else
4320 <  ac_ext=f90
4321 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4322 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4323 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4324 < cat >conftest.$ac_ext <<_ACEOF
4325 < subroutine foobar()
4326 < return
4327 < end
4328 < subroutine foo_bar()
4329 < return
4330 < end
4320 >  ac_fc_dm_save_LIBS=$LIBS
4321 > LIBS="$LIBS $FCLIBS"
4322 > ac_fortran_dm_var=FC_DUMMY_MAIN
4323 > ac_ext=c
4324 > ac_cpp='$CPP $CPPFLAGS'
4325 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4326 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4327 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4328 >
4329 > # First, try linking without a dummy main:
4330 > cat >conftest.$ac_ext <<_ACEOF
4331 > /* confdefs.h.  */
4332   _ACEOF
4333 + cat confdefs.h >>conftest.$ac_ext
4334 + cat >>conftest.$ac_ext <<_ACEOF
4335 + /* end confdefs.h.  */
4336 +
4337 + #ifdef FC_DUMMY_MAIN
4338 + #ifndef FC_DUMMY_MAIN_EQ_F77
4339 + #  ifdef __cplusplus
4340 +     extern "C"
4341 + #  endif
4342 +   int FC_DUMMY_MAIN() { return 1; }
4343 + #endif
4344 + #endif
4345 + int
4346 + main ()
4347 + {
4348 +
4349 +  ;
4350 +  return 0;
4351 + }
4352 + _ACEOF
4353 + rm -f conftest.$ac_objext conftest$ac_exeext
4354 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4355 +  (eval $ac_link) 2>conftest.er1
4356 +  ac_status=$?
4357 +  grep -v '^ *+' conftest.er1 >conftest.err
4358 +  rm -f conftest.er1
4359 +  cat conftest.err >&5
4360 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4361 +  (exit $ac_status); } &&
4362 +         { ac_try='test -z "$ac_c_werror_flag"
4363 +                         || test ! -s conftest.err'
4364 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4365 +  (eval $ac_try) 2>&5
4366 +  ac_status=$?
4367 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4368 +  (exit $ac_status); }; } &&
4369 +         { ac_try='test -s conftest$ac_exeext'
4370 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4371 +  (eval $ac_try) 2>&5
4372 +  ac_status=$?
4373 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4374 +  (exit $ac_status); }; }; then
4375 +  ac_cv_fortran_dummy_main=none
4376 + else
4377 +  echo "$as_me: failed program was:" >&5
4378 + sed 's/^/| /' conftest.$ac_ext >&5
4379 +
4380 + ac_cv_fortran_dummy_main=unknown
4381 + fi
4382 + rm -f conftest.err conftest.$ac_objext \
4383 +      conftest$ac_exeext conftest.$ac_ext
4384 +
4385 + if test $ac_cv_fortran_dummy_main = unknown; then
4386 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4387 +     cat >conftest.$ac_ext <<_ACEOF
4388 + /* confdefs.h.  */
4389 + _ACEOF
4390 + cat confdefs.h >>conftest.$ac_ext
4391 + cat >>conftest.$ac_ext <<_ACEOF
4392 + /* end confdefs.h.  */
4393 + #define $ac_fortran_dm_var $ac_func
4394 + #ifdef FC_DUMMY_MAIN
4395 + #ifndef FC_DUMMY_MAIN_EQ_F77
4396 + #  ifdef __cplusplus
4397 +     extern "C"
4398 + #  endif
4399 +   int FC_DUMMY_MAIN() { return 1; }
4400 + #endif
4401 + #endif
4402 + int
4403 + main ()
4404 + {
4405 +
4406 +  ;
4407 +  return 0;
4408 + }
4409 + _ACEOF
4410 + rm -f conftest.$ac_objext conftest$ac_exeext
4411 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4412 +  (eval $ac_link) 2>conftest.er1
4413 +  ac_status=$?
4414 +  grep -v '^ *+' conftest.er1 >conftest.err
4415 +  rm -f conftest.er1
4416 +  cat conftest.err >&5
4417 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4418 +  (exit $ac_status); } &&
4419 +         { ac_try='test -z "$ac_c_werror_flag"
4420 +                         || test ! -s conftest.err'
4421 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4422 +  (eval $ac_try) 2>&5
4423 +  ac_status=$?
4424 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4425 +  (exit $ac_status); }; } &&
4426 +         { ac_try='test -s conftest$ac_exeext'
4427 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4428 +  (eval $ac_try) 2>&5
4429 +  ac_status=$?
4430 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4431 +  (exit $ac_status); }; }; then
4432 +  ac_cv_fortran_dummy_main=$ac_func; break
4433 + else
4434 +  echo "$as_me: failed program was:" >&5
4435 + sed 's/^/| /' conftest.$ac_ext >&5
4436 +
4437 + fi
4438 + rm -f conftest.err conftest.$ac_objext \
4439 +      conftest$ac_exeext conftest.$ac_ext
4440 +   done
4441 + fi
4442 + ac_ext=${FC_SRCEXT-f}
4443 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4444 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4445 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4446 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4447 + rm -f conftest*
4448 + LIBS=$ac_fc_dm_save_LIBS
4449 +
4450 + fi
4451 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4452 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4453 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4454 + if test "$FC_DUMMY_MAIN" != unknown; then
4455 +  if test $FC_DUMMY_MAIN != none; then
4456 +
4457 + cat >>confdefs.h <<_ACEOF
4458 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4459 + _ACEOF
4460 +
4461 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4462 +
4463 + cat >>confdefs.h <<\_ACEOF
4464 + #define FC_DUMMY_MAIN_EQ_F77 1
4465 + _ACEOF
4466 +
4467 +  fi
4468 + fi
4469 + else
4470 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4471 + See \`config.log' for more details." >&5
4472 + echo "$as_me: error: linking to Fortran libraries from C fails
4473 + See \`config.log' for more details." >&2;}
4474 +   { (exit 1); exit 1; }; }
4475 + fi
4476 +
4477 +
4478 + ac_ext=${FC_SRCEXT-f}
4479 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4480 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4481 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4482 +
4483 + ac_ext=${FC_SRCEXT-f}
4484 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4485 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4486 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4487 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4488 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4489 + if test "${ac_cv_fc_mangling+set}" = set; then
4490 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4491 + else
4492 +  cat >conftest.$ac_ext <<_ACEOF
4493 +      subroutine foobar()
4494 +      return
4495 +      end
4496 +      subroutine foo_bar()
4497 +      return
4498 +      end
4499 + _ACEOF
4500   rm -f conftest.$ac_objext
4501   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4502    (eval $ac_compile) 2>conftest.er1
# Line 4072 | Line 4506 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4506    cat conftest.err >&5
4507    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508    (exit $ac_status); } &&
4509 <         { ac_try='test -z "$ac_f90_werror_flag"
4509 >         { ac_try='test -z "$ac_fc_werror_flag"
4510                           || test ! -s conftest.err'
4511    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512    (eval $ac_try) 2>&5
# Line 4085 | Line 4519 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4519    ac_status=$?
4520    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521    (exit $ac_status); }; }; then
4522 <  mv conftest.$ac_objext cf90_test.$ac_objext
4522 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4523  
4524 +  ac_save_LIBS=$LIBS
4525 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4526 +
4527    ac_ext=c
4528   ac_cpp='$CPP $CPPFLAGS'
4529   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4530   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4531   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4095
4096  ac_save_LIBS=$LIBS
4097  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4098
4532    ac_success=no
4533    for ac_foobar in foobar FOOBAR; do
4534      for ac_underscore in "" "_"; do
# Line 4114 | Line 4547 | int
4547   /* We use char because int might match the return type of a gcc2
4548     builtin and then its argument prototype would still apply.  */
4549   char $ac_func ();
4550 + #ifdef FC_DUMMY_MAIN
4551 + #ifndef FC_DUMMY_MAIN_EQ_F77
4552 + #  ifdef __cplusplus
4553 +     extern "C"
4554 + #  endif
4555 +   int FC_DUMMY_MAIN() { return 1; }
4556 + #endif
4557 + #endif
4558   int
4559   main ()
4560   {
# Line 4154 | Line 4595 | rm -f conftest.err conftest.$ac_objext \
4595        conftest$ac_exeext conftest.$ac_ext
4596      done
4597    done
4598 +  ac_ext=${FC_SRCEXT-f}
4599 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4600 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4601 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4602  
4603    if test "$ac_success" = "yes"; then
4604       case $ac_foobar in
4605 <        foobar)
4606 <           ac_case=lower
4607 <           ac_foo_bar=foo_bar
4608 <           ;;
4609 <        FOOBAR)
4610 <           ac_case=upper
4611 <           ac_foo_bar=FOO_BAR
4612 <           ;;
4605 >        foobar)
4606 >           ac_case=lower
4607 >           ac_foo_bar=foo_bar
4608 >           ;;
4609 >        FOOBAR)
4610 >           ac_case=upper
4611 >           ac_foo_bar=FOO_BAR
4612 >           ;;
4613       esac
4614  
4615 +     ac_ext=c
4616 + ac_cpp='$CPP $CPPFLAGS'
4617 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4618 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4619 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4620       ac_success_extra=no
4621       for ac_extra in "" "_"; do
4622 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4623 <
4174 <        cat >conftest.$ac_ext <<_ACEOF
4622 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4623 >        cat >conftest.$ac_ext <<_ACEOF
4624   /* confdefs.h.  */
4625   _ACEOF
4626   cat confdefs.h >>conftest.$ac_ext
# Line 4185 | Line 4634 | int
4634   /* We use char because int might match the return type of a gcc2
4635     builtin and then its argument prototype would still apply.  */
4636   char $ac_func ();
4637 + #ifdef FC_DUMMY_MAIN
4638 + #ifndef FC_DUMMY_MAIN_EQ_F77
4639 + #  ifdef __cplusplus
4640 +     extern "C"
4641 + #  endif
4642 +   int FC_DUMMY_MAIN() { return 1; }
4643 + #endif
4644 + #endif
4645   int
4646   main ()
4647   {
# Line 4224 | Line 4681 | rm -f conftest.err conftest.$ac_objext \
4681   rm -f conftest.err conftest.$ac_objext \
4682        conftest$ac_exeext conftest.$ac_ext
4683       done
4684 +     ac_ext=${FC_SRCEXT-f}
4685 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4686 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4687 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4688  
4689       if test "$ac_success_extra" = "yes"; then
4690 <        ac_cv_f90_mangling="$ac_case case"
4690 >        ac_cv_fc_mangling="$ac_case case"
4691          if test -z "$ac_underscore"; then
4692 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4692 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4693          else
4694 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4234 <
4694 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4695          fi
4696          if test -z "$ac_extra"; then
4697 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4697 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4698          else
4699 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4699 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4700          fi
4701        else
4702 <        ac_cv_f90_mangling="unknown"
4702 >        ac_cv_fc_mangling="unknown"
4703        fi
4704    else
4705 <     ac_cv_f90_mangling="unknown"
4246 <
4705 >     ac_cv_fc_mangling="unknown"
4706    fi
4707  
4708    LIBS=$ac_save_LIBS
4709 <  ac_ext=f90
4251 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4252 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4253 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4254 <  rm -f cf90_test* conftest*
4709 >  rm -f cfortran_test* conftest*
4710   else
4711    echo "$as_me: failed program was:" >&5
4712   sed 's/^/| /' conftest.$ac_ext >&5
4713  
4714 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4715 + See \`config.log' for more details." >&5
4716 + echo "$as_me: error: cannot compile a simple Fortran program
4717 + See \`config.log' for more details." >&2;}
4718 +   { (exit 1); exit 1; }; }
4719   fi
4720   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4261 ac_ext=f90
4262 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4263 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4264 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4721  
4722   fi
4723 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4724 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4723 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4724 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4725  
4726 + ac_ext=${FC_SRCEXT-f}
4727 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4728 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4729 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4730  
4731 + ac_ext=${FC_SRCEXT-f}
4732 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4733 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4734 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4735  
4736 < case $ac_cv_f90_mangling in
4736 >
4737 > case $ac_cv_fc_mangling in
4738    "lower case, no underscore, no extra underscore")
4739            cat >>confdefs.h <<\_ACEOF
4740 < #define F90_FUNC(name,NAME) name
4740 > #define FC_FUNC(name,NAME) name
4741   _ACEOF
4742  
4743            cat >>confdefs.h <<\_ACEOF
4744 < #define F90_FUNC_(name,NAME) name
4744 > #define FC_FUNC_(name,NAME) name
4745   _ACEOF
4746   ;;
4747    "lower case, no underscore, extra underscore")
4748            cat >>confdefs.h <<\_ACEOF
4749 < #define F90_FUNC(name,NAME) name
4749 > #define FC_FUNC(name,NAME) name
4750   _ACEOF
4751  
4752            cat >>confdefs.h <<\_ACEOF
4753 < #define F90_FUNC_(name,NAME) name ## _
4753 > #define FC_FUNC_(name,NAME) name ## _
4754   _ACEOF
4755   ;;
4756    "lower case, underscore, no extra underscore")
4757            cat >>confdefs.h <<\_ACEOF
4758 < #define F90_FUNC(name,NAME) name ## _
4758 > #define FC_FUNC(name,NAME) name ## _
4759   _ACEOF
4760  
4761            cat >>confdefs.h <<\_ACEOF
4762 < #define F90_FUNC_(name,NAME) name ## _
4762 > #define FC_FUNC_(name,NAME) name ## _
4763   _ACEOF
4764   ;;
4765    "lower case, underscore, extra underscore")
4766            cat >>confdefs.h <<\_ACEOF
4767 < #define F90_FUNC(name,NAME) name ## _
4767 > #define FC_FUNC(name,NAME) name ## _
4768   _ACEOF
4769  
4770            cat >>confdefs.h <<\_ACEOF
4771 < #define F90_FUNC_(name,NAME) name ## __
4771 > #define FC_FUNC_(name,NAME) name ## __
4772   _ACEOF
4773   ;;
4774    "upper case, no underscore, no extra underscore")
4775            cat >>confdefs.h <<\_ACEOF
4776 < #define F90_FUNC(name,NAME) NAME
4776 > #define FC_FUNC(name,NAME) NAME
4777   _ACEOF
4778  
4779            cat >>confdefs.h <<\_ACEOF
4780 < #define F90_FUNC_(name,NAME) NAME
4780 > #define FC_FUNC_(name,NAME) NAME
4781   _ACEOF
4782   ;;
4783    "upper case, no underscore, extra underscore")
4784            cat >>confdefs.h <<\_ACEOF
4785 < #define F90_FUNC(name,NAME) NAME
4785 > #define FC_FUNC(name,NAME) NAME
4786   _ACEOF
4787  
4788            cat >>confdefs.h <<\_ACEOF
4789 < #define F90_FUNC_(name,NAME) NAME ## _
4789 > #define FC_FUNC_(name,NAME) NAME ## _
4790   _ACEOF
4791   ;;
4792    "upper case, underscore, no extra underscore")
4793            cat >>confdefs.h <<\_ACEOF
4794 < #define F90_FUNC(name,NAME) NAME ## _
4794 > #define FC_FUNC(name,NAME) NAME ## _
4795   _ACEOF
4796  
4797            cat >>confdefs.h <<\_ACEOF
4798 < #define F90_FUNC_(name,NAME) NAME ## _
4798 > #define FC_FUNC_(name,NAME) NAME ## _
4799   _ACEOF
4800   ;;
4801    "upper case, underscore, extra underscore")
4802            cat >>confdefs.h <<\_ACEOF
4803 < #define F90_FUNC(name,NAME) NAME ## _
4803 > #define FC_FUNC(name,NAME) NAME ## _
4804   _ACEOF
4805  
4806            cat >>confdefs.h <<\_ACEOF
4807 < #define F90_FUNC_(name,NAME) NAME ## __
4807 > #define FC_FUNC_(name,NAME) NAME ## __
4808   _ACEOF
4809   ;;
4810    *)
4811 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4812 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4811 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4812 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4813            ;;
4814   esac
4815  
4816 + ac_ext=${FC_SRCEXT-f}
4817 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4818 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4819 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4820  
4821  
4822  
4823 + ac_ext=${FC_SRCEXT-f}
4824 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4825 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4826 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4827 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4828 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4829 + if test "${ac_cv_prog_fc_v+set}" = set; then
4830 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4831 + else
4832 +  cat >conftest.$ac_ext <<_ACEOF
4833 +      program main
4834  
4835 +      end
4836 + _ACEOF
4837 + rm -f conftest.$ac_objext
4838 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4839 +  (eval $ac_compile) 2>conftest.er1
4840 +  ac_status=$?
4841 +  grep -v '^ *+' conftest.er1 >conftest.err
4842 +  rm -f conftest.er1
4843 +  cat conftest.err >&5
4844 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4845 +  (exit $ac_status); } &&
4846 +         { ac_try='test -z "$ac_fc_werror_flag"
4847 +                         || test ! -s conftest.err'
4848 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4849 +  (eval $ac_try) 2>&5
4850 +  ac_status=$?
4851 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4852 +  (exit $ac_status); }; } &&
4853 +         { ac_try='test -s conftest.$ac_objext'
4854 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4855 +  (eval $ac_try) 2>&5
4856 +  ac_status=$?
4857 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4858 +  (exit $ac_status); }; }; then
4859 +  ac_cv_prog_fc_v=
4860 + # Try some options frequently used verbose output
4861 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4862 +  cat >conftest.$ac_ext <<_ACEOF
4863 +      program main
4864 +
4865 +      end
4866 + _ACEOF
4867 +
4868 + # Compile and link our simple test program by passing a flag (argument
4869 + # 1 to this macro) to the Fortran compiler in order to get
4870 + # "verbose" output that we can then parse for the Fortran linker
4871 + # flags.
4872 + ac_save_FFLAGS=$FCFLAGS
4873 + FCFLAGS="$FCFLAGS $ac_verb"
4874 + (eval echo $as_me:4874: \"$ac_link\") >&5
4875 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4876 + echo "$ac_fc_v_output" >&5
4877 + FCFLAGS=$ac_save_FFLAGS
4878 +
4879 + rm -f conftest*
4880 +
4881 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4882 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4883 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4884 + ac_fc_v_output="`echo $ac_fc_v_output |
4885 +        grep 'LPATH is:' |
4886 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4887 +
4888 + case $ac_fc_v_output in
4889 +  # If we are using xlf then replace all the commas with spaces.
4890 +  *xlfentry*)
4891 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4892 +
4893 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4894 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4895 +  *mGLOB_options_string*)
4896 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4897 +
4898 +  # If we are using Cray Fortran then delete quotes.
4899 +  # Use "\"" instead of '"' for font-lock-mode.
4900 +  # FIXME: a more general fix for quoted arguments with spaces?
4901 +  *cft90*)
4902 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4903 + esac
4904 +
4905 +
4906 +  # look for -l* and *.a constructs in the output
4907 +  for ac_arg in $ac_fc_v_output; do
4908 +     case $ac_arg in
4909 +        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4910 +          ac_cv_prog_fc_v=$ac_verb
4911 +          break 2 ;;
4912 +     esac
4913 +  done
4914 + done
4915 + if test -z "$ac_cv_prog_fc_v"; then
4916 +   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4917 + echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4918 + fi
4919 + else
4920 +  echo "$as_me: failed program was:" >&5
4921 + sed 's/^/| /' conftest.$ac_ext >&5
4922 +
4923 + { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4924 + echo "$as_me: WARNING: compilation failed" >&2;}
4925 + fi
4926 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4927 +
4928 + fi
4929 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4930 + echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4931 + echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4932 + echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4933 + if test "${ac_cv_fc_libs+set}" = set; then
4934 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4935 + else
4936 +  if test "x$FCLIBS" != "x"; then
4937 +  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4938 + else
4939 +
4940 + cat >conftest.$ac_ext <<_ACEOF
4941 +      program main
4942 +
4943 +      end
4944 + _ACEOF
4945 +
4946 + # Compile and link our simple test program by passing a flag (argument
4947 + # 1 to this macro) to the Fortran compiler in order to get
4948 + # "verbose" output that we can then parse for the Fortran linker
4949 + # flags.
4950 + ac_save_FFLAGS=$FCFLAGS
4951 + FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4952 + (eval echo $as_me:4952: \"$ac_link\") >&5
4953 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4954 + echo "$ac_fc_v_output" >&5
4955 + FCFLAGS=$ac_save_FFLAGS
4956 +
4957 + rm -f conftest*
4958 +
4959 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4960 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4961 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4962 + ac_fc_v_output="`echo $ac_fc_v_output |
4963 +        grep 'LPATH is:' |
4964 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4965 +
4966 + case $ac_fc_v_output in
4967 +  # If we are using xlf then replace all the commas with spaces.
4968 +  *xlfentry*)
4969 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4970 +
4971 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4972 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4973 +  *mGLOB_options_string*)
4974 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4975 +
4976 +  # If we are using Cray Fortran then delete quotes.
4977 +  # Use "\"" instead of '"' for font-lock-mode.
4978 +  # FIXME: a more general fix for quoted arguments with spaces?
4979 +  *cft90*)
4980 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4981 + esac
4982 +
4983 +
4984 +
4985 + ac_cv_fc_libs=
4986 +
4987 + # Save positional arguments (if any)
4988 + ac_save_positional="$@"
4989 +
4990 + set X $ac_fc_v_output
4991 + while test $# != 1; do
4992 +  shift
4993 +  ac_arg=$1
4994 +  case $ac_arg in
4995 +        [\\/]*.a | ?:[\\/]*.a)
4996 +            ac_exists=false
4997 +  for ac_i in $ac_cv_fc_libs; do
4998 +    if test x"$ac_arg" = x"$ac_i"; then
4999 +      ac_exists=true
5000 +      break
5001 +    fi
5002 +  done
5003 +
5004 +  if test x"$ac_exists" = xtrue; then
5005 +  :
5006 + else
5007 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5008 + fi
5009 +
5010 +          ;;
5011 +        -bI:*)
5012 +            ac_exists=false
5013 +  for ac_i in $ac_cv_fc_libs; do
5014 +    if test x"$ac_arg" = x"$ac_i"; then
5015 +      ac_exists=true
5016 +      break
5017 +    fi
5018 +  done
5019 +
5020 +  if test x"$ac_exists" = xtrue; then
5021 +  :
5022 + else
5023 +  if test "$ac_compiler_gnu" = yes; then
5024 +  for ac_link_opt in $ac_arg; do
5025 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5026 +  done
5027 + else
5028 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5029 + fi
5030 + fi
5031 +
5032 +          ;;
5033 +          # Ignore these flags.
5034 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5035 +          ;;
5036 +        -lkernel32)
5037 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5038 +          ;;
5039 +        -[LRuY])
5040 +          # These flags, when seen by themselves, take an argument.
5041 +          # We remove the space between option and argument and re-iterate
5042 +          # unless we find an empty arg or a new option (starting with -)
5043 +          case $2 in
5044 +             "" | -*);;
5045 +             *)
5046 +                ac_arg="$ac_arg$2"
5047 +                shift; shift
5048 +                set X $ac_arg "$@"
5049 +                ;;
5050 +          esac
5051 +          ;;
5052 +        -YP,*)
5053 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5054 +              ac_exists=false
5055 +  for ac_i in $ac_cv_fc_libs; do
5056 +    if test x"$ac_j" = x"$ac_i"; then
5057 +      ac_exists=true
5058 +      break
5059 +    fi
5060 +  done
5061 +
5062 +  if test x"$ac_exists" = xtrue; then
5063 +  :
5064 + else
5065 +  ac_arg="$ac_arg $ac_j"
5066 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5067 + fi
5068 +
5069 +          done
5070 +          ;;
5071 +        -[lLR]*)
5072 +            ac_exists=false
5073 +  for ac_i in $ac_cv_fc_libs; do
5074 +    if test x"$ac_arg" = x"$ac_i"; then
5075 +      ac_exists=true
5076 +      break
5077 +    fi
5078 +  done
5079 +
5080 +  if test x"$ac_exists" = xtrue; then
5081 +  :
5082 + else
5083 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5084 + fi
5085 +
5086 +          ;;
5087 +          # Ignore everything else.
5088 +  esac
5089 + done
5090 + # restore positional arguments
5091 + set X $ac_save_positional; shift
5092 +
5093 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5094 + # then we insist that the "run path" must be an absolute path (i.e. it
5095 + # must begin with a "/").
5096 + case `(uname -sr) 2>/dev/null` in
5097 +   "SunOS 5"*)
5098 +      ac_ld_run_path=`echo $ac_fc_v_output |
5099 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5100 +      test "x$ac_ld_run_path" != x &&
5101 +        if test "$ac_compiler_gnu" = yes; then
5102 +  for ac_link_opt in $ac_ld_run_path; do
5103 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5104 +  done
5105 + else
5106 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5107 + fi
5108 +      ;;
5109 + esac
5110 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5111 +
5112 + fi
5113 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5114 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5115 + FCLIBS="$ac_cv_fc_libs"
5116 +
5117 +
5118 + ac_ext=${FC_SRCEXT-f}
5119 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5120 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5121 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5122 +
5123 +
5124 +
5125   echo "$as_me:$LINENO: checking for module suffix" >&5
5126   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5127   rm -f conftest*
5128   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5129   rm -f work*
5130 < cat >conftest.f90 <<EOF
5130 > cat >conftest.$ac_ext <<EOF
5131          module conftest
5132          integer n
5133          parameter (n=1)
# Line 4366 | Line 5136 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5136   # SGI and absoft compilers generates module name in upper case!
5137   testname="conftest"
5138   modcase="lower"
5139 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5140 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5139 > if (eval $ac_compile) 2>/dev/null ; then
5140 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5141      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5142      if test -z "$MOD" ; then
5143          MOD=`ls CONFTEST* 2>/dev/null \
5144 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5144 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5145          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5146          if test -n "$MOD" ; then
5147              testname="CONFTEST"
# Line 4411 | Line 5181 | cat >conftest.f90 <<EOF
5181   rm -f conftest*
5182   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5183   rm -f work*
5184 < cat >conftest.f90 <<EOF
5184 > cat >conftest.$ac_ext <<EOF
5185          module conftest
5186          integer n
5187          parameter (n=1)
# Line 4419 | Line 5189 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5189   EOF
5190   # SGI and absoft compilers generates module name in upper case!
5191   testname="conftest"
5192 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5193 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5192 > if (eval $ac_compile) 2>/dev/null ; then
5193 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5194     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5195     if test -n "$mod" ; then
5196        testname="CONFTEST"
# Line 4429 | Line 5199 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5199     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5200     cp $testname.$MOD conf
5201     rm -f conftest* CONFTEST*
5202 <   cat >conftest1.f90 <<EOF
5202 >   cat >conftest1.$ac_ext <<EOF
5203          program main
5204          use conftest
5205          print *, n
# Line 4437 | Line 5207 | EOF
5207   EOF
5208     F90_WORK_FILES_ARG=""
5209     F90MODINCSPEC=""
5210 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5210 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5211         MODDIRFLAG="-I"
5212         F90MODINCSPEC="-I<dir>"
5213         echo "$as_me:$LINENO: result: -I" >&5
5214   echo "${ECHO_T}-I" >&6
5215 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5215 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5216         MODDIRFLAG="-M"
5217         F90MODINCSPEC="-M<dir>"
5218         echo "$as_me:$LINENO: result: -M" >&5
5219   echo "${ECHO_T}-M" >&6
5220 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5220 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5221         MODDIRFLAG="-p"
5222         F90MODINCSPEC="-p<dir>"
5223         echo "$as_me:$LINENO: result: -p" >&5
# Line 4456 | Line 5226 | echo "${ECHO_T}-p" >&6
5226          cp work.pc conf/mpimod.pc
5227          echo "mpimod.pc" > conf/mpimod.pcl
5228          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5229 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5229 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5230              MODDIRFLAG='-cl,mpimod.pcl'
5231              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5232   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4486 | Line 5256 | else
5256   if test "${ac_cv_f90_module_names+set}" = set; then
5257    echo $ECHO_N "(cached) $ECHO_C" >&6
5258   else
5259 <  ac_ext=f90
5260 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5261 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5262 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5259 >  ac_ext=${FC_SRCEXT-f}
5260 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5261 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5262 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5263  
5264   # carry out the test in a new directory, so that we don't miss anything
5265   mkdir conftest
# Line 4507 | Line 5277 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5277    cat conftest.err >&5
5278    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5279    (exit $ac_status); } &&
5280 <         { ac_try='test -z "$ac_f90_werror_flag"
5280 >         { ac_try='test -z "$ac_fc_werror_flag"
5281                           || test ! -s conftest.err'
5282    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5283    (eval $ac_try) 2>&5
# Line 4623 | Line 5393 | ac_ext=f90
5393   cd ..
5394   # cleanup
5395   rm -rf conftest
5396 < ac_ext=f90
5397 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5398 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5399 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5396 > ac_ext=${FC_SRCEXT-f}
5397 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5398 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5399 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5400  
5401   fi
5402   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4715 | Line 5485 | ac_ext=cc
5485   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5486  
5487  
5488 < ac_ext=cc
5489 < ac_cpp='$CXXCPP $CPPFLAGS'
5490 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5491 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5492 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5488 > ac_ext=c
5489 > ac_cpp='$CPP $CPPFLAGS'
5490 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5491 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5492 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5493  
5494  
5495  
# Line 4744 | Line 5514 | int
5514   /* We use char because int might match the return type of a gcc2
5515     builtin and then its argument prototype would still apply.  */
5516   char asin ();
5517 + #ifdef FC_DUMMY_MAIN
5518 + #ifndef FC_DUMMY_MAIN_EQ_F77
5519 + #  ifdef __cplusplus
5520 +     extern "C"
5521 + #  endif
5522 +   int FC_DUMMY_MAIN() { return 1; }
5523 + #endif
5524 + #endif
5525   int
5526   main ()
5527   {
# Line 4761 | Line 5539 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5539    cat conftest.err >&5
5540    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5541    (exit $ac_status); } &&
5542 <         { ac_try='test -z "$ac_cxx_werror_flag"
5542 >         { ac_try='test -z "$ac_c_werror_flag"
5543                           || test ! -s conftest.err'
5544    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5545    (eval $ac_try) 2>&5
# Line 4799 | Line 5577 | ac_ext=c
5577   fi
5578  
5579  
4802 ac_ext=c
4803 ac_cpp='$CPP $CPPFLAGS'
4804 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4805 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4806 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4807
4808
5580   echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5581   echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5582   if test "${ac_cv_header_stdc+set}" = set; then
# Line 4822 | Line 5593 | int
5593   #include <string.h>
5594   #include <float.h>
5595  
5596 + #ifdef FC_DUMMY_MAIN
5597 + #ifndef FC_DUMMY_MAIN_EQ_F77
5598 + #  ifdef __cplusplus
5599 +     extern "C"
5600 + #  endif
5601 +   int FC_DUMMY_MAIN() { return 1; }
5602 + #endif
5603 + #endif
5604   int
5605   main ()
5606   {
# Line 5047 | Line 5826 | echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5826   #
5827   # Handle user hints
5828   #
5050 echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5051 echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5829  
5830   # Check whether --with-zlib or --without-zlib was given.
5831   if test "${with_zlib+set}" = set; then
5832    withval="$with_zlib"
5833 <  if test "$withval" != no ; then
5834 <  echo "$as_me:$LINENO: result: yes" >&5
5835 < echo "${ECHO_T}yes" >&6
5836 <  if test -d "$withval"
5833 >  zlib_dir="$withval"
5834 > else
5835 >                zlib_dir="not_set"
5836 > fi;
5837 > if test "$zlib_dir" != "no"; then
5838 >
5839 > if test "$zlib_dir" != "not_set" ; then
5840 >  if test -d "$zlib_dir"
5841    then
5842 <    ZLIB_HOME="$withval"
5842 >    ZLIB_HOME="$zlib_dir"
5843    else
5844 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5845 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5844 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5845 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5846    fi
5066 else
5067  echo "$as_me:$LINENO: result: no" >&5
5068 echo "${ECHO_T}no" >&6
5847   fi
5070 fi;
5848  
5849   ZLIB_HOME=/usr/local
5850   if test ! -f "${ZLIB_HOME}/include/zlib.h"
# Line 5113 | Line 5890 | int
5890   /* We use char because int might match the return type of a gcc2
5891     builtin and then its argument prototype would still apply.  */
5892   char inflateEnd ();
5893 + #ifdef FC_DUMMY_MAIN
5894 + #ifndef FC_DUMMY_MAIN_EQ_F77
5895 + #  ifdef __cplusplus
5896 +     extern "C"
5897 + #  endif
5898 +   int FC_DUMMY_MAIN() { return 1; }
5899 + #endif
5900 + #endif
5901   int
5902   main ()
5903   {
# Line 5312 | Line 6097 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
6097   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6098   ac_compiler_gnu=$ac_cv_c_compiler_gnu
6099  
6100 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6101 <        then
5317 <                #
5318 <                # If both library and header were found, use them
5319 <                #
6100 >
6101 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6102  
6103 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6104 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6105 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6103 > cat >>confdefs.h <<\_ACEOF
6104 > #define HAVE_ZLIB_H 1
6105 > _ACEOF
6106 >
6107 >
6108 > cat >>confdefs.h <<\_ACEOF
6109 > #define HAVE_LIBZ 1
6110 > _ACEOF
6111 >
6112 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6113 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6114 >                ZLIB="-lz"
6115 >        else
6116 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6117 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6118 >                ZLIB_INC_DIR=
6119 >                ZLIB_LIB_DIR=
6120 >                ZLIB=
6121 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6122 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6123 >                echo "$as_me:$LINENO: result: failed" >&5
6124 > echo "${ECHO_T}failed" >&6
6125 >                echo ""
6126 >                echo "*********************************************************"
6127 >                echo "* WARNING: Could not find a working zlib installation   *"
6128 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6129 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6130 >                echo "* installation with --with-zlib=DIR                     *"
6131 >                echo "*                                                       *"
6132 >                echo "* OOPSE will still work without zlib installed.         *"
6133 >                echo "*********************************************************"
6134 >                echo ""
6135 >        fi
6136 >
6137 >
6138 >
6139 > fi
6140 > fi
6141 >
6142 > #
6143 > # Handle user hints
6144 > #
6145 >
6146 > # Check whether --with-fftw or --without-fftw was given.
6147 > if test "${with_fftw+set}" = set; then
6148 >  withval="$with_fftw"
6149 >  fftw_dir="$withval"
6150 > else
6151 >             fftw_dir="not_set"
6152 > fi;
6153 > if test "$fftw_dir" != "no"; then
6154 >  if test "$fftw_dir" != "not_set" ; then
6155 >    if test -d "$fftw_dir"; then
6156 >      FFTW_HOME="$fftw_dir"
6157 >    else
6158 >      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6159 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6160 >      FFTW_HOME=/usr/local
6161 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6162 >        FFTW_HOME=/usr
6163 >      fi
6164 >    fi
6165 >    #
6166 >    # Locate fftw, if wanted
6167 >    #
6168 >    if test -n "${FFTW_HOME}"; then
6169 >      FFTW_OLD_LDFLAGS=$LDFLAGS
6170 >      FFTW_OLD_CPPFLAGS=$LDFLAGS
6171 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6172 >      CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6173 >
6174 >
6175 >      ac_ext=c
6176 > ac_cpp='$CPP $CPPFLAGS'
6177 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6178 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6179 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6180 >
6181 >      echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6182 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6183 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6184    echo $ECHO_N "(cached) $ECHO_C" >&6
6185   else
6186    ac_check_lib_save_LIBS=$LIBS
6187 < LIBS="-lz  $LIBS"
6187 > LIBS="-lfftw3  $LIBS"
6188   cat >conftest.$ac_ext <<_ACEOF
6189   /* confdefs.h.  */
6190   _ACEOF
# Line 5338 | Line 6198 | char inflateEnd ();
6198   #endif
6199   /* We use char because int might match the return type of a gcc2
6200     builtin and then its argument prototype would still apply.  */
6201 < char inflateEnd ();
6201 > char fftw_execute ();
6202 > #ifdef FC_DUMMY_MAIN
6203 > #ifndef FC_DUMMY_MAIN_EQ_F77
6204 > #  ifdef __cplusplus
6205 >     extern "C"
6206 > #  endif
6207 >   int FC_DUMMY_MAIN() { return 1; }
6208 > #endif
6209 > #endif
6210   int
6211   main ()
6212   {
6213 < inflateEnd ();
6213 > fftw_execute ();
6214    ;
6215    return 0;
6216   }
# Line 5369 | Line 6237 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6237    ac_status=$?
6238    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6239    (exit $ac_status); }; }; then
6240 <  ac_cv_lib_z_inflateEnd=yes
6240 >  ac_cv_lib_fftw3_fftw_execute=yes
6241   else
6242    echo "$as_me: failed program was:" >&5
6243   sed 's/^/| /' conftest.$ac_ext >&5
6244  
6245 < ac_cv_lib_z_inflateEnd=no
6245 > ac_cv_lib_fftw3_fftw_execute=no
6246   fi
6247   rm -f conftest.err conftest.$ac_objext \
6248        conftest$ac_exeext conftest.$ac_ext
6249   LIBS=$ac_check_lib_save_LIBS
6250   fi
6251 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6252 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6253 < if test $ac_cv_lib_z_inflateEnd = yes; then
6254 <  cat >>confdefs.h <<_ACEOF
6255 < #define HAVE_LIBZ 1
6256 < _ACEOF
5389 <
5390 <  LIBS="-lz $LIBS"
5391 <
6251 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6252 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6253 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6254 >  fftw_cv_libfftw3=yes
6255 > else
6256 >  fftw_cv_libfftw3=no
6257   fi
6258  
6259 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6260 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6261 <                echo "$as_me:$LINENO: result: ok" >&5
6262 < echo "${ECHO_T}ok" >&6
6263 <        else
6264 <                #
6265 <                # If either header or library was not found, revert and bomb
6266 <                #
6267 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6268 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6269 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6270 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6271 <                echo "$as_me:$LINENO: result: failed" >&5
6272 < echo "${ECHO_T}failed" >&6
6273 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6274 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6275 <   { (exit 1); exit 1; }; }
6276 <        fi
6277 < fi
6278 <
6279 <
6280 <
6281 <
6282 <
6283 <
6284 <
6285 <
6286 < for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
6287 < do
6288 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6289 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6290 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6291 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6292 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6293 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6294 < fi
6295 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6296 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6297 < else
6298 <  # Is the header compilable?
6299 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6300 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6301 < cat >conftest.$ac_ext <<_ACEOF
6302 < /* confdefs.h.  */
6303 < _ACEOF
6304 < cat confdefs.h >>conftest.$ac_ext
6305 < cat >>conftest.$ac_ext <<_ACEOF
6306 < /* end confdefs.h.  */
6307 < $ac_includes_default
6308 < #include <$ac_header>
6309 < _ACEOF
6310 < rm -f conftest.$ac_objext
6311 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6312 <  (eval $ac_compile) 2>conftest.er1
6313 <  ac_status=$?
6314 <  grep -v '^ *+' conftest.er1 >conftest.err
6315 <  rm -f conftest.er1
6316 <  cat conftest.err >&5
6317 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6318 <  (exit $ac_status); } &&
6319 <         { ac_try='test -z "$ac_c_werror_flag"
6320 <                         || test ! -s conftest.err'
6321 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6322 <  (eval $ac_try) 2>&5
6323 <  ac_status=$?
6324 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6325 <  (exit $ac_status); }; } &&
6326 <         { ac_try='test -s conftest.$ac_objext'
6327 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6328 <  (eval $ac_try) 2>&5
6329 <  ac_status=$?
6330 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6331 <  (exit $ac_status); }; }; then
6332 <  ac_header_compiler=yes
6333 < else
6334 <  echo "$as_me: failed program was:" >&5
6335 < sed 's/^/| /' conftest.$ac_ext >&5
6336 <
6337 < ac_header_compiler=no
6338 < fi
6339 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6340 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6341 < echo "${ECHO_T}$ac_header_compiler" >&6
6342 <
6343 < # Is the header present?
6344 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6345 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6346 < cat >conftest.$ac_ext <<_ACEOF
6347 < /* confdefs.h.  */
6348 < _ACEOF
6349 < cat confdefs.h >>conftest.$ac_ext
6350 < cat >>conftest.$ac_ext <<_ACEOF
6351 < /* end confdefs.h.  */
6352 < #include <$ac_header>
6353 < _ACEOF
6354 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6355 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6356 <  ac_status=$?
6357 <  grep -v '^ *+' conftest.er1 >conftest.err
6358 <  rm -f conftest.er1
6359 <  cat conftest.err >&5
6360 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6361 <  (exit $ac_status); } >/dev/null; then
6362 <  if test -s conftest.err; then
6363 <    ac_cpp_err=$ac_c_preproc_warn_flag
6364 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6365 <  else
6366 <    ac_cpp_err=
6367 <  fi
6368 < else
6369 <  ac_cpp_err=yes
6370 < fi
6371 < if test -z "$ac_cpp_err"; then
6372 <  ac_header_preproc=yes
6373 < else
6374 <  echo "$as_me: failed program was:" >&5
6375 < sed 's/^/| /' conftest.$ac_ext >&5
6376 <
6377 <  ac_header_preproc=no
6378 < fi
6379 < rm -f conftest.err conftest.$ac_ext
6380 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6381 < echo "${ECHO_T}$ac_header_preproc" >&6
6382 <
6383 < # So?  What about this header?
6384 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6385 <  yes:no: )
6386 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6387 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6388 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6389 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6390 <    ac_header_preproc=yes
6391 <    ;;
6392 <  no:yes:* )
6393 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6394 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6395 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6396 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6397 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6398 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6399 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6400 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6401 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6402 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6403 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6404 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6405 <    (
6406 <      cat <<\_ASBOX
6407 < ## ------------------------------ ##
6408 < ## Report this to gezelter@nd.edu ##
6409 < ## ------------------------------ ##
6410 < _ASBOX
6411 <    ) |
6412 <      sed "s/^/$as_me: WARNING:     /" >&2
6413 <    ;;
6414 < esac
6415 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6416 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6417 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6418 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6419 < else
6420 <  eval "$as_ac_Header=\$ac_header_preproc"
6421 < fi
6422 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6423 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6424 <
6425 < fi
6426 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6427 <  cat >>confdefs.h <<_ACEOF
6428 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6429 < _ACEOF
6430 <
6431 < fi
6432 <
6433 < done
6434 <
6435 <
6436 <
6437 <
6438 <
6439 <
6440 < for ac_header in strstream.h iostream.h fstream.h math.h time.h
6441 < do
6442 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6443 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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
6447 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6448 < fi
6449 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6450 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6451 < else
6452 <  # Is the header compilable?
6453 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6454 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6455 < cat >conftest.$ac_ext <<_ACEOF
6259 >      if test "${ac_cv_header_fftw3_h+set}" = set; then
6260 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6261 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6262 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6263 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6264 > fi
6265 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6266 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6267 > else
6268 >  # Is the header compilable?
6269 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6270 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6271 > cat >conftest.$ac_ext <<_ACEOF
6272 > /* confdefs.h.  */
6273 > _ACEOF
6274 > cat confdefs.h >>conftest.$ac_ext
6275 > cat >>conftest.$ac_ext <<_ACEOF
6276 > /* end confdefs.h.  */
6277 > $ac_includes_default
6278 > #include <fftw3.h>
6279 > _ACEOF
6280 > rm -f conftest.$ac_objext
6281 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6282 >  (eval $ac_compile) 2>conftest.er1
6283 >  ac_status=$?
6284 >  grep -v '^ *+' conftest.er1 >conftest.err
6285 >  rm -f conftest.er1
6286 >  cat conftest.err >&5
6287 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6288 >  (exit $ac_status); } &&
6289 >         { ac_try='test -z "$ac_c_werror_flag"
6290 >                         || test ! -s conftest.err'
6291 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6292 >  (eval $ac_try) 2>&5
6293 >  ac_status=$?
6294 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6295 >  (exit $ac_status); }; } &&
6296 >         { ac_try='test -s conftest.$ac_objext'
6297 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6298 >  (eval $ac_try) 2>&5
6299 >  ac_status=$?
6300 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6301 >  (exit $ac_status); }; }; then
6302 >  ac_header_compiler=yes
6303 > else
6304 >  echo "$as_me: failed program was:" >&5
6305 > sed 's/^/| /' conftest.$ac_ext >&5
6306 >
6307 > ac_header_compiler=no
6308 > fi
6309 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6310 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6311 > echo "${ECHO_T}$ac_header_compiler" >&6
6312 >
6313 > # Is the header present?
6314 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6315 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6316 > cat >conftest.$ac_ext <<_ACEOF
6317 > /* confdefs.h.  */
6318 > _ACEOF
6319 > cat confdefs.h >>conftest.$ac_ext
6320 > cat >>conftest.$ac_ext <<_ACEOF
6321 > /* end confdefs.h.  */
6322 > #include <fftw3.h>
6323 > _ACEOF
6324 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6325 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6326 >  ac_status=$?
6327 >  grep -v '^ *+' conftest.er1 >conftest.err
6328 >  rm -f conftest.er1
6329 >  cat conftest.err >&5
6330 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6331 >  (exit $ac_status); } >/dev/null; then
6332 >  if test -s conftest.err; then
6333 >    ac_cpp_err=$ac_c_preproc_warn_flag
6334 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6335 >  else
6336 >    ac_cpp_err=
6337 >  fi
6338 > else
6339 >  ac_cpp_err=yes
6340 > fi
6341 > if test -z "$ac_cpp_err"; then
6342 >  ac_header_preproc=yes
6343 > else
6344 >  echo "$as_me: failed program was:" >&5
6345 > sed 's/^/| /' conftest.$ac_ext >&5
6346 >
6347 >  ac_header_preproc=no
6348 > fi
6349 > rm -f conftest.err conftest.$ac_ext
6350 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6351 > echo "${ECHO_T}$ac_header_preproc" >&6
6352 >
6353 > # So?  What about this header?
6354 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6355 >  yes:no: )
6356 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6357 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6358 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6359 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6360 >    ac_header_preproc=yes
6361 >    ;;
6362 >  no:yes:* )
6363 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6364 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6365 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6366 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6367 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6368 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6369 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6370 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6371 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6372 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6373 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6374 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6375 >    (
6376 >      cat <<\_ASBOX
6377 > ## ------------------------------ ##
6378 > ## Report this to gezelter@nd.edu ##
6379 > ## ------------------------------ ##
6380 > _ASBOX
6381 >    ) |
6382 >      sed "s/^/$as_me: WARNING:     /" >&2
6383 >    ;;
6384 > esac
6385 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6386 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6387 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6388 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6389 > else
6390 >  ac_cv_header_fftw3_h=$ac_header_preproc
6391 > fi
6392 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6393 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6394 >
6395 > fi
6396 > if test $ac_cv_header_fftw3_h = yes; then
6397 >  fftw_cv_fftw3_h=yes
6398 > else
6399 >  fftw_cv_fftw3_h=no
6400 > fi
6401 >
6402 >
6403 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6404 >        echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6405 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6406 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6407 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6408 > else
6409 >  ac_check_lib_save_LIBS=$LIBS
6410 > LIBS="-lfftw  $LIBS"
6411 > cat >conftest.$ac_ext <<_ACEOF
6412 > /* confdefs.h.  */
6413 > _ACEOF
6414 > cat confdefs.h >>conftest.$ac_ext
6415 > cat >>conftest.$ac_ext <<_ACEOF
6416 > /* end confdefs.h.  */
6417 >
6418 > /* Override any gcc2 internal prototype to avoid an error.  */
6419 > #ifdef __cplusplus
6420 > extern "C"
6421 > #endif
6422 > /* We use char because int might match the return type of a gcc2
6423 >   builtin and then its argument prototype would still apply.  */
6424 > char fftwnd_one ();
6425 > #ifdef FC_DUMMY_MAIN
6426 > #ifndef FC_DUMMY_MAIN_EQ_F77
6427 > #  ifdef __cplusplus
6428 >     extern "C"
6429 > #  endif
6430 >   int FC_DUMMY_MAIN() { return 1; }
6431 > #endif
6432 > #endif
6433 > int
6434 > main ()
6435 > {
6436 > fftwnd_one ();
6437 >  ;
6438 >  return 0;
6439 > }
6440 > _ACEOF
6441 > rm -f conftest.$ac_objext conftest$ac_exeext
6442 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6443 >  (eval $ac_link) 2>conftest.er1
6444 >  ac_status=$?
6445 >  grep -v '^ *+' conftest.er1 >conftest.err
6446 >  rm -f conftest.er1
6447 >  cat conftest.err >&5
6448 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6449 >  (exit $ac_status); } &&
6450 >         { ac_try='test -z "$ac_c_werror_flag"
6451 >                         || test ! -s conftest.err'
6452 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6453 >  (eval $ac_try) 2>&5
6454 >  ac_status=$?
6455 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6456 >  (exit $ac_status); }; } &&
6457 >         { ac_try='test -s conftest$ac_exeext'
6458 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6459 >  (eval $ac_try) 2>&5
6460 >  ac_status=$?
6461 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6462 >  (exit $ac_status); }; }; then
6463 >  ac_cv_lib_fftw_fftwnd_one=yes
6464 > else
6465 >  echo "$as_me: failed program was:" >&5
6466 > sed 's/^/| /' conftest.$ac_ext >&5
6467 >
6468 > ac_cv_lib_fftw_fftwnd_one=no
6469 > fi
6470 > rm -f conftest.err conftest.$ac_objext \
6471 >      conftest$ac_exeext conftest.$ac_ext
6472 > LIBS=$ac_check_lib_save_LIBS
6473 > fi
6474 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6475 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6476 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6477 >  fftw_cv_libfftw=yes
6478 > else
6479 >  fftw_cv_libfftw=no
6480 > fi
6481 >
6482 >        if test "${ac_cv_header_fftw_h+set}" = set; then
6483 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6484 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6485 > if test "${ac_cv_header_fftw_h+set}" = set; then
6486 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6487 > fi
6488 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6489 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6490 > else
6491 >  # Is the header compilable?
6492 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6493 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6494 > cat >conftest.$ac_ext <<_ACEOF
6495 > /* confdefs.h.  */
6496 > _ACEOF
6497 > cat confdefs.h >>conftest.$ac_ext
6498 > cat >>conftest.$ac_ext <<_ACEOF
6499 > /* end confdefs.h.  */
6500 > $ac_includes_default
6501 > #include <fftw.h>
6502 > _ACEOF
6503 > rm -f conftest.$ac_objext
6504 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6505 >  (eval $ac_compile) 2>conftest.er1
6506 >  ac_status=$?
6507 >  grep -v '^ *+' conftest.er1 >conftest.err
6508 >  rm -f conftest.er1
6509 >  cat conftest.err >&5
6510 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6511 >  (exit $ac_status); } &&
6512 >         { ac_try='test -z "$ac_c_werror_flag"
6513 >                         || test ! -s conftest.err'
6514 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6515 >  (eval $ac_try) 2>&5
6516 >  ac_status=$?
6517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6518 >  (exit $ac_status); }; } &&
6519 >         { ac_try='test -s conftest.$ac_objext'
6520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6521 >  (eval $ac_try) 2>&5
6522 >  ac_status=$?
6523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6524 >  (exit $ac_status); }; }; then
6525 >  ac_header_compiler=yes
6526 > else
6527 >  echo "$as_me: failed program was:" >&5
6528 > sed 's/^/| /' conftest.$ac_ext >&5
6529 >
6530 > ac_header_compiler=no
6531 > fi
6532 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6533 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6534 > echo "${ECHO_T}$ac_header_compiler" >&6
6535 >
6536 > # Is the header present?
6537 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6538 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6539 > cat >conftest.$ac_ext <<_ACEOF
6540 > /* confdefs.h.  */
6541 > _ACEOF
6542 > cat confdefs.h >>conftest.$ac_ext
6543 > cat >>conftest.$ac_ext <<_ACEOF
6544 > /* end confdefs.h.  */
6545 > #include <fftw.h>
6546 > _ACEOF
6547 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6548 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6549 >  ac_status=$?
6550 >  grep -v '^ *+' conftest.er1 >conftest.err
6551 >  rm -f conftest.er1
6552 >  cat conftest.err >&5
6553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6554 >  (exit $ac_status); } >/dev/null; then
6555 >  if test -s conftest.err; then
6556 >    ac_cpp_err=$ac_c_preproc_warn_flag
6557 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6558 >  else
6559 >    ac_cpp_err=
6560 >  fi
6561 > else
6562 >  ac_cpp_err=yes
6563 > fi
6564 > if test -z "$ac_cpp_err"; then
6565 >  ac_header_preproc=yes
6566 > else
6567 >  echo "$as_me: failed program was:" >&5
6568 > sed 's/^/| /' conftest.$ac_ext >&5
6569 >
6570 >  ac_header_preproc=no
6571 > fi
6572 > rm -f conftest.err conftest.$ac_ext
6573 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6574 > echo "${ECHO_T}$ac_header_preproc" >&6
6575 >
6576 > # So?  What about this header?
6577 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6578 >  yes:no: )
6579 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6580 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6581 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6582 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6583 >    ac_header_preproc=yes
6584 >    ;;
6585 >  no:yes:* )
6586 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6587 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6588 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6589 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6590 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6591 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6592 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6593 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6594 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6595 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6596 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6597 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6598 >    (
6599 >      cat <<\_ASBOX
6600 > ## ------------------------------ ##
6601 > ## Report this to gezelter@nd.edu ##
6602 > ## ------------------------------ ##
6603 > _ASBOX
6604 >    ) |
6605 >      sed "s/^/$as_me: WARNING:     /" >&2
6606 >    ;;
6607 > esac
6608 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6609 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6610 > if test "${ac_cv_header_fftw_h+set}" = set; then
6611 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6612 > else
6613 >  ac_cv_header_fftw_h=$ac_header_preproc
6614 > fi
6615 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6616 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6617 >
6618 > fi
6619 > if test $ac_cv_header_fftw_h = yes; then
6620 >  fftw_cv_fftw_h=yes
6621 > else
6622 >  fftw_cv_fftw_h=no
6623 > fi
6624 >
6625 >
6626 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6627 >          echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6628 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6629 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6630 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6631 > else
6632 >  ac_check_lib_save_LIBS=$LIBS
6633 > LIBS="-ldfftw  $LIBS"
6634 > cat >conftest.$ac_ext <<_ACEOF
6635 > /* confdefs.h.  */
6636 > _ACEOF
6637 > cat confdefs.h >>conftest.$ac_ext
6638 > cat >>conftest.$ac_ext <<_ACEOF
6639 > /* end confdefs.h.  */
6640 >
6641 > /* Override any gcc2 internal prototype to avoid an error.  */
6642 > #ifdef __cplusplus
6643 > extern "C"
6644 > #endif
6645 > /* We use char because int might match the return type of a gcc2
6646 >   builtin and then its argument prototype would still apply.  */
6647 > char fftwnd_one ();
6648 > #ifdef FC_DUMMY_MAIN
6649 > #ifndef FC_DUMMY_MAIN_EQ_F77
6650 > #  ifdef __cplusplus
6651 >     extern "C"
6652 > #  endif
6653 >   int FC_DUMMY_MAIN() { return 1; }
6654 > #endif
6655 > #endif
6656 > int
6657 > main ()
6658 > {
6659 > fftwnd_one ();
6660 >  ;
6661 >  return 0;
6662 > }
6663 > _ACEOF
6664 > rm -f conftest.$ac_objext conftest$ac_exeext
6665 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6666 >  (eval $ac_link) 2>conftest.er1
6667 >  ac_status=$?
6668 >  grep -v '^ *+' conftest.er1 >conftest.err
6669 >  rm -f conftest.er1
6670 >  cat conftest.err >&5
6671 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6672 >  (exit $ac_status); } &&
6673 >         { ac_try='test -z "$ac_c_werror_flag"
6674 >                         || test ! -s conftest.err'
6675 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6676 >  (eval $ac_try) 2>&5
6677 >  ac_status=$?
6678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6679 >  (exit $ac_status); }; } &&
6680 >         { ac_try='test -s conftest$ac_exeext'
6681 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6682 >  (eval $ac_try) 2>&5
6683 >  ac_status=$?
6684 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6685 >  (exit $ac_status); }; }; then
6686 >  ac_cv_lib_dfftw_fftwnd_one=yes
6687 > else
6688 >  echo "$as_me: failed program was:" >&5
6689 > sed 's/^/| /' conftest.$ac_ext >&5
6690 >
6691 > ac_cv_lib_dfftw_fftwnd_one=no
6692 > fi
6693 > rm -f conftest.err conftest.$ac_objext \
6694 >      conftest$ac_exeext conftest.$ac_ext
6695 > LIBS=$ac_check_lib_save_LIBS
6696 > fi
6697 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6698 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6699 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6700 >  fftw_cv_libdfftw=yes
6701 > else
6702 >  fftw_cv_libdfftw=no
6703 > fi
6704 >
6705 >          if test "${ac_cv_header_dfftw_h+set}" = set; then
6706 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6707 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6708 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6709 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6710 > fi
6711 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6712 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6713 > else
6714 >  # Is the header compilable?
6715 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6716 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6717 > cat >conftest.$ac_ext <<_ACEOF
6718 > /* confdefs.h.  */
6719 > _ACEOF
6720 > cat confdefs.h >>conftest.$ac_ext
6721 > cat >>conftest.$ac_ext <<_ACEOF
6722 > /* end confdefs.h.  */
6723 > $ac_includes_default
6724 > #include <dfftw.h>
6725 > _ACEOF
6726 > rm -f conftest.$ac_objext
6727 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6728 >  (eval $ac_compile) 2>conftest.er1
6729 >  ac_status=$?
6730 >  grep -v '^ *+' conftest.er1 >conftest.err
6731 >  rm -f conftest.er1
6732 >  cat conftest.err >&5
6733 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6734 >  (exit $ac_status); } &&
6735 >         { ac_try='test -z "$ac_c_werror_flag"
6736 >                         || test ! -s conftest.err'
6737 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6738 >  (eval $ac_try) 2>&5
6739 >  ac_status=$?
6740 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6741 >  (exit $ac_status); }; } &&
6742 >         { ac_try='test -s conftest.$ac_objext'
6743 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6744 >  (eval $ac_try) 2>&5
6745 >  ac_status=$?
6746 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6747 >  (exit $ac_status); }; }; then
6748 >  ac_header_compiler=yes
6749 > else
6750 >  echo "$as_me: failed program was:" >&5
6751 > sed 's/^/| /' conftest.$ac_ext >&5
6752 >
6753 > ac_header_compiler=no
6754 > fi
6755 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6756 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6757 > echo "${ECHO_T}$ac_header_compiler" >&6
6758 >
6759 > # Is the header present?
6760 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6761 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6762 > cat >conftest.$ac_ext <<_ACEOF
6763 > /* confdefs.h.  */
6764 > _ACEOF
6765 > cat confdefs.h >>conftest.$ac_ext
6766 > cat >>conftest.$ac_ext <<_ACEOF
6767 > /* end confdefs.h.  */
6768 > #include <dfftw.h>
6769 > _ACEOF
6770 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6771 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6772 >  ac_status=$?
6773 >  grep -v '^ *+' conftest.er1 >conftest.err
6774 >  rm -f conftest.er1
6775 >  cat conftest.err >&5
6776 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6777 >  (exit $ac_status); } >/dev/null; then
6778 >  if test -s conftest.err; then
6779 >    ac_cpp_err=$ac_c_preproc_warn_flag
6780 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6781 >  else
6782 >    ac_cpp_err=
6783 >  fi
6784 > else
6785 >  ac_cpp_err=yes
6786 > fi
6787 > if test -z "$ac_cpp_err"; then
6788 >  ac_header_preproc=yes
6789 > else
6790 >  echo "$as_me: failed program was:" >&5
6791 > sed 's/^/| /' conftest.$ac_ext >&5
6792 >
6793 >  ac_header_preproc=no
6794 > fi
6795 > rm -f conftest.err conftest.$ac_ext
6796 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6797 > echo "${ECHO_T}$ac_header_preproc" >&6
6798 >
6799 > # So?  What about this header?
6800 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6801 >  yes:no: )
6802 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6803 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6804 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6805 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6806 >    ac_header_preproc=yes
6807 >    ;;
6808 >  no:yes:* )
6809 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6810 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6811 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6812 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6813 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6814 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6815 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6816 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6817 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6818 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6819 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6820 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6821 >    (
6822 >      cat <<\_ASBOX
6823 > ## ------------------------------ ##
6824 > ## Report this to gezelter@nd.edu ##
6825 > ## ------------------------------ ##
6826 > _ASBOX
6827 >    ) |
6828 >      sed "s/^/$as_me: WARNING:     /" >&2
6829 >    ;;
6830 > esac
6831 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6832 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6833 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6834 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6835 > else
6836 >  ac_cv_header_dfftw_h=$ac_header_preproc
6837 > fi
6838 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6839 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6840 >
6841 > fi
6842 > if test $ac_cv_header_dfftw_h = yes; then
6843 >  fftw_cv_dfftw_h=yes
6844 > else
6845 >  fftw_cv_dfftw_h=no
6846 > fi
6847 >
6848 >
6849 >        fi
6850 >      fi
6851 >      ac_ext=c
6852 > ac_cpp='$CPP $CPPFLAGS'
6853 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6854 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6855 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6856 >
6857 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6858 >
6859 > cat >>confdefs.h <<\_ACEOF
6860 > #define HAVE_FFTW3_H 1
6861 > _ACEOF
6862 >
6863 >        FFTW_INC_DIR="${FFTW_HOME}/include"
6864 >        FFTW_LIB_DIR="${FFTW_HOME}/lib"
6865 >        FFTW_LIBS="-lfftw3"
6866 >      else
6867 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6868 >
6869 > cat >>confdefs.h <<\_ACEOF
6870 > #define HAVE_FFTW_H 1
6871 > _ACEOF
6872 >
6873 >          FFTW_INC_DIR="${FFTW_HOME}/include"
6874 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
6875 >          FFTW_LIBS="-lfftw"
6876 >        else
6877 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6878 >
6879 > cat >>confdefs.h <<\_ACEOF
6880 > #define HAVE_DFFTW_H 1
6881 > _ACEOF
6882 >
6883 >            FFTW_INC_DIR="${FFTW_HOME}/include"
6884 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
6885 >            FFTW_LIBS="-ldfftw"
6886 >          else
6887 >            echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6888 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6889 >            FFTW_INC_DIR=
6890 >            FFTW_LIB_DIR=
6891 >            FFTW_LIBS=
6892 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
6893 >            CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6894 >            echo "$as_me:$LINENO: result: failed" >&5
6895 > echo "${ECHO_T}failed" >&6
6896 >            echo ""
6897 >            echo "*********************************************************"
6898 >            echo "* WARNING: Could not find a working FFTW installation   *"
6899 >            echo "* If you need the staticProps program to be able to     *"
6900 >            echo "* compute undulation spectra, be sure to specify a      *"
6901 >            echo "* valid fftw installation with --with-fftw=DIR          *"
6902 >            echo "*                                                       *"
6903 >            echo "* OOPSE will still work without fftw installed.         *"
6904 >            echo "*********************************************************"
6905 >            echo ""
6906 >          fi
6907 >        fi
6908 >      fi
6909 >
6910 >
6911 >
6912 >    fi
6913 >  fi
6914 > fi
6915 >
6916 >
6917 >
6918 > # Checks for header files.
6919 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6920 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6921 > if test "${ac_cv_header_stdc+set}" = set; then
6922 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6923 > else
6924 >  cat >conftest.$ac_ext <<_ACEOF
6925 > /* confdefs.h.  */
6926 > _ACEOF
6927 > cat confdefs.h >>conftest.$ac_ext
6928 > cat >>conftest.$ac_ext <<_ACEOF
6929 > /* end confdefs.h.  */
6930 > #include <stdlib.h>
6931 > #include <stdarg.h>
6932 > #include <string.h>
6933 > #include <float.h>
6934 >
6935 > #ifdef FC_DUMMY_MAIN
6936 > #ifndef FC_DUMMY_MAIN_EQ_F77
6937 > #  ifdef __cplusplus
6938 >     extern "C"
6939 > #  endif
6940 >   int FC_DUMMY_MAIN() { return 1; }
6941 > #endif
6942 > #endif
6943 > int
6944 > main ()
6945 > {
6946 >
6947 >  ;
6948 >  return 0;
6949 > }
6950 > _ACEOF
6951 > rm -f conftest.$ac_objext
6952 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6953 >  (eval $ac_compile) 2>conftest.er1
6954 >  ac_status=$?
6955 >  grep -v '^ *+' conftest.er1 >conftest.err
6956 >  rm -f conftest.er1
6957 >  cat conftest.err >&5
6958 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6959 >  (exit $ac_status); } &&
6960 >         { ac_try='test -z "$ac_c_werror_flag"
6961 >                         || test ! -s conftest.err'
6962 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6963 >  (eval $ac_try) 2>&5
6964 >  ac_status=$?
6965 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6966 >  (exit $ac_status); }; } &&
6967 >         { ac_try='test -s conftest.$ac_objext'
6968 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6969 >  (eval $ac_try) 2>&5
6970 >  ac_status=$?
6971 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6972 >  (exit $ac_status); }; }; then
6973 >  ac_cv_header_stdc=yes
6974 > else
6975 >  echo "$as_me: failed program was:" >&5
6976 > sed 's/^/| /' conftest.$ac_ext >&5
6977 >
6978 > ac_cv_header_stdc=no
6979 > fi
6980 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6981 >
6982 > if test $ac_cv_header_stdc = yes; then
6983 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6984 >  cat >conftest.$ac_ext <<_ACEOF
6985 > /* confdefs.h.  */
6986 > _ACEOF
6987 > cat confdefs.h >>conftest.$ac_ext
6988 > cat >>conftest.$ac_ext <<_ACEOF
6989 > /* end confdefs.h.  */
6990 > #include <string.h>
6991 >
6992 > _ACEOF
6993 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6994 >  $EGREP "memchr" >/dev/null 2>&1; then
6995 >  :
6996 > else
6997 >  ac_cv_header_stdc=no
6998 > fi
6999 > rm -f conftest*
7000 >
7001 > fi
7002 >
7003 > if test $ac_cv_header_stdc = yes; then
7004 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7005 >  cat >conftest.$ac_ext <<_ACEOF
7006 > /* confdefs.h.  */
7007 > _ACEOF
7008 > cat confdefs.h >>conftest.$ac_ext
7009 > cat >>conftest.$ac_ext <<_ACEOF
7010 > /* end confdefs.h.  */
7011 > #include <stdlib.h>
7012 >
7013 > _ACEOF
7014 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7015 >  $EGREP "free" >/dev/null 2>&1; then
7016 >  :
7017 > else
7018 >  ac_cv_header_stdc=no
7019 > fi
7020 > rm -f conftest*
7021 >
7022 > fi
7023 >
7024 > if test $ac_cv_header_stdc = yes; then
7025 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7026 >  if test "$cross_compiling" = yes; then
7027 >  :
7028 > else
7029 >  cat >conftest.$ac_ext <<_ACEOF
7030 > /* confdefs.h.  */
7031 > _ACEOF
7032 > cat confdefs.h >>conftest.$ac_ext
7033 > cat >>conftest.$ac_ext <<_ACEOF
7034 > /* end confdefs.h.  */
7035 > #include <ctype.h>
7036 > #if ((' ' & 0x0FF) == 0x020)
7037 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7038 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7039 > #else
7040 > # define ISLOWER(c) \
7041 >                   (('a' <= (c) && (c) <= 'i') \
7042 >                     || ('j' <= (c) && (c) <= 'r') \
7043 >                     || ('s' <= (c) && (c) <= 'z'))
7044 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7045 > #endif
7046 >
7047 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7048 > int
7049 > main ()
7050 > {
7051 >  int i;
7052 >  for (i = 0; i < 256; i++)
7053 >    if (XOR (islower (i), ISLOWER (i))
7054 >        || toupper (i) != TOUPPER (i))
7055 >      exit(2);
7056 >  exit (0);
7057 > }
7058 > _ACEOF
7059 > rm -f conftest$ac_exeext
7060 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7061 >  (eval $ac_link) 2>&5
7062 >  ac_status=$?
7063 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7064 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7065 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7066 >  (eval $ac_try) 2>&5
7067 >  ac_status=$?
7068 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7069 >  (exit $ac_status); }; }; then
7070 >  :
7071 > else
7072 >  echo "$as_me: program exited with status $ac_status" >&5
7073 > echo "$as_me: failed program was:" >&5
7074 > sed 's/^/| /' conftest.$ac_ext >&5
7075 >
7076 > ( exit $ac_status )
7077 > ac_cv_header_stdc=no
7078 > fi
7079 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7080 > fi
7081 > fi
7082 > fi
7083 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7084 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7085 > if test $ac_cv_header_stdc = yes; then
7086 >
7087 > cat >>confdefs.h <<\_ACEOF
7088 > #define STDC_HEADERS 1
7089 > _ACEOF
7090 >
7091 > fi
7092 >
7093 >
7094 >
7095 >
7096 >
7097 >
7098 >
7099 >
7100 >
7101 >
7102 >
7103 >
7104 >
7105 >
7106 >
7107 >
7108 >
7109 >
7110 >
7111 >
7112 >
7113 >
7114 >
7115 >
7116 >
7117 >
7118 > 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
7119 > do
7120 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7121 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7122 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7123 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7124 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7125 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7126 > fi
7127 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7128 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7129 > else
7130 >  # Is the header compilable?
7131 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7132 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7133 > cat >conftest.$ac_ext <<_ACEOF
7134 > /* confdefs.h.  */
7135 > _ACEOF
7136 > cat confdefs.h >>conftest.$ac_ext
7137 > cat >>conftest.$ac_ext <<_ACEOF
7138 > /* end confdefs.h.  */
7139 > $ac_includes_default
7140 > #include <$ac_header>
7141 > _ACEOF
7142 > rm -f conftest.$ac_objext
7143 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7144 >  (eval $ac_compile) 2>conftest.er1
7145 >  ac_status=$?
7146 >  grep -v '^ *+' conftest.er1 >conftest.err
7147 >  rm -f conftest.er1
7148 >  cat conftest.err >&5
7149 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7150 >  (exit $ac_status); } &&
7151 >         { ac_try='test -z "$ac_c_werror_flag"
7152 >                         || test ! -s conftest.err'
7153 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7154 >  (eval $ac_try) 2>&5
7155 >  ac_status=$?
7156 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7157 >  (exit $ac_status); }; } &&
7158 >         { ac_try='test -s conftest.$ac_objext'
7159 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7160 >  (eval $ac_try) 2>&5
7161 >  ac_status=$?
7162 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7163 >  (exit $ac_status); }; }; then
7164 >  ac_header_compiler=yes
7165 > else
7166 >  echo "$as_me: failed program was:" >&5
7167 > sed 's/^/| /' conftest.$ac_ext >&5
7168 >
7169 > ac_header_compiler=no
7170 > fi
7171 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7172 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7173 > echo "${ECHO_T}$ac_header_compiler" >&6
7174 >
7175 > # Is the header present?
7176 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7177 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7178 > cat >conftest.$ac_ext <<_ACEOF
7179 > /* confdefs.h.  */
7180 > _ACEOF
7181 > cat confdefs.h >>conftest.$ac_ext
7182 > cat >>conftest.$ac_ext <<_ACEOF
7183 > /* end confdefs.h.  */
7184 > #include <$ac_header>
7185 > _ACEOF
7186 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7187 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7188 >  ac_status=$?
7189 >  grep -v '^ *+' conftest.er1 >conftest.err
7190 >  rm -f conftest.er1
7191 >  cat conftest.err >&5
7192 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7193 >  (exit $ac_status); } >/dev/null; then
7194 >  if test -s conftest.err; then
7195 >    ac_cpp_err=$ac_c_preproc_warn_flag
7196 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7197 >  else
7198 >    ac_cpp_err=
7199 >  fi
7200 > else
7201 >  ac_cpp_err=yes
7202 > fi
7203 > if test -z "$ac_cpp_err"; then
7204 >  ac_header_preproc=yes
7205 > else
7206 >  echo "$as_me: failed program was:" >&5
7207 > sed 's/^/| /' conftest.$ac_ext >&5
7208 >
7209 >  ac_header_preproc=no
7210 > fi
7211 > rm -f conftest.err conftest.$ac_ext
7212 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7213 > echo "${ECHO_T}$ac_header_preproc" >&6
7214 >
7215 > # So?  What about this header?
7216 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7217 >  yes:no: )
7218 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7219 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7220 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7221 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7222 >    ac_header_preproc=yes
7223 >    ;;
7224 >  no:yes:* )
7225 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7226 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7227 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7228 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7229 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7230 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7231 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7232 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7233 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7234 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7235 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7236 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7237 >    (
7238 >      cat <<\_ASBOX
7239 > ## ------------------------------ ##
7240 > ## Report this to gezelter@nd.edu ##
7241 > ## ------------------------------ ##
7242 > _ASBOX
7243 >    ) |
7244 >      sed "s/^/$as_me: WARNING:     /" >&2
7245 >    ;;
7246 > esac
7247 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7248 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7249 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7250 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7251 > else
7252 >  eval "$as_ac_Header=\$ac_header_preproc"
7253 > fi
7254 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7255 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7256 >
7257 > fi
7258 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7259 >  cat >>confdefs.h <<_ACEOF
7260 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7261 > _ACEOF
7262 >
7263 > fi
7264 >
7265 > done
7266 >
7267 >
7268 > # Checks for typedefs, structures, and compiler characteristics.
7269 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7270 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7271 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7272 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7273 > else
7274 >  cat >conftest.$ac_ext <<_ACEOF
7275 > /* confdefs.h.  */
7276 > _ACEOF
7277 > cat confdefs.h >>conftest.$ac_ext
7278 > cat >>conftest.$ac_ext <<_ACEOF
7279 > /* end confdefs.h.  */
7280 >
7281 > #include <stdbool.h>
7282 > #ifndef bool
7283 > # error bool is not defined
7284 > #endif
7285 > #ifndef false
7286 > # error false is not defined
7287 > #endif
7288 > #if false
7289 > # error false is not 0
7290 > #endif
7291 > #ifndef true
7292 > # error true is not defined
7293 > #endif
7294 > #if true != 1
7295 > # error true is not 1
7296 > #endif
7297 > #ifndef __bool_true_false_are_defined
7298 > # error __bool_true_false_are_defined is not defined
7299 > #endif
7300 >
7301 >        struct s { _Bool s: 1; _Bool t; } s;
7302 >
7303 >        char a[true == 1 ? 1 : -1];
7304 >        char b[false == 0 ? 1 : -1];
7305 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7306 >        char d[(bool) -0.5 == true ? 1 : -1];
7307 >        bool e = &s;
7308 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7309 >        char g[true];
7310 >        char h[sizeof (_Bool)];
7311 >        char i[sizeof s.t];
7312 >
7313 > #ifdef FC_DUMMY_MAIN
7314 > #ifndef FC_DUMMY_MAIN_EQ_F77
7315 > #  ifdef __cplusplus
7316 >     extern "C"
7317 > #  endif
7318 >   int FC_DUMMY_MAIN() { return 1; }
7319 > #endif
7320 > #endif
7321 > int
7322 > main ()
7323 > {
7324 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7325 >  ;
7326 >  return 0;
7327 > }
7328 > _ACEOF
7329 > rm -f conftest.$ac_objext
7330 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7331 >  (eval $ac_compile) 2>conftest.er1
7332 >  ac_status=$?
7333 >  grep -v '^ *+' conftest.er1 >conftest.err
7334 >  rm -f conftest.er1
7335 >  cat conftest.err >&5
7336 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7337 >  (exit $ac_status); } &&
7338 >         { ac_try='test -z "$ac_c_werror_flag"
7339 >                         || test ! -s conftest.err'
7340 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7341 >  (eval $ac_try) 2>&5
7342 >  ac_status=$?
7343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7344 >  (exit $ac_status); }; } &&
7345 >         { ac_try='test -s conftest.$ac_objext'
7346 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7347 >  (eval $ac_try) 2>&5
7348 >  ac_status=$?
7349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7350 >  (exit $ac_status); }; }; then
7351 >  ac_cv_header_stdbool_h=yes
7352 > else
7353 >  echo "$as_me: failed program was:" >&5
7354 > sed 's/^/| /' conftest.$ac_ext >&5
7355 >
7356 > ac_cv_header_stdbool_h=no
7357 > fi
7358 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7359 > fi
7360 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7361 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7362 > echo "$as_me:$LINENO: checking for _Bool" >&5
7363 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7364 > if test "${ac_cv_type__Bool+set}" = set; then
7365 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7366 > else
7367 >  cat >conftest.$ac_ext <<_ACEOF
7368 > /* confdefs.h.  */
7369 > _ACEOF
7370 > cat confdefs.h >>conftest.$ac_ext
7371 > cat >>conftest.$ac_ext <<_ACEOF
7372 > /* end confdefs.h.  */
7373 > $ac_includes_default
7374 > #ifdef FC_DUMMY_MAIN
7375 > #ifndef FC_DUMMY_MAIN_EQ_F77
7376 > #  ifdef __cplusplus
7377 >     extern "C"
7378 > #  endif
7379 >   int FC_DUMMY_MAIN() { return 1; }
7380 > #endif
7381 > #endif
7382 > int
7383 > main ()
7384 > {
7385 > if ((_Bool *) 0)
7386 >  return 0;
7387 > if (sizeof (_Bool))
7388 >  return 0;
7389 >  ;
7390 >  return 0;
7391 > }
7392 > _ACEOF
7393 > rm -f conftest.$ac_objext
7394 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7395 >  (eval $ac_compile) 2>conftest.er1
7396 >  ac_status=$?
7397 >  grep -v '^ *+' conftest.er1 >conftest.err
7398 >  rm -f conftest.er1
7399 >  cat conftest.err >&5
7400 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7401 >  (exit $ac_status); } &&
7402 >         { ac_try='test -z "$ac_c_werror_flag"
7403 >                         || test ! -s conftest.err'
7404 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7405 >  (eval $ac_try) 2>&5
7406 >  ac_status=$?
7407 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7408 >  (exit $ac_status); }; } &&
7409 >         { ac_try='test -s conftest.$ac_objext'
7410 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7411 >  (eval $ac_try) 2>&5
7412 >  ac_status=$?
7413 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7414 >  (exit $ac_status); }; }; then
7415 >  ac_cv_type__Bool=yes
7416 > else
7417 >  echo "$as_me: failed program was:" >&5
7418 > sed 's/^/| /' conftest.$ac_ext >&5
7419 >
7420 > ac_cv_type__Bool=no
7421 > fi
7422 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7423 > fi
7424 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7425 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7426 > if test $ac_cv_type__Bool = yes; then
7427 >
7428 > cat >>confdefs.h <<_ACEOF
7429 > #define HAVE__BOOL 1
7430 > _ACEOF
7431 >
7432 >
7433 > fi
7434 >
7435 > if test $ac_cv_header_stdbool_h = yes; then
7436 >
7437 > cat >>confdefs.h <<\_ACEOF
7438 > #define HAVE_STDBOOL_H 1
7439 > _ACEOF
7440 >
7441 > fi
7442 >
7443 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7444 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7445 > if test "${ac_cv_c_const+set}" = set; then
7446 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7447 > else
7448 >  cat >conftest.$ac_ext <<_ACEOF
7449 > /* confdefs.h.  */
7450 > _ACEOF
7451 > cat confdefs.h >>conftest.$ac_ext
7452 > cat >>conftest.$ac_ext <<_ACEOF
7453 > /* end confdefs.h.  */
7454 >
7455 > #ifdef FC_DUMMY_MAIN
7456 > #ifndef FC_DUMMY_MAIN_EQ_F77
7457 > #  ifdef __cplusplus
7458 >     extern "C"
7459 > #  endif
7460 >   int FC_DUMMY_MAIN() { return 1; }
7461 > #endif
7462 > #endif
7463 > int
7464 > main ()
7465 > {
7466 > /* FIXME: Include the comments suggested by Paul. */
7467 > #ifndef __cplusplus
7468 >  /* Ultrix mips cc rejects this.  */
7469 >  typedef int charset[2];
7470 >  const charset x;
7471 >  /* SunOS 4.1.1 cc rejects this.  */
7472 >  char const *const *ccp;
7473 >  char **p;
7474 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7475 >  struct point {int x, y;};
7476 >  static struct point const zero = {0,0};
7477 >  /* AIX XL C 1.02.0.0 rejects this.
7478 >     It does not let you subtract one const X* pointer from another in
7479 >     an arm of an if-expression whose if-part is not a constant
7480 >     expression */
7481 >  const char *g = "string";
7482 >  ccp = &g + (g ? g-g : 0);
7483 >  /* HPUX 7.0 cc rejects these. */
7484 >  ++ccp;
7485 >  p = (char**) ccp;
7486 >  ccp = (char const *const *) p;
7487 >  { /* SCO 3.2v4 cc rejects this.  */
7488 >    char *t;
7489 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7490 >
7491 >    *t++ = 0;
7492 >  }
7493 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7494 >    int x[] = {25, 17};
7495 >    const int *foo = &x[0];
7496 >    ++foo;
7497 >  }
7498 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7499 >    typedef const int *iptr;
7500 >    iptr p = 0;
7501 >    ++p;
7502 >  }
7503 >  { /* AIX XL C 1.02.0.0 rejects this saying
7504 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7505 >    struct s { int j; const int *ap[3]; };
7506 >    struct s *b; b->j = 5;
7507 >  }
7508 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7509 >    const int foo = 10;
7510 >  }
7511 > #endif
7512 >
7513 >  ;
7514 >  return 0;
7515 > }
7516 > _ACEOF
7517 > rm -f conftest.$ac_objext
7518 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7519 >  (eval $ac_compile) 2>conftest.er1
7520 >  ac_status=$?
7521 >  grep -v '^ *+' conftest.er1 >conftest.err
7522 >  rm -f conftest.er1
7523 >  cat conftest.err >&5
7524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7525 >  (exit $ac_status); } &&
7526 >         { ac_try='test -z "$ac_c_werror_flag"
7527 >                         || test ! -s conftest.err'
7528 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7529 >  (eval $ac_try) 2>&5
7530 >  ac_status=$?
7531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7532 >  (exit $ac_status); }; } &&
7533 >         { ac_try='test -s conftest.$ac_objext'
7534 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7535 >  (eval $ac_try) 2>&5
7536 >  ac_status=$?
7537 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7538 >  (exit $ac_status); }; }; then
7539 >  ac_cv_c_const=yes
7540 > else
7541 >  echo "$as_me: failed program was:" >&5
7542 > sed 's/^/| /' conftest.$ac_ext >&5
7543 >
7544 > ac_cv_c_const=no
7545 > fi
7546 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7547 > fi
7548 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7549 > echo "${ECHO_T}$ac_cv_c_const" >&6
7550 > if test $ac_cv_c_const = no; then
7551 >
7552 > cat >>confdefs.h <<\_ACEOF
7553 > #define const
7554 > _ACEOF
7555 >
7556 > fi
7557 >
7558 > echo "$as_me:$LINENO: checking for inline" >&5
7559 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7560 > if test "${ac_cv_c_inline+set}" = set; then
7561 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7562 > else
7563 >  ac_cv_c_inline=no
7564 > for ac_kw in inline __inline__ __inline; do
7565 >  cat >conftest.$ac_ext <<_ACEOF
7566 > /* confdefs.h.  */
7567 > _ACEOF
7568 > cat confdefs.h >>conftest.$ac_ext
7569 > cat >>conftest.$ac_ext <<_ACEOF
7570 > /* end confdefs.h.  */
7571 > #ifndef __cplusplus
7572 > typedef int foo_t;
7573 > static $ac_kw foo_t static_foo () {return 0; }
7574 > $ac_kw foo_t foo () {return 0; }
7575 > #endif
7576 >
7577 > _ACEOF
7578 > rm -f conftest.$ac_objext
7579 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7580 >  (eval $ac_compile) 2>conftest.er1
7581 >  ac_status=$?
7582 >  grep -v '^ *+' conftest.er1 >conftest.err
7583 >  rm -f conftest.er1
7584 >  cat conftest.err >&5
7585 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7586 >  (exit $ac_status); } &&
7587 >         { ac_try='test -z "$ac_c_werror_flag"
7588 >                         || test ! -s conftest.err'
7589 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7590 >  (eval $ac_try) 2>&5
7591 >  ac_status=$?
7592 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7593 >  (exit $ac_status); }; } &&
7594 >         { ac_try='test -s conftest.$ac_objext'
7595 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7596 >  (eval $ac_try) 2>&5
7597 >  ac_status=$?
7598 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7599 >  (exit $ac_status); }; }; then
7600 >  ac_cv_c_inline=$ac_kw; break
7601 > else
7602 >  echo "$as_me: failed program was:" >&5
7603 > sed 's/^/| /' conftest.$ac_ext >&5
7604 >
7605 > fi
7606 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7607 > done
7608 >
7609 > fi
7610 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7611 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7612 >
7613 >
7614 > case $ac_cv_c_inline in
7615 >  inline | yes) ;;
7616 >  *)
7617 >    case $ac_cv_c_inline in
7618 >      no) ac_val=;;
7619 >      *) ac_val=$ac_cv_c_inline;;
7620 >    esac
7621 >    cat >>confdefs.h <<_ACEOF
7622 > #ifndef __cplusplus
7623 > #define inline $ac_val
7624 > #endif
7625 > _ACEOF
7626 >    ;;
7627 > esac
7628 >
7629 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7630 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7631 > if test "${ac_cv_c_restrict+set}" = set; then
7632 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7633 > else
7634 >  ac_cv_c_restrict=no
7635 >   # Try the official restrict keyword, then gcc's __restrict, and
7636 >   # the less common variants.
7637 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7638 >     cat >conftest.$ac_ext <<_ACEOF
7639 > /* confdefs.h.  */
7640 > _ACEOF
7641 > cat confdefs.h >>conftest.$ac_ext
7642 > cat >>conftest.$ac_ext <<_ACEOF
7643 > /* end confdefs.h.  */
7644 > float * $ac_kw x;
7645 > _ACEOF
7646 > rm -f conftest.$ac_objext
7647 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7648 >  (eval $ac_compile) 2>conftest.er1
7649 >  ac_status=$?
7650 >  grep -v '^ *+' conftest.er1 >conftest.err
7651 >  rm -f conftest.er1
7652 >  cat conftest.err >&5
7653 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7654 >  (exit $ac_status); } &&
7655 >         { ac_try='test -z "$ac_c_werror_flag"
7656 >                         || test ! -s conftest.err'
7657 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7658 >  (eval $ac_try) 2>&5
7659 >  ac_status=$?
7660 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7661 >  (exit $ac_status); }; } &&
7662 >         { ac_try='test -s conftest.$ac_objext'
7663 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7664 >  (eval $ac_try) 2>&5
7665 >  ac_status=$?
7666 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7667 >  (exit $ac_status); }; }; then
7668 >  ac_cv_c_restrict=$ac_kw; break
7669 > else
7670 >  echo "$as_me: failed program was:" >&5
7671 > sed 's/^/| /' conftest.$ac_ext >&5
7672 >
7673 > fi
7674 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7675 >   done
7676 >
7677 > fi
7678 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7679 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7680 > case $ac_cv_c_restrict in
7681 >   restrict) ;;
7682 >   no)
7683 > cat >>confdefs.h <<\_ACEOF
7684 > #define restrict
7685 > _ACEOF
7686 > ;;
7687 >   *)  cat >>confdefs.h <<_ACEOF
7688 > #define restrict $ac_cv_c_restrict
7689 > _ACEOF
7690 > ;;
7691 > esac
7692 >
7693 > echo "$as_me:$LINENO: checking for size_t" >&5
7694 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7695 > if test "${ac_cv_type_size_t+set}" = set; then
7696 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7697 > else
7698 >  cat >conftest.$ac_ext <<_ACEOF
7699 > /* confdefs.h.  */
7700 > _ACEOF
7701 > cat confdefs.h >>conftest.$ac_ext
7702 > cat >>conftest.$ac_ext <<_ACEOF
7703 > /* end confdefs.h.  */
7704 > $ac_includes_default
7705 > #ifdef FC_DUMMY_MAIN
7706 > #ifndef FC_DUMMY_MAIN_EQ_F77
7707 > #  ifdef __cplusplus
7708 >     extern "C"
7709 > #  endif
7710 >   int FC_DUMMY_MAIN() { return 1; }
7711 > #endif
7712 > #endif
7713 > int
7714 > main ()
7715 > {
7716 > if ((size_t *) 0)
7717 >  return 0;
7718 > if (sizeof (size_t))
7719 >  return 0;
7720 >  ;
7721 >  return 0;
7722 > }
7723 > _ACEOF
7724 > rm -f conftest.$ac_objext
7725 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7726 >  (eval $ac_compile) 2>conftest.er1
7727 >  ac_status=$?
7728 >  grep -v '^ *+' conftest.er1 >conftest.err
7729 >  rm -f conftest.er1
7730 >  cat conftest.err >&5
7731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7732 >  (exit $ac_status); } &&
7733 >         { ac_try='test -z "$ac_c_werror_flag"
7734 >                         || test ! -s conftest.err'
7735 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7736 >  (eval $ac_try) 2>&5
7737 >  ac_status=$?
7738 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7739 >  (exit $ac_status); }; } &&
7740 >         { ac_try='test -s conftest.$ac_objext'
7741 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7742 >  (eval $ac_try) 2>&5
7743 >  ac_status=$?
7744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7745 >  (exit $ac_status); }; }; then
7746 >  ac_cv_type_size_t=yes
7747 > else
7748 >  echo "$as_me: failed program was:" >&5
7749 > sed 's/^/| /' conftest.$ac_ext >&5
7750 >
7751 > ac_cv_type_size_t=no
7752 > fi
7753 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7754 > fi
7755 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7756 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7757 > if test $ac_cv_type_size_t = yes; then
7758 >  :
7759 > else
7760 >
7761 > cat >>confdefs.h <<_ACEOF
7762 > #define size_t unsigned
7763 > _ACEOF
7764 >
7765 > fi
7766 >
7767 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7768 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7769 > if test "${ac_cv_header_time+set}" = set; then
7770 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7771 > else
7772 >  cat >conftest.$ac_ext <<_ACEOF
7773 > /* confdefs.h.  */
7774 > _ACEOF
7775 > cat confdefs.h >>conftest.$ac_ext
7776 > cat >>conftest.$ac_ext <<_ACEOF
7777 > /* end confdefs.h.  */
7778 > #include <sys/types.h>
7779 > #include <sys/time.h>
7780 > #include <time.h>
7781 >
7782 > #ifdef FC_DUMMY_MAIN
7783 > #ifndef FC_DUMMY_MAIN_EQ_F77
7784 > #  ifdef __cplusplus
7785 >     extern "C"
7786 > #  endif
7787 >   int FC_DUMMY_MAIN() { return 1; }
7788 > #endif
7789 > #endif
7790 > int
7791 > main ()
7792 > {
7793 > if ((struct tm *) 0)
7794 > return 0;
7795 >  ;
7796 >  return 0;
7797 > }
7798 > _ACEOF
7799 > rm -f conftest.$ac_objext
7800 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7801 >  (eval $ac_compile) 2>conftest.er1
7802 >  ac_status=$?
7803 >  grep -v '^ *+' conftest.er1 >conftest.err
7804 >  rm -f conftest.er1
7805 >  cat conftest.err >&5
7806 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7807 >  (exit $ac_status); } &&
7808 >         { ac_try='test -z "$ac_c_werror_flag"
7809 >                         || test ! -s conftest.err'
7810 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7811 >  (eval $ac_try) 2>&5
7812 >  ac_status=$?
7813 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7814 >  (exit $ac_status); }; } &&
7815 >         { ac_try='test -s conftest.$ac_objext'
7816 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7817 >  (eval $ac_try) 2>&5
7818 >  ac_status=$?
7819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7820 >  (exit $ac_status); }; }; then
7821 >  ac_cv_header_time=yes
7822 > else
7823 >  echo "$as_me: failed program was:" >&5
7824 > sed 's/^/| /' conftest.$ac_ext >&5
7825 >
7826 > ac_cv_header_time=no
7827 > fi
7828 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7829 > fi
7830 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7831 > echo "${ECHO_T}$ac_cv_header_time" >&6
7832 > if test $ac_cv_header_time = yes; then
7833 >
7834 > cat >>confdefs.h <<\_ACEOF
7835 > #define TIME_WITH_SYS_TIME 1
7836 > _ACEOF
7837 >
7838 > fi
7839 >
7840 > echo "$as_me:$LINENO: checking for clock_t" >&5
7841 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7842 > if test "${ac_cv_type_clock_t+set}" = set; then
7843 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7844 > else
7845 >  cat >conftest.$ac_ext <<_ACEOF
7846 > /* confdefs.h.  */
7847 > _ACEOF
7848 > cat confdefs.h >>conftest.$ac_ext
7849 > cat >>conftest.$ac_ext <<_ACEOF
7850 > /* end confdefs.h.  */
7851 > $ac_includes_default
7852 > #ifdef FC_DUMMY_MAIN
7853 > #ifndef FC_DUMMY_MAIN_EQ_F77
7854 > #  ifdef __cplusplus
7855 >     extern "C"
7856 > #  endif
7857 >   int FC_DUMMY_MAIN() { return 1; }
7858 > #endif
7859 > #endif
7860 > int
7861 > main ()
7862 > {
7863 > if ((clock_t *) 0)
7864 >  return 0;
7865 > if (sizeof (clock_t))
7866 >  return 0;
7867 >  ;
7868 >  return 0;
7869 > }
7870 > _ACEOF
7871 > rm -f conftest.$ac_objext
7872 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7873 >  (eval $ac_compile) 2>conftest.er1
7874 >  ac_status=$?
7875 >  grep -v '^ *+' conftest.er1 >conftest.err
7876 >  rm -f conftest.er1
7877 >  cat conftest.err >&5
7878 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879 >  (exit $ac_status); } &&
7880 >         { ac_try='test -z "$ac_c_werror_flag"
7881 >                         || test ! -s conftest.err'
7882 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7883 >  (eval $ac_try) 2>&5
7884 >  ac_status=$?
7885 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7886 >  (exit $ac_status); }; } &&
7887 >         { ac_try='test -s conftest.$ac_objext'
7888 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7889 >  (eval $ac_try) 2>&5
7890 >  ac_status=$?
7891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7892 >  (exit $ac_status); }; }; then
7893 >  ac_cv_type_clock_t=yes
7894 > else
7895 >  echo "$as_me: failed program was:" >&5
7896 > sed 's/^/| /' conftest.$ac_ext >&5
7897 >
7898 > ac_cv_type_clock_t=no
7899 > fi
7900 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7901 > fi
7902 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7903 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7904 > if test $ac_cv_type_clock_t = yes; then
7905 >
7906 > cat >>confdefs.h <<_ACEOF
7907 > #define HAVE_CLOCK_T 1
7908 > _ACEOF
7909 >
7910 >
7911 > fi
7912 >
7913 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7914 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7915 > if test "${ac_cv_c_const+set}" = set; then
7916 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7917 > else
7918 >  cat >conftest.$ac_ext <<_ACEOF
7919 > /* confdefs.h.  */
7920 > _ACEOF
7921 > cat confdefs.h >>conftest.$ac_ext
7922 > cat >>conftest.$ac_ext <<_ACEOF
7923 > /* end confdefs.h.  */
7924 >
7925 > #ifdef FC_DUMMY_MAIN
7926 > #ifndef FC_DUMMY_MAIN_EQ_F77
7927 > #  ifdef __cplusplus
7928 >     extern "C"
7929 > #  endif
7930 >   int FC_DUMMY_MAIN() { return 1; }
7931 > #endif
7932 > #endif
7933 > int
7934 > main ()
7935 > {
7936 > /* FIXME: Include the comments suggested by Paul. */
7937 > #ifndef __cplusplus
7938 >  /* Ultrix mips cc rejects this.  */
7939 >  typedef int charset[2];
7940 >  const charset x;
7941 >  /* SunOS 4.1.1 cc rejects this.  */
7942 >  char const *const *ccp;
7943 >  char **p;
7944 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7945 >  struct point {int x, y;};
7946 >  static struct point const zero = {0,0};
7947 >  /* AIX XL C 1.02.0.0 rejects this.
7948 >     It does not let you subtract one const X* pointer from another in
7949 >     an arm of an if-expression whose if-part is not a constant
7950 >     expression */
7951 >  const char *g = "string";
7952 >  ccp = &g + (g ? g-g : 0);
7953 >  /* HPUX 7.0 cc rejects these. */
7954 >  ++ccp;
7955 >  p = (char**) ccp;
7956 >  ccp = (char const *const *) p;
7957 >  { /* SCO 3.2v4 cc rejects this.  */
7958 >    char *t;
7959 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7960 >
7961 >    *t++ = 0;
7962 >  }
7963 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7964 >    int x[] = {25, 17};
7965 >    const int *foo = &x[0];
7966 >    ++foo;
7967 >  }
7968 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7969 >    typedef const int *iptr;
7970 >    iptr p = 0;
7971 >    ++p;
7972 >  }
7973 >  { /* AIX XL C 1.02.0.0 rejects this saying
7974 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7975 >    struct s { int j; const int *ap[3]; };
7976 >    struct s *b; b->j = 5;
7977 >  }
7978 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7979 >    const int foo = 10;
7980 >  }
7981 > #endif
7982 >
7983 >  ;
7984 >  return 0;
7985 > }
7986 > _ACEOF
7987 > rm -f conftest.$ac_objext
7988 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7989 >  (eval $ac_compile) 2>conftest.er1
7990 >  ac_status=$?
7991 >  grep -v '^ *+' conftest.er1 >conftest.err
7992 >  rm -f conftest.er1
7993 >  cat conftest.err >&5
7994 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7995 >  (exit $ac_status); } &&
7996 >         { ac_try='test -z "$ac_c_werror_flag"
7997 >                         || test ! -s conftest.err'
7998 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7999 >  (eval $ac_try) 2>&5
8000 >  ac_status=$?
8001 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8002 >  (exit $ac_status); }; } &&
8003 >         { ac_try='test -s conftest.$ac_objext'
8004 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8005 >  (eval $ac_try) 2>&5
8006 >  ac_status=$?
8007 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8008 >  (exit $ac_status); }; }; then
8009 >  ac_cv_c_const=yes
8010 > else
8011 >  echo "$as_me: failed program was:" >&5
8012 > sed 's/^/| /' conftest.$ac_ext >&5
8013 >
8014 > ac_cv_c_const=no
8015 > fi
8016 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8017 > fi
8018 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8019 > echo "${ECHO_T}$ac_cv_c_const" >&6
8020 > if test $ac_cv_c_const = no; then
8021 >
8022 > cat >>confdefs.h <<\_ACEOF
8023 > #define const
8024 > _ACEOF
8025 >
8026 > fi
8027 >
8028 > echo "$as_me:$LINENO: checking for inline" >&5
8029 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8030 > if test "${ac_cv_c_inline+set}" = set; then
8031 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8032 > else
8033 >  ac_cv_c_inline=no
8034 > for ac_kw in inline __inline__ __inline; do
8035 >  cat >conftest.$ac_ext <<_ACEOF
8036 > /* confdefs.h.  */
8037 > _ACEOF
8038 > cat confdefs.h >>conftest.$ac_ext
8039 > cat >>conftest.$ac_ext <<_ACEOF
8040 > /* end confdefs.h.  */
8041 > #ifndef __cplusplus
8042 > typedef int foo_t;
8043 > static $ac_kw foo_t static_foo () {return 0; }
8044 > $ac_kw foo_t foo () {return 0; }
8045 > #endif
8046 >
8047 > _ACEOF
8048 > rm -f conftest.$ac_objext
8049 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8050 >  (eval $ac_compile) 2>conftest.er1
8051 >  ac_status=$?
8052 >  grep -v '^ *+' conftest.er1 >conftest.err
8053 >  rm -f conftest.er1
8054 >  cat conftest.err >&5
8055 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8056 >  (exit $ac_status); } &&
8057 >         { ac_try='test -z "$ac_c_werror_flag"
8058 >                         || test ! -s conftest.err'
8059 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8060 >  (eval $ac_try) 2>&5
8061 >  ac_status=$?
8062 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8063 >  (exit $ac_status); }; } &&
8064 >         { ac_try='test -s conftest.$ac_objext'
8065 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8066 >  (eval $ac_try) 2>&5
8067 >  ac_status=$?
8068 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8069 >  (exit $ac_status); }; }; then
8070 >  ac_cv_c_inline=$ac_kw; break
8071 > else
8072 >  echo "$as_me: failed program was:" >&5
8073 > sed 's/^/| /' conftest.$ac_ext >&5
8074 >
8075 > fi
8076 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8077 > done
8078 >
8079 > fi
8080 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8081 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8082 >
8083 >
8084 > case $ac_cv_c_inline in
8085 >  inline | yes) ;;
8086 >  *)
8087 >    case $ac_cv_c_inline in
8088 >      no) ac_val=;;
8089 >      *) ac_val=$ac_cv_c_inline;;
8090 >    esac
8091 >    cat >>confdefs.h <<_ACEOF
8092 > #ifndef __cplusplus
8093 > #define inline $ac_val
8094 > #endif
8095 > _ACEOF
8096 >    ;;
8097 > esac
8098 >
8099 >
8100 > # Checks for library functions.
8101 >
8102 > for ac_header in stdlib.h
8103 > do
8104 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8105 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8106 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8107 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8108 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8109 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8110 > fi
8111 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8112 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8113 > else
8114 >  # Is the header compilable?
8115 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8116 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8117 > cat >conftest.$ac_ext <<_ACEOF
8118 > /* confdefs.h.  */
8119 > _ACEOF
8120 > cat confdefs.h >>conftest.$ac_ext
8121 > cat >>conftest.$ac_ext <<_ACEOF
8122 > /* end confdefs.h.  */
8123 > $ac_includes_default
8124 > #include <$ac_header>
8125 > _ACEOF
8126 > rm -f conftest.$ac_objext
8127 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8128 >  (eval $ac_compile) 2>conftest.er1
8129 >  ac_status=$?
8130 >  grep -v '^ *+' conftest.er1 >conftest.err
8131 >  rm -f conftest.er1
8132 >  cat conftest.err >&5
8133 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8134 >  (exit $ac_status); } &&
8135 >         { ac_try='test -z "$ac_c_werror_flag"
8136 >                         || test ! -s conftest.err'
8137 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8138 >  (eval $ac_try) 2>&5
8139 >  ac_status=$?
8140 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8141 >  (exit $ac_status); }; } &&
8142 >         { ac_try='test -s conftest.$ac_objext'
8143 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8144 >  (eval $ac_try) 2>&5
8145 >  ac_status=$?
8146 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8147 >  (exit $ac_status); }; }; then
8148 >  ac_header_compiler=yes
8149 > else
8150 >  echo "$as_me: failed program was:" >&5
8151 > sed 's/^/| /' conftest.$ac_ext >&5
8152 >
8153 > ac_header_compiler=no
8154 > fi
8155 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8156 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8157 > echo "${ECHO_T}$ac_header_compiler" >&6
8158 >
8159 > # Is the header present?
8160 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8161 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8162 > cat >conftest.$ac_ext <<_ACEOF
8163 > /* confdefs.h.  */
8164 > _ACEOF
8165 > cat confdefs.h >>conftest.$ac_ext
8166 > cat >>conftest.$ac_ext <<_ACEOF
8167 > /* end confdefs.h.  */
8168 > #include <$ac_header>
8169 > _ACEOF
8170 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8171 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8172 >  ac_status=$?
8173 >  grep -v '^ *+' conftest.er1 >conftest.err
8174 >  rm -f conftest.er1
8175 >  cat conftest.err >&5
8176 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8177 >  (exit $ac_status); } >/dev/null; then
8178 >  if test -s conftest.err; then
8179 >    ac_cpp_err=$ac_c_preproc_warn_flag
8180 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8181 >  else
8182 >    ac_cpp_err=
8183 >  fi
8184 > else
8185 >  ac_cpp_err=yes
8186 > fi
8187 > if test -z "$ac_cpp_err"; then
8188 >  ac_header_preproc=yes
8189 > else
8190 >  echo "$as_me: failed program was:" >&5
8191 > sed 's/^/| /' conftest.$ac_ext >&5
8192 >
8193 >  ac_header_preproc=no
8194 > fi
8195 > rm -f conftest.err conftest.$ac_ext
8196 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8197 > echo "${ECHO_T}$ac_header_preproc" >&6
8198 >
8199 > # So?  What about this header?
8200 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8201 >  yes:no: )
8202 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8203 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8204 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8205 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8206 >    ac_header_preproc=yes
8207 >    ;;
8208 >  no:yes:* )
8209 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8210 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8211 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8212 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8213 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8214 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8215 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8216 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8217 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8218 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8219 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8220 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8221 >    (
8222 >      cat <<\_ASBOX
8223 > ## ------------------------------ ##
8224 > ## Report this to gezelter@nd.edu ##
8225 > ## ------------------------------ ##
8226 > _ASBOX
8227 >    ) |
8228 >      sed "s/^/$as_me: WARNING:     /" >&2
8229 >    ;;
8230 > esac
8231 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8232 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8233 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8234 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8235 > else
8236 >  eval "$as_ac_Header=\$ac_header_preproc"
8237 > fi
8238 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8239 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8240 >
8241 > fi
8242 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8243 >  cat >>confdefs.h <<_ACEOF
8244 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8245 > _ACEOF
8246 >
8247 > fi
8248 >
8249 > done
8250 >
8251 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8252 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8253 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8254 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8255 > else
8256 >  if test "$cross_compiling" = yes; then
8257 >  ac_cv_func_malloc_0_nonnull=no
8258 > else
8259 >  cat >conftest.$ac_ext <<_ACEOF
8260 > /* confdefs.h.  */
8261 > _ACEOF
8262 > cat confdefs.h >>conftest.$ac_ext
8263 > cat >>conftest.$ac_ext <<_ACEOF
8264 > /* end confdefs.h.  */
8265 > #if STDC_HEADERS || HAVE_STDLIB_H
8266 > # include <stdlib.h>
8267 > #else
8268 > char *malloc ();
8269 > #endif
8270 >
8271 > #ifdef FC_DUMMY_MAIN
8272 > #ifndef FC_DUMMY_MAIN_EQ_F77
8273 > #  ifdef __cplusplus
8274 >     extern "C"
8275 > #  endif
8276 >   int FC_DUMMY_MAIN() { return 1; }
8277 > #endif
8278 > #endif
8279 > int
8280 > main ()
8281 > {
8282 > exit (malloc (0) ? 0 : 1);
8283 >  ;
8284 >  return 0;
8285 > }
8286 > _ACEOF
8287 > rm -f conftest$ac_exeext
8288 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8289 >  (eval $ac_link) 2>&5
8290 >  ac_status=$?
8291 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8292 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8293 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8294 >  (eval $ac_try) 2>&5
8295 >  ac_status=$?
8296 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8297 >  (exit $ac_status); }; }; then
8298 >  ac_cv_func_malloc_0_nonnull=yes
8299 > else
8300 >  echo "$as_me: program exited with status $ac_status" >&5
8301 > echo "$as_me: failed program was:" >&5
8302 > sed 's/^/| /' conftest.$ac_ext >&5
8303 >
8304 > ( exit $ac_status )
8305 > ac_cv_func_malloc_0_nonnull=no
8306 > fi
8307 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8308 > fi
8309 > fi
8310 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8311 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8312 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8313 >
8314 > cat >>confdefs.h <<\_ACEOF
8315 > #define HAVE_MALLOC 1
8316 > _ACEOF
8317 >
8318 > else
8319 >  cat >>confdefs.h <<\_ACEOF
8320 > #define HAVE_MALLOC 0
8321 > _ACEOF
8322 >
8323 >   case $LIBOBJS in
8324 >    "malloc.$ac_objext"   | \
8325 >  *" malloc.$ac_objext"   | \
8326 >    "malloc.$ac_objext "* | \
8327 >  *" malloc.$ac_objext "* ) ;;
8328 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8329 > esac
8330 >
8331 >
8332 > cat >>confdefs.h <<\_ACEOF
8333 > #define malloc rpl_malloc
8334 > _ACEOF
8335 >
8336 > fi
8337 >
8338 >
8339 >
8340 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8341 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8342 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8343 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8344 > else
8345 >  if test "$cross_compiling" = yes; then
8346 >  ac_cv_func_memcmp_working=no
8347 > else
8348 >  cat >conftest.$ac_ext <<_ACEOF
8349 > /* confdefs.h.  */
8350 > _ACEOF
8351 > cat confdefs.h >>conftest.$ac_ext
8352 > cat >>conftest.$ac_ext <<_ACEOF
8353 > /* end confdefs.h.  */
8354 > $ac_includes_default
8355 > #ifdef FC_DUMMY_MAIN
8356 > #ifndef FC_DUMMY_MAIN_EQ_F77
8357 > #  ifdef __cplusplus
8358 >     extern "C"
8359 > #  endif
8360 >   int FC_DUMMY_MAIN() { return 1; }
8361 > #endif
8362 > #endif
8363 > int
8364 > main ()
8365 > {
8366 >
8367 >  /* Some versions of memcmp are not 8-bit clean.  */
8368 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8369 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8370 >    exit (1);
8371 >
8372 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8373 >     or more and with at least one buffer not starting on a 4-byte boundary.
8374 >     William Lewis provided this test program.   */
8375 >  {
8376 >    char foo[21];
8377 >    char bar[21];
8378 >    int i;
8379 >    for (i = 0; i < 4; i++)
8380 >      {
8381 >        char *a = foo + i;
8382 >        char *b = bar + i;
8383 >        strcpy (a, "--------01111111");
8384 >        strcpy (b, "--------10000000");
8385 >        if (memcmp (a, b, 16) >= 0)
8386 >          exit (1);
8387 >      }
8388 >    exit (0);
8389 >  }
8390 >
8391 >  ;
8392 >  return 0;
8393 > }
8394 > _ACEOF
8395 > rm -f conftest$ac_exeext
8396 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8397 >  (eval $ac_link) 2>&5
8398 >  ac_status=$?
8399 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8400 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8401 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8402 >  (eval $ac_try) 2>&5
8403 >  ac_status=$?
8404 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8405 >  (exit $ac_status); }; }; then
8406 >  ac_cv_func_memcmp_working=yes
8407 > else
8408 >  echo "$as_me: program exited with status $ac_status" >&5
8409 > echo "$as_me: failed program was:" >&5
8410 > sed 's/^/| /' conftest.$ac_ext >&5
8411 >
8412 > ( exit $ac_status )
8413 > ac_cv_func_memcmp_working=no
8414 > fi
8415 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8416 > fi
8417 > fi
8418 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8419 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8420 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8421 >    "memcmp.$ac_objext"   | \
8422 >  *" memcmp.$ac_objext"   | \
8423 >    "memcmp.$ac_objext "* | \
8424 >  *" memcmp.$ac_objext "* ) ;;
8425 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8426 > esac
8427 >
8428 >
8429 >
8430 > for ac_header in stdlib.h
8431 > do
8432 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8433 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8434 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8435 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8436 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8437 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8438 > fi
8439 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8440 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8441 > else
8442 >  # Is the header compilable?
8443 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8444 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8445 > cat >conftest.$ac_ext <<_ACEOF
8446 > /* confdefs.h.  */
8447 > _ACEOF
8448 > cat confdefs.h >>conftest.$ac_ext
8449 > cat >>conftest.$ac_ext <<_ACEOF
8450 > /* end confdefs.h.  */
8451 > $ac_includes_default
8452 > #include <$ac_header>
8453 > _ACEOF
8454 > rm -f conftest.$ac_objext
8455 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8456 >  (eval $ac_compile) 2>conftest.er1
8457 >  ac_status=$?
8458 >  grep -v '^ *+' conftest.er1 >conftest.err
8459 >  rm -f conftest.er1
8460 >  cat conftest.err >&5
8461 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8462 >  (exit $ac_status); } &&
8463 >         { ac_try='test -z "$ac_c_werror_flag"
8464 >                         || test ! -s conftest.err'
8465 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8466 >  (eval $ac_try) 2>&5
8467 >  ac_status=$?
8468 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8469 >  (exit $ac_status); }; } &&
8470 >         { ac_try='test -s conftest.$ac_objext'
8471 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8472 >  (eval $ac_try) 2>&5
8473 >  ac_status=$?
8474 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8475 >  (exit $ac_status); }; }; then
8476 >  ac_header_compiler=yes
8477 > else
8478 >  echo "$as_me: failed program was:" >&5
8479 > sed 's/^/| /' conftest.$ac_ext >&5
8480 >
8481 > ac_header_compiler=no
8482 > fi
8483 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8484 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8485 > echo "${ECHO_T}$ac_header_compiler" >&6
8486 >
8487 > # Is the header present?
8488 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8489 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8490 > cat >conftest.$ac_ext <<_ACEOF
8491 > /* confdefs.h.  */
8492 > _ACEOF
8493 > cat confdefs.h >>conftest.$ac_ext
8494 > cat >>conftest.$ac_ext <<_ACEOF
8495 > /* end confdefs.h.  */
8496 > #include <$ac_header>
8497 > _ACEOF
8498 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8499 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8500 >  ac_status=$?
8501 >  grep -v '^ *+' conftest.er1 >conftest.err
8502 >  rm -f conftest.er1
8503 >  cat conftest.err >&5
8504 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8505 >  (exit $ac_status); } >/dev/null; then
8506 >  if test -s conftest.err; then
8507 >    ac_cpp_err=$ac_c_preproc_warn_flag
8508 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8509 >  else
8510 >    ac_cpp_err=
8511 >  fi
8512 > else
8513 >  ac_cpp_err=yes
8514 > fi
8515 > if test -z "$ac_cpp_err"; then
8516 >  ac_header_preproc=yes
8517 > else
8518 >  echo "$as_me: failed program was:" >&5
8519 > sed 's/^/| /' conftest.$ac_ext >&5
8520 >
8521 >  ac_header_preproc=no
8522 > fi
8523 > rm -f conftest.err conftest.$ac_ext
8524 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8525 > echo "${ECHO_T}$ac_header_preproc" >&6
8526 >
8527 > # So?  What about this header?
8528 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8529 >  yes:no: )
8530 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8531 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8532 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8533 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8534 >    ac_header_preproc=yes
8535 >    ;;
8536 >  no:yes:* )
8537 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8538 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8539 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8540 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8541 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8542 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8543 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8544 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8545 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8546 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8547 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8548 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8549 >    (
8550 >      cat <<\_ASBOX
8551 > ## ------------------------------ ##
8552 > ## Report this to gezelter@nd.edu ##
8553 > ## ------------------------------ ##
8554 > _ASBOX
8555 >    ) |
8556 >      sed "s/^/$as_me: WARNING:     /" >&2
8557 >    ;;
8558 > esac
8559 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8560 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8561 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8562 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8563 > else
8564 >  eval "$as_ac_Header=\$ac_header_preproc"
8565 > fi
8566 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8567 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8568 >
8569 > fi
8570 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8571 >  cat >>confdefs.h <<_ACEOF
8572 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8573 > _ACEOF
8574 >
8575 > fi
8576 >
8577 > done
8578 >
8579 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8580 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8581 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8582 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8583 > else
8584 >  if test "$cross_compiling" = yes; then
8585 >  ac_cv_func_realloc_0_nonnull=no
8586 > else
8587 >  cat >conftest.$ac_ext <<_ACEOF
8588 > /* confdefs.h.  */
8589 > _ACEOF
8590 > cat confdefs.h >>conftest.$ac_ext
8591 > cat >>conftest.$ac_ext <<_ACEOF
8592 > /* end confdefs.h.  */
8593 > #if STDC_HEADERS || HAVE_STDLIB_H
8594 > # include <stdlib.h>
8595 > #else
8596 > char *realloc ();
8597 > #endif
8598 >
8599 > #ifdef FC_DUMMY_MAIN
8600 > #ifndef FC_DUMMY_MAIN_EQ_F77
8601 > #  ifdef __cplusplus
8602 >     extern "C"
8603 > #  endif
8604 >   int FC_DUMMY_MAIN() { return 1; }
8605 > #endif
8606 > #endif
8607 > int
8608 > main ()
8609 > {
8610 > exit (realloc (0, 0) ? 0 : 1);
8611 >  ;
8612 >  return 0;
8613 > }
8614 > _ACEOF
8615 > rm -f conftest$ac_exeext
8616 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8617 >  (eval $ac_link) 2>&5
8618 >  ac_status=$?
8619 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8620 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8621 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8622 >  (eval $ac_try) 2>&5
8623 >  ac_status=$?
8624 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8625 >  (exit $ac_status); }; }; then
8626 >  ac_cv_func_realloc_0_nonnull=yes
8627 > else
8628 >  echo "$as_me: program exited with status $ac_status" >&5
8629 > echo "$as_me: failed program was:" >&5
8630 > sed 's/^/| /' conftest.$ac_ext >&5
8631 >
8632 > ( exit $ac_status )
8633 > ac_cv_func_realloc_0_nonnull=no
8634 > fi
8635 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8636 > fi
8637 > fi
8638 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8639 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8640 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8641 >
8642 > cat >>confdefs.h <<\_ACEOF
8643 > #define HAVE_REALLOC 1
8644 > _ACEOF
8645 >
8646 > else
8647 >  cat >>confdefs.h <<\_ACEOF
8648 > #define HAVE_REALLOC 0
8649 > _ACEOF
8650 >
8651 >   case $LIBOBJS in
8652 >    "realloc.$ac_objext"   | \
8653 >  *" realloc.$ac_objext"   | \
8654 >    "realloc.$ac_objext "* | \
8655 >  *" realloc.$ac_objext "* ) ;;
8656 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8657 > esac
8658 >
8659 >
8660 > cat >>confdefs.h <<\_ACEOF
8661 > #define realloc rpl_realloc
8662 > _ACEOF
8663 >
8664 > fi
8665 >
8666 >
8667 >
8668 >
8669 >
8670 > for ac_header in sys/select.h sys/socket.h
8671 > do
8672 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8673 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8674 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8675 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8676 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8677 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8678 > fi
8679 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8680 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8681 > else
8682 >  # Is the header compilable?
8683 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8684 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8685 > cat >conftest.$ac_ext <<_ACEOF
8686 > /* confdefs.h.  */
8687 > _ACEOF
8688 > cat confdefs.h >>conftest.$ac_ext
8689 > cat >>conftest.$ac_ext <<_ACEOF
8690 > /* end confdefs.h.  */
8691 > $ac_includes_default
8692 > #include <$ac_header>
8693 > _ACEOF
8694 > rm -f conftest.$ac_objext
8695 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8696 >  (eval $ac_compile) 2>conftest.er1
8697 >  ac_status=$?
8698 >  grep -v '^ *+' conftest.er1 >conftest.err
8699 >  rm -f conftest.er1
8700 >  cat conftest.err >&5
8701 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8702 >  (exit $ac_status); } &&
8703 >         { ac_try='test -z "$ac_c_werror_flag"
8704 >                         || test ! -s conftest.err'
8705 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8706 >  (eval $ac_try) 2>&5
8707 >  ac_status=$?
8708 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8709 >  (exit $ac_status); }; } &&
8710 >         { ac_try='test -s conftest.$ac_objext'
8711 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8712 >  (eval $ac_try) 2>&5
8713 >  ac_status=$?
8714 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8715 >  (exit $ac_status); }; }; then
8716 >  ac_header_compiler=yes
8717 > else
8718 >  echo "$as_me: failed program was:" >&5
8719 > sed 's/^/| /' conftest.$ac_ext >&5
8720 >
8721 > ac_header_compiler=no
8722 > fi
8723 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8724 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8725 > echo "${ECHO_T}$ac_header_compiler" >&6
8726 >
8727 > # Is the header present?
8728 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8729 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8730 > cat >conftest.$ac_ext <<_ACEOF
8731 > /* confdefs.h.  */
8732 > _ACEOF
8733 > cat confdefs.h >>conftest.$ac_ext
8734 > cat >>conftest.$ac_ext <<_ACEOF
8735 > /* end confdefs.h.  */
8736 > #include <$ac_header>
8737 > _ACEOF
8738 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8739 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8740 >  ac_status=$?
8741 >  grep -v '^ *+' conftest.er1 >conftest.err
8742 >  rm -f conftest.er1
8743 >  cat conftest.err >&5
8744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8745 >  (exit $ac_status); } >/dev/null; then
8746 >  if test -s conftest.err; then
8747 >    ac_cpp_err=$ac_c_preproc_warn_flag
8748 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8749 >  else
8750 >    ac_cpp_err=
8751 >  fi
8752 > else
8753 >  ac_cpp_err=yes
8754 > fi
8755 > if test -z "$ac_cpp_err"; then
8756 >  ac_header_preproc=yes
8757 > else
8758 >  echo "$as_me: failed program was:" >&5
8759 > sed 's/^/| /' conftest.$ac_ext >&5
8760 >
8761 >  ac_header_preproc=no
8762 > fi
8763 > rm -f conftest.err conftest.$ac_ext
8764 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8765 > echo "${ECHO_T}$ac_header_preproc" >&6
8766 >
8767 > # So?  What about this header?
8768 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8769 >  yes:no: )
8770 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8771 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8772 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8773 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8774 >    ac_header_preproc=yes
8775 >    ;;
8776 >  no:yes:* )
8777 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8778 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8779 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8780 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8781 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8782 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8783 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8784 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8785 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8786 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8787 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8788 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8789 >    (
8790 >      cat <<\_ASBOX
8791 > ## ------------------------------ ##
8792 > ## Report this to gezelter@nd.edu ##
8793 > ## ------------------------------ ##
8794 > _ASBOX
8795 >    ) |
8796 >      sed "s/^/$as_me: WARNING:     /" >&2
8797 >    ;;
8798 > esac
8799 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8800 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8801 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8802 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8803 > else
8804 >  eval "$as_ac_Header=\$ac_header_preproc"
8805 > fi
8806 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8807 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8808 >
8809 > fi
8810 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8811 >  cat >>confdefs.h <<_ACEOF
8812 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8813 > _ACEOF
8814 >
8815 > fi
8816 >
8817 > done
8818 >
8819 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8820 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8821 > if test "${ac_cv_func_select_args+set}" = set; then
8822 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8823 > else
8824 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8825 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8826 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8827 >   cat >conftest.$ac_ext <<_ACEOF
8828 > /* confdefs.h.  */
8829 > _ACEOF
8830 > cat confdefs.h >>conftest.$ac_ext
8831 > cat >>conftest.$ac_ext <<_ACEOF
8832 > /* end confdefs.h.  */
8833 > $ac_includes_default
8834 > #if HAVE_SYS_SELECT_H
8835 > # include <sys/select.h>
8836 > #endif
8837 > #if HAVE_SYS_SOCKET_H
8838 > # include <sys/socket.h>
8839 > #endif
8840 >
8841 > #ifdef FC_DUMMY_MAIN
8842 > #ifndef FC_DUMMY_MAIN_EQ_F77
8843 > #  ifdef __cplusplus
8844 >     extern "C"
8845 > #  endif
8846 >   int FC_DUMMY_MAIN() { return 1; }
8847 > #endif
8848 > #endif
8849 > int
8850 > main ()
8851 > {
8852 > extern int select ($ac_arg1,
8853 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8854 >                                            $ac_arg5);
8855 >  ;
8856 >  return 0;
8857 > }
8858 > _ACEOF
8859 > rm -f conftest.$ac_objext
8860 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8861 >  (eval $ac_compile) 2>conftest.er1
8862 >  ac_status=$?
8863 >  grep -v '^ *+' conftest.er1 >conftest.err
8864 >  rm -f conftest.er1
8865 >  cat conftest.err >&5
8866 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8867 >  (exit $ac_status); } &&
8868 >         { ac_try='test -z "$ac_c_werror_flag"
8869 >                         || test ! -s conftest.err'
8870 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8871 >  (eval $ac_try) 2>&5
8872 >  ac_status=$?
8873 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8874 >  (exit $ac_status); }; } &&
8875 >         { ac_try='test -s conftest.$ac_objext'
8876 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8877 >  (eval $ac_try) 2>&5
8878 >  ac_status=$?
8879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8880 >  (exit $ac_status); }; }; then
8881 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8882 > else
8883 >  echo "$as_me: failed program was:" >&5
8884 > sed 's/^/| /' conftest.$ac_ext >&5
8885 >
8886 > fi
8887 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8888 >  done
8889 > done
8890 > done
8891 > # Provide a safe default value.
8892 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8893 >
8894 > fi
8895 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8896 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8897 > ac_save_IFS=$IFS; IFS=','
8898 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8899 > IFS=$ac_save_IFS
8900 > shift
8901 >
8902 > cat >>confdefs.h <<_ACEOF
8903 > #define SELECT_TYPE_ARG1 $1
8904 > _ACEOF
8905 >
8906 >
8907 > cat >>confdefs.h <<_ACEOF
8908 > #define SELECT_TYPE_ARG234 ($2)
8909 > _ACEOF
8910 >
8911 >
8912 > cat >>confdefs.h <<_ACEOF
8913 > #define SELECT_TYPE_ARG5 ($3)
8914 > _ACEOF
8915 >
8916 > rm -f conftest*
8917 >
8918 >
8919 > for ac_func in strftime
8920 > do
8921 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8922 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8923 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8924 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8925 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8926 > else
8927 >  cat >conftest.$ac_ext <<_ACEOF
8928 > /* confdefs.h.  */
8929 > _ACEOF
8930 > cat confdefs.h >>conftest.$ac_ext
8931 > cat >>conftest.$ac_ext <<_ACEOF
8932 > /* end confdefs.h.  */
8933 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8934 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8935 > #define $ac_func innocuous_$ac_func
8936 >
8937 > /* System header to define __stub macros and hopefully few prototypes,
8938 >    which can conflict with char $ac_func (); below.
8939 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8940 >    <limits.h> exists even on freestanding compilers.  */
8941 >
8942 > #ifdef __STDC__
8943 > # include <limits.h>
8944 > #else
8945 > # include <assert.h>
8946 > #endif
8947 >
8948 > #undef $ac_func
8949 >
8950 > /* Override any gcc2 internal prototype to avoid an error.  */
8951 > #ifdef __cplusplus
8952 > extern "C"
8953 > {
8954 > #endif
8955 > /* We use char because int might match the return type of a gcc2
8956 >   builtin and then its argument prototype would still apply.  */
8957 > char $ac_func ();
8958 > /* The GNU C library defines this for functions which it implements
8959 >    to always fail with ENOSYS.  Some functions are actually named
8960 >    something starting with __ and the normal name is an alias.  */
8961 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8962 > choke me
8963 > #else
8964 > char (*f) () = $ac_func;
8965 > #endif
8966 > #ifdef __cplusplus
8967 > }
8968 > #endif
8969 >
8970 > #ifdef FC_DUMMY_MAIN
8971 > #ifndef FC_DUMMY_MAIN_EQ_F77
8972 > #  ifdef __cplusplus
8973 >     extern "C"
8974 > #  endif
8975 >   int FC_DUMMY_MAIN() { return 1; }
8976 > #endif
8977 > #endif
8978 > int
8979 > main ()
8980 > {
8981 > return f != $ac_func;
8982 >  ;
8983 >  return 0;
8984 > }
8985 > _ACEOF
8986 > rm -f conftest.$ac_objext conftest$ac_exeext
8987 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8988 >  (eval $ac_link) 2>conftest.er1
8989 >  ac_status=$?
8990 >  grep -v '^ *+' conftest.er1 >conftest.err
8991 >  rm -f conftest.er1
8992 >  cat conftest.err >&5
8993 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8994 >  (exit $ac_status); } &&
8995 >         { ac_try='test -z "$ac_c_werror_flag"
8996 >                         || test ! -s conftest.err'
8997 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8998 >  (eval $ac_try) 2>&5
8999 >  ac_status=$?
9000 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9001 >  (exit $ac_status); }; } &&
9002 >         { ac_try='test -s conftest$ac_exeext'
9003 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9004 >  (eval $ac_try) 2>&5
9005 >  ac_status=$?
9006 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9007 >  (exit $ac_status); }; }; then
9008 >  eval "$as_ac_var=yes"
9009 > else
9010 >  echo "$as_me: failed program was:" >&5
9011 > sed 's/^/| /' conftest.$ac_ext >&5
9012 >
9013 > eval "$as_ac_var=no"
9014 > fi
9015 > rm -f conftest.err conftest.$ac_objext \
9016 >      conftest$ac_exeext conftest.$ac_ext
9017 > fi
9018 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9019 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9020 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9021 >  cat >>confdefs.h <<_ACEOF
9022 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9023 > _ACEOF
9024 >
9025 > else
9026 >  # strftime is in -lintl on SCO UNIX.
9027 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9028 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9029 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9030 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9031 > else
9032 >  ac_check_lib_save_LIBS=$LIBS
9033 > LIBS="-lintl  $LIBS"
9034 > cat >conftest.$ac_ext <<_ACEOF
9035 > /* confdefs.h.  */
9036 > _ACEOF
9037 > cat confdefs.h >>conftest.$ac_ext
9038 > cat >>conftest.$ac_ext <<_ACEOF
9039 > /* end confdefs.h.  */
9040 >
9041 > /* Override any gcc2 internal prototype to avoid an error.  */
9042 > #ifdef __cplusplus
9043 > extern "C"
9044 > #endif
9045 > /* We use char because int might match the return type of a gcc2
9046 >   builtin and then its argument prototype would still apply.  */
9047 > char strftime ();
9048 > #ifdef FC_DUMMY_MAIN
9049 > #ifndef FC_DUMMY_MAIN_EQ_F77
9050 > #  ifdef __cplusplus
9051 >     extern "C"
9052 > #  endif
9053 >   int FC_DUMMY_MAIN() { return 1; }
9054 > #endif
9055 > #endif
9056 > int
9057 > main ()
9058 > {
9059 > strftime ();
9060 >  ;
9061 >  return 0;
9062 > }
9063 > _ACEOF
9064 > rm -f conftest.$ac_objext conftest$ac_exeext
9065 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9066 >  (eval $ac_link) 2>conftest.er1
9067 >  ac_status=$?
9068 >  grep -v '^ *+' conftest.er1 >conftest.err
9069 >  rm -f conftest.er1
9070 >  cat conftest.err >&5
9071 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9072 >  (exit $ac_status); } &&
9073 >         { ac_try='test -z "$ac_c_werror_flag"
9074 >                         || test ! -s conftest.err'
9075 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9076 >  (eval $ac_try) 2>&5
9077 >  ac_status=$?
9078 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9079 >  (exit $ac_status); }; } &&
9080 >         { ac_try='test -s conftest$ac_exeext'
9081 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9082 >  (eval $ac_try) 2>&5
9083 >  ac_status=$?
9084 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9085 >  (exit $ac_status); }; }; then
9086 >  ac_cv_lib_intl_strftime=yes
9087 > else
9088 >  echo "$as_me: failed program was:" >&5
9089 > sed 's/^/| /' conftest.$ac_ext >&5
9090 >
9091 > ac_cv_lib_intl_strftime=no
9092 > fi
9093 > rm -f conftest.err conftest.$ac_objext \
9094 >      conftest$ac_exeext conftest.$ac_ext
9095 > LIBS=$ac_check_lib_save_LIBS
9096 > fi
9097 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9098 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9099 > if test $ac_cv_lib_intl_strftime = yes; then
9100 >  cat >>confdefs.h <<\_ACEOF
9101 > #define HAVE_STRFTIME 1
9102 > _ACEOF
9103 >
9104 > LIBS="-lintl $LIBS"
9105 > fi
9106 >
9107 > fi
9108 > done
9109 >
9110 > echo "$as_me:$LINENO: checking for working strtod" >&5
9111 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9112 > if test "${ac_cv_func_strtod+set}" = set; then
9113 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9114 > else
9115 >  if test "$cross_compiling" = yes; then
9116 >  ac_cv_func_strtod=no
9117 > else
9118 >  cat >conftest.$ac_ext <<_ACEOF
9119 > /* confdefs.h.  */
9120 > _ACEOF
9121 > cat confdefs.h >>conftest.$ac_ext
9122 > cat >>conftest.$ac_ext <<_ACEOF
9123 > /* end confdefs.h.  */
9124 >
9125 > double strtod ();
9126 > int
9127 > main()
9128 > {
9129 >  {
9130 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9131 >    char *string = " +69";
9132 >    char *term;
9133 >    double value;
9134 >    value = strtod (string, &term);
9135 >    if (value != 69 || term != (string + 4))
9136 >      exit (1);
9137 >  }
9138 >
9139 >  {
9140 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9141 >       terminating character under some conditions.  */
9142 >    char *string = "NaN";
9143 >    char *term;
9144 >    strtod (string, &term);
9145 >    if (term != string && *(term - 1) == 0)
9146 >      exit (1);
9147 >  }
9148 >  exit (0);
9149 > }
9150 >
9151 > _ACEOF
9152 > rm -f conftest$ac_exeext
9153 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9154 >  (eval $ac_link) 2>&5
9155 >  ac_status=$?
9156 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9157 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9158 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9159 >  (eval $ac_try) 2>&5
9160 >  ac_status=$?
9161 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9162 >  (exit $ac_status); }; }; then
9163 >  ac_cv_func_strtod=yes
9164 > else
9165 >  echo "$as_me: program exited with status $ac_status" >&5
9166 > echo "$as_me: failed program was:" >&5
9167 > sed 's/^/| /' conftest.$ac_ext >&5
9168 >
9169 > ( exit $ac_status )
9170 > ac_cv_func_strtod=no
9171 > fi
9172 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9173 > fi
9174 > fi
9175 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9176 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9177 > if test $ac_cv_func_strtod = no; then
9178 >  case $LIBOBJS in
9179 >    "strtod.$ac_objext"   | \
9180 >  *" strtod.$ac_objext"   | \
9181 >    "strtod.$ac_objext "* | \
9182 >  *" strtod.$ac_objext "* ) ;;
9183 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9184 > esac
9185 >
9186 > echo "$as_me:$LINENO: checking for pow" >&5
9187 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9188 > if test "${ac_cv_func_pow+set}" = set; then
9189 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9190 > else
9191 >  cat >conftest.$ac_ext <<_ACEOF
9192 > /* confdefs.h.  */
9193 > _ACEOF
9194 > cat confdefs.h >>conftest.$ac_ext
9195 > cat >>conftest.$ac_ext <<_ACEOF
9196 > /* end confdefs.h.  */
9197 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9198 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9199 > #define pow innocuous_pow
9200 >
9201 > /* System header to define __stub macros and hopefully few prototypes,
9202 >    which can conflict with char pow (); below.
9203 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9204 >    <limits.h> exists even on freestanding compilers.  */
9205 >
9206 > #ifdef __STDC__
9207 > # include <limits.h>
9208 > #else
9209 > # include <assert.h>
9210 > #endif
9211 >
9212 > #undef pow
9213 >
9214 > /* Override any gcc2 internal prototype to avoid an error.  */
9215 > #ifdef __cplusplus
9216 > extern "C"
9217 > {
9218 > #endif
9219 > /* We use char because int might match the return type of a gcc2
9220 >   builtin and then its argument prototype would still apply.  */
9221 > char pow ();
9222 > /* The GNU C library defines this for functions which it implements
9223 >    to always fail with ENOSYS.  Some functions are actually named
9224 >    something starting with __ and the normal name is an alias.  */
9225 > #if defined (__stub_pow) || defined (__stub___pow)
9226 > choke me
9227 > #else
9228 > char (*f) () = pow;
9229 > #endif
9230 > #ifdef __cplusplus
9231 > }
9232 > #endif
9233 >
9234 > #ifdef FC_DUMMY_MAIN
9235 > #ifndef FC_DUMMY_MAIN_EQ_F77
9236 > #  ifdef __cplusplus
9237 >     extern "C"
9238 > #  endif
9239 >   int FC_DUMMY_MAIN() { return 1; }
9240 > #endif
9241 > #endif
9242 > int
9243 > main ()
9244 > {
9245 > return f != pow;
9246 >  ;
9247 >  return 0;
9248 > }
9249 > _ACEOF
9250 > rm -f conftest.$ac_objext conftest$ac_exeext
9251 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9252 >  (eval $ac_link) 2>conftest.er1
9253 >  ac_status=$?
9254 >  grep -v '^ *+' conftest.er1 >conftest.err
9255 >  rm -f conftest.er1
9256 >  cat conftest.err >&5
9257 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9258 >  (exit $ac_status); } &&
9259 >         { ac_try='test -z "$ac_c_werror_flag"
9260 >                         || test ! -s conftest.err'
9261 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9262 >  (eval $ac_try) 2>&5
9263 >  ac_status=$?
9264 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9265 >  (exit $ac_status); }; } &&
9266 >         { ac_try='test -s conftest$ac_exeext'
9267 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9268 >  (eval $ac_try) 2>&5
9269 >  ac_status=$?
9270 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9271 >  (exit $ac_status); }; }; then
9272 >  ac_cv_func_pow=yes
9273 > else
9274 >  echo "$as_me: failed program was:" >&5
9275 > sed 's/^/| /' conftest.$ac_ext >&5
9276 >
9277 > ac_cv_func_pow=no
9278 > fi
9279 > rm -f conftest.err conftest.$ac_objext \
9280 >      conftest$ac_exeext conftest.$ac_ext
9281 > fi
9282 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9283 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9284 >
9285 > if test $ac_cv_func_pow = no; then
9286 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9287 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9288 > if test "${ac_cv_lib_m_pow+set}" = set; then
9289 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9290 > else
9291 >  ac_check_lib_save_LIBS=$LIBS
9292 > LIBS="-lm  $LIBS"
9293 > cat >conftest.$ac_ext <<_ACEOF
9294 > /* confdefs.h.  */
9295 > _ACEOF
9296 > cat confdefs.h >>conftest.$ac_ext
9297 > cat >>conftest.$ac_ext <<_ACEOF
9298 > /* end confdefs.h.  */
9299 >
9300 > /* Override any gcc2 internal prototype to avoid an error.  */
9301 > #ifdef __cplusplus
9302 > extern "C"
9303 > #endif
9304 > /* We use char because int might match the return type of a gcc2
9305 >   builtin and then its argument prototype would still apply.  */
9306 > char pow ();
9307 > #ifdef FC_DUMMY_MAIN
9308 > #ifndef FC_DUMMY_MAIN_EQ_F77
9309 > #  ifdef __cplusplus
9310 >     extern "C"
9311 > #  endif
9312 >   int FC_DUMMY_MAIN() { return 1; }
9313 > #endif
9314 > #endif
9315 > int
9316 > main ()
9317 > {
9318 > pow ();
9319 >  ;
9320 >  return 0;
9321 > }
9322 > _ACEOF
9323 > rm -f conftest.$ac_objext conftest$ac_exeext
9324 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9325 >  (eval $ac_link) 2>conftest.er1
9326 >  ac_status=$?
9327 >  grep -v '^ *+' conftest.er1 >conftest.err
9328 >  rm -f conftest.er1
9329 >  cat conftest.err >&5
9330 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9331 >  (exit $ac_status); } &&
9332 >         { ac_try='test -z "$ac_c_werror_flag"
9333 >                         || test ! -s conftest.err'
9334 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9335 >  (eval $ac_try) 2>&5
9336 >  ac_status=$?
9337 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9338 >  (exit $ac_status); }; } &&
9339 >         { ac_try='test -s conftest$ac_exeext'
9340 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9341 >  (eval $ac_try) 2>&5
9342 >  ac_status=$?
9343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9344 >  (exit $ac_status); }; }; then
9345 >  ac_cv_lib_m_pow=yes
9346 > else
9347 >  echo "$as_me: failed program was:" >&5
9348 > sed 's/^/| /' conftest.$ac_ext >&5
9349 >
9350 > ac_cv_lib_m_pow=no
9351 > fi
9352 > rm -f conftest.err conftest.$ac_objext \
9353 >      conftest$ac_exeext conftest.$ac_ext
9354 > LIBS=$ac_check_lib_save_LIBS
9355 > fi
9356 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9357 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9358 > if test $ac_cv_lib_m_pow = yes; then
9359 >  POW_LIB=-lm
9360 > else
9361 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9362 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9363 > fi
9364 >
9365 > fi
9366 >
9367 > fi
9368 >
9369 >
9370 >
9371 >
9372 >
9373 >
9374 >
9375 >
9376 >
9377 >
9378 >
9379 >
9380 >
9381 >
9382 >
9383 >
9384 >
9385 >
9386 >
9387 >
9388 >
9389 >
9390 >
9391 >
9392 >
9393 >
9394 >
9395 >
9396 > 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
9397 > do
9398 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9399 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9400 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9401 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9402 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9403 > else
9404 >  cat >conftest.$ac_ext <<_ACEOF
9405 > /* confdefs.h.  */
9406 > _ACEOF
9407 > cat confdefs.h >>conftest.$ac_ext
9408 > cat >>conftest.$ac_ext <<_ACEOF
9409 > /* end confdefs.h.  */
9410 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9411 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9412 > #define $ac_func innocuous_$ac_func
9413 >
9414 > /* System header to define __stub macros and hopefully few prototypes,
9415 >    which can conflict with char $ac_func (); below.
9416 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9417 >    <limits.h> exists even on freestanding compilers.  */
9418 >
9419 > #ifdef __STDC__
9420 > # include <limits.h>
9421 > #else
9422 > # include <assert.h>
9423 > #endif
9424 >
9425 > #undef $ac_func
9426 >
9427 > /* Override any gcc2 internal prototype to avoid an error.  */
9428 > #ifdef __cplusplus
9429 > extern "C"
9430 > {
9431 > #endif
9432 > /* We use char because int might match the return type of a gcc2
9433 >   builtin and then its argument prototype would still apply.  */
9434 > char $ac_func ();
9435 > /* The GNU C library defines this for functions which it implements
9436 >    to always fail with ENOSYS.  Some functions are actually named
9437 >    something starting with __ and the normal name is an alias.  */
9438 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9439 > choke me
9440 > #else
9441 > char (*f) () = $ac_func;
9442 > #endif
9443 > #ifdef __cplusplus
9444 > }
9445 > #endif
9446 >
9447 > #ifdef FC_DUMMY_MAIN
9448 > #ifndef FC_DUMMY_MAIN_EQ_F77
9449 > #  ifdef __cplusplus
9450 >     extern "C"
9451 > #  endif
9452 >   int FC_DUMMY_MAIN() { return 1; }
9453 > #endif
9454 > #endif
9455 > int
9456 > main ()
9457 > {
9458 > return f != $ac_func;
9459 >  ;
9460 >  return 0;
9461 > }
9462 > _ACEOF
9463 > rm -f conftest.$ac_objext conftest$ac_exeext
9464 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9465 >  (eval $ac_link) 2>conftest.er1
9466 >  ac_status=$?
9467 >  grep -v '^ *+' conftest.er1 >conftest.err
9468 >  rm -f conftest.er1
9469 >  cat conftest.err >&5
9470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9471 >  (exit $ac_status); } &&
9472 >         { ac_try='test -z "$ac_c_werror_flag"
9473 >                         || test ! -s conftest.err'
9474 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9475 >  (eval $ac_try) 2>&5
9476 >  ac_status=$?
9477 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9478 >  (exit $ac_status); }; } &&
9479 >         { ac_try='test -s conftest$ac_exeext'
9480 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9481 >  (eval $ac_try) 2>&5
9482 >  ac_status=$?
9483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9484 >  (exit $ac_status); }; }; then
9485 >  eval "$as_ac_var=yes"
9486 > else
9487 >  echo "$as_me: failed program was:" >&5
9488 > sed 's/^/| /' conftest.$ac_ext >&5
9489 >
9490 > eval "$as_ac_var=no"
9491 > fi
9492 > rm -f conftest.err conftest.$ac_objext \
9493 >      conftest$ac_exeext conftest.$ac_ext
9494 > fi
9495 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9496 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9497 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9498 >  cat >>confdefs.h <<_ACEOF
9499 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9500 > _ACEOF
9501 >
9502 > fi
9503 > done
9504 >
9505 >
9506 > # special check for _system_configuration because AIX <4.3.2 do not
9507 > # contain the `physmem' member.
9508 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9509 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9510 > cat >conftest.$ac_ext <<_ACEOF
9511 > /* confdefs.h.  */
9512 > _ACEOF
9513 > cat confdefs.h >>conftest.$ac_ext
9514 > cat >>conftest.$ac_ext <<_ACEOF
9515 > /* end confdefs.h.  */
9516 > #include <sys/systemcfg.h>
9517 > #ifdef FC_DUMMY_MAIN
9518 > #ifndef FC_DUMMY_MAIN_EQ_F77
9519 > #  ifdef __cplusplus
9520 >     extern "C"
9521 > #  endif
9522 >   int FC_DUMMY_MAIN() { return 1; }
9523 > #endif
9524 > #endif
9525 > int
9526 > main ()
9527 > {
9528 > double x = _system_configuration.physmem;
9529 >  ;
9530 >  return 0;
9531 > }
9532 > _ACEOF
9533 > rm -f conftest.$ac_objext
9534 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9535 >  (eval $ac_compile) 2>conftest.er1
9536 >  ac_status=$?
9537 >  grep -v '^ *+' conftest.er1 >conftest.err
9538 >  rm -f conftest.er1
9539 >  cat conftest.err >&5
9540 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9541 >  (exit $ac_status); } &&
9542 >         { ac_try='test -z "$ac_c_werror_flag"
9543 >                         || test ! -s conftest.err'
9544 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9545 >  (eval $ac_try) 2>&5
9546 >  ac_status=$?
9547 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9548 >  (exit $ac_status); }; } &&
9549 >         { ac_try='test -s conftest.$ac_objext'
9550 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9551 >  (eval $ac_try) 2>&5
9552 >  ac_status=$?
9553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9554 >  (exit $ac_status); }; }; then
9555 >  echo "$as_me:$LINENO: result: yes" >&5
9556 > echo "${ECHO_T}yes" >&6
9557 >
9558 > cat >>confdefs.h <<\_ACEOF
9559 > #define HAVE__SYSTEM_CONFIGURATION 1
9560 > _ACEOF
9561 >
9562 > else
9563 >  echo "$as_me: failed program was:" >&5
9564 > sed 's/^/| /' conftest.$ac_ext >&5
9565 >
9566 > echo "$as_me:$LINENO: result: no" >&5
9567 > echo "${ECHO_T}no" >&6
9568 > fi
9569 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9570 >
9571 >  # clean out junk possibly left behind by a previous configuration
9572 >  rm -f src/getopt.h
9573 >  # Check for getopt_long support
9574 >
9575 > for ac_header in getopt.h
9576 > do
9577 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9578 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9579 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9580 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9581 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9582 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9583 > fi
9584 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9585 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9586 > else
9587 >  # Is the header compilable?
9588 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9589 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9590 > cat >conftest.$ac_ext <<_ACEOF
9591 > /* confdefs.h.  */
9592 > _ACEOF
9593 > cat confdefs.h >>conftest.$ac_ext
9594 > cat >>conftest.$ac_ext <<_ACEOF
9595 > /* end confdefs.h.  */
9596 > $ac_includes_default
9597 > #include <$ac_header>
9598 > _ACEOF
9599 > rm -f conftest.$ac_objext
9600 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9601 >  (eval $ac_compile) 2>conftest.er1
9602 >  ac_status=$?
9603 >  grep -v '^ *+' conftest.er1 >conftest.err
9604 >  rm -f conftest.er1
9605 >  cat conftest.err >&5
9606 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9607 >  (exit $ac_status); } &&
9608 >         { ac_try='test -z "$ac_c_werror_flag"
9609 >                         || test ! -s conftest.err'
9610 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9611 >  (eval $ac_try) 2>&5
9612 >  ac_status=$?
9613 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9614 >  (exit $ac_status); }; } &&
9615 >         { ac_try='test -s conftest.$ac_objext'
9616 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9617 >  (eval $ac_try) 2>&5
9618 >  ac_status=$?
9619 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9620 >  (exit $ac_status); }; }; then
9621 >  ac_header_compiler=yes
9622 > else
9623 >  echo "$as_me: failed program was:" >&5
9624 > sed 's/^/| /' conftest.$ac_ext >&5
9625 >
9626 > ac_header_compiler=no
9627 > fi
9628 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9629 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9630 > echo "${ECHO_T}$ac_header_compiler" >&6
9631 >
9632 > # Is the header present?
9633 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9634 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9635 > cat >conftest.$ac_ext <<_ACEOF
9636 > /* confdefs.h.  */
9637 > _ACEOF
9638 > cat confdefs.h >>conftest.$ac_ext
9639 > cat >>conftest.$ac_ext <<_ACEOF
9640 > /* end confdefs.h.  */
9641 > #include <$ac_header>
9642 > _ACEOF
9643 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9644 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9645 >  ac_status=$?
9646 >  grep -v '^ *+' conftest.er1 >conftest.err
9647 >  rm -f conftest.er1
9648 >  cat conftest.err >&5
9649 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9650 >  (exit $ac_status); } >/dev/null; then
9651 >  if test -s conftest.err; then
9652 >    ac_cpp_err=$ac_c_preproc_warn_flag
9653 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9654 >  else
9655 >    ac_cpp_err=
9656 >  fi
9657 > else
9658 >  ac_cpp_err=yes
9659 > fi
9660 > if test -z "$ac_cpp_err"; then
9661 >  ac_header_preproc=yes
9662 > else
9663 >  echo "$as_me: failed program was:" >&5
9664 > sed 's/^/| /' conftest.$ac_ext >&5
9665 >
9666 >  ac_header_preproc=no
9667 > fi
9668 > rm -f conftest.err conftest.$ac_ext
9669 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9670 > echo "${ECHO_T}$ac_header_preproc" >&6
9671 >
9672 > # So?  What about this header?
9673 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9674 >  yes:no: )
9675 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9676 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9677 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9678 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9679 >    ac_header_preproc=yes
9680 >    ;;
9681 >  no:yes:* )
9682 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9683 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9684 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9685 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9686 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9687 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9688 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9689 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9690 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9691 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9692 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9693 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9694 >    (
9695 >      cat <<\_ASBOX
9696 > ## ------------------------------ ##
9697 > ## Report this to gezelter@nd.edu ##
9698 > ## ------------------------------ ##
9699 > _ASBOX
9700 >    ) |
9701 >      sed "s/^/$as_me: WARNING:     /" >&2
9702 >    ;;
9703 > esac
9704 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9705 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9706 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9707 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9708 > else
9709 >  eval "$as_ac_Header=\$ac_header_preproc"
9710 > fi
9711 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9712 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9713 >
9714 > fi
9715 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9716 >  cat >>confdefs.h <<_ACEOF
9717 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9718 > _ACEOF
9719 >
9720 > fi
9721 >
9722 > done
9723 >
9724 >
9725 > for ac_func in getopt_long
9726 > do
9727 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9728 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9729 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9730 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9731 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9732 > else
9733 >  cat >conftest.$ac_ext <<_ACEOF
9734 > /* confdefs.h.  */
9735 > _ACEOF
9736 > cat confdefs.h >>conftest.$ac_ext
9737 > cat >>conftest.$ac_ext <<_ACEOF
9738 > /* end confdefs.h.  */
9739 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9740 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9741 > #define $ac_func innocuous_$ac_func
9742 >
9743 > /* System header to define __stub macros and hopefully few prototypes,
9744 >    which can conflict with char $ac_func (); below.
9745 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9746 >    <limits.h> exists even on freestanding compilers.  */
9747 >
9748 > #ifdef __STDC__
9749 > # include <limits.h>
9750 > #else
9751 > # include <assert.h>
9752 > #endif
9753 >
9754 > #undef $ac_func
9755 >
9756 > /* Override any gcc2 internal prototype to avoid an error.  */
9757 > #ifdef __cplusplus
9758 > extern "C"
9759 > {
9760 > #endif
9761 > /* We use char because int might match the return type of a gcc2
9762 >   builtin and then its argument prototype would still apply.  */
9763 > char $ac_func ();
9764 > /* The GNU C library defines this for functions which it implements
9765 >    to always fail with ENOSYS.  Some functions are actually named
9766 >    something starting with __ and the normal name is an alias.  */
9767 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9768 > choke me
9769 > #else
9770 > char (*f) () = $ac_func;
9771 > #endif
9772 > #ifdef __cplusplus
9773 > }
9774 > #endif
9775 >
9776 > #ifdef FC_DUMMY_MAIN
9777 > #ifndef FC_DUMMY_MAIN_EQ_F77
9778 > #  ifdef __cplusplus
9779 >     extern "C"
9780 > #  endif
9781 >   int FC_DUMMY_MAIN() { return 1; }
9782 > #endif
9783 > #endif
9784 > int
9785 > main ()
9786 > {
9787 > return f != $ac_func;
9788 >  ;
9789 >  return 0;
9790 > }
9791 > _ACEOF
9792 > rm -f conftest.$ac_objext conftest$ac_exeext
9793 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9794 >  (eval $ac_link) 2>conftest.er1
9795 >  ac_status=$?
9796 >  grep -v '^ *+' conftest.er1 >conftest.err
9797 >  rm -f conftest.er1
9798 >  cat conftest.err >&5
9799 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9800 >  (exit $ac_status); } &&
9801 >         { ac_try='test -z "$ac_c_werror_flag"
9802 >                         || test ! -s conftest.err'
9803 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9804 >  (eval $ac_try) 2>&5
9805 >  ac_status=$?
9806 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9807 >  (exit $ac_status); }; } &&
9808 >         { ac_try='test -s conftest$ac_exeext'
9809 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9810 >  (eval $ac_try) 2>&5
9811 >  ac_status=$?
9812 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9813 >  (exit $ac_status); }; }; then
9814 >  eval "$as_ac_var=yes"
9815 > else
9816 >  echo "$as_me: failed program was:" >&5
9817 > sed 's/^/| /' conftest.$ac_ext >&5
9818 >
9819 > eval "$as_ac_var=no"
9820 > fi
9821 > rm -f conftest.err conftest.$ac_objext \
9822 >      conftest$ac_exeext conftest.$ac_ext
9823 > fi
9824 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9825 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9826 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9827 >  cat >>confdefs.h <<_ACEOF
9828 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9829 > _ACEOF
9830 >
9831 > else
9832 >  # FreeBSD has a gnugetopt library for this
9833 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9834 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9835 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9836 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9837 > else
9838 >  ac_check_lib_save_LIBS=$LIBS
9839 > LIBS="-lgnugetopt  $LIBS"
9840 > cat >conftest.$ac_ext <<_ACEOF
9841 > /* confdefs.h.  */
9842 > _ACEOF
9843 > cat confdefs.h >>conftest.$ac_ext
9844 > cat >>conftest.$ac_ext <<_ACEOF
9845 > /* end confdefs.h.  */
9846 >
9847 > /* Override any gcc2 internal prototype to avoid an error.  */
9848 > #ifdef __cplusplus
9849 > extern "C"
9850 > #endif
9851 > /* We use char because int might match the return type of a gcc2
9852 >   builtin and then its argument prototype would still apply.  */
9853 > char getopt_long ();
9854 > #ifdef FC_DUMMY_MAIN
9855 > #ifndef FC_DUMMY_MAIN_EQ_F77
9856 > #  ifdef __cplusplus
9857 >     extern "C"
9858 > #  endif
9859 >   int FC_DUMMY_MAIN() { return 1; }
9860 > #endif
9861 > #endif
9862 > int
9863 > main ()
9864 > {
9865 > getopt_long ();
9866 >  ;
9867 >  return 0;
9868 > }
9869 > _ACEOF
9870 > rm -f conftest.$ac_objext conftest$ac_exeext
9871 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9872 >  (eval $ac_link) 2>conftest.er1
9873 >  ac_status=$?
9874 >  grep -v '^ *+' conftest.er1 >conftest.err
9875 >  rm -f conftest.er1
9876 >  cat conftest.err >&5
9877 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9878 >  (exit $ac_status); } &&
9879 >         { ac_try='test -z "$ac_c_werror_flag"
9880 >                         || test ! -s conftest.err'
9881 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9882 >  (eval $ac_try) 2>&5
9883 >  ac_status=$?
9884 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9885 >  (exit $ac_status); }; } &&
9886 >         { ac_try='test -s conftest$ac_exeext'
9887 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9888 >  (eval $ac_try) 2>&5
9889 >  ac_status=$?
9890 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9891 >  (exit $ac_status); }; }; then
9892 >  ac_cv_lib_gnugetopt_getopt_long=yes
9893 > else
9894 >  echo "$as_me: failed program was:" >&5
9895 > sed 's/^/| /' conftest.$ac_ext >&5
9896 >
9897 > ac_cv_lib_gnugetopt_getopt_long=no
9898 > fi
9899 > rm -f conftest.err conftest.$ac_objext \
9900 >      conftest$ac_exeext conftest.$ac_ext
9901 > LIBS=$ac_check_lib_save_LIBS
9902 > fi
9903 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9904 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9905 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9906 >  cat >>confdefs.h <<\_ACEOF
9907 > #define HAVE_GETOPT_LONG 1
9908 > _ACEOF
9909 >
9910 > else
9911 >  # use the GNU replacement
9912 >      case $LIBOBJS in
9913 >    "getopt.$ac_objext"   | \
9914 >  *" getopt.$ac_objext"   | \
9915 >    "getopt.$ac_objext "* | \
9916 >  *" getopt.$ac_objext "* ) ;;
9917 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9918 > esac
9919 >
9920 >      case $LIBOBJS in
9921 >    "getopt1.$ac_objext"   | \
9922 >  *" getopt1.$ac_objext"   | \
9923 >    "getopt1.$ac_objext "* | \
9924 >  *" getopt1.$ac_objext "* ) ;;
9925 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9926 > esac
9927 >
9928 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9929 >
9930 > fi
9931 >
9932 > fi
9933 > done
9934 >
9935 >
9936 > ac_ext=cc
9937 > ac_cpp='$CXXCPP $CPPFLAGS'
9938 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9939 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9940 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9941 >
9942 >
9943 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9944 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9945 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9946 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9947 > else
9948 >
9949 >
9950 > ac_ext=cc
9951 > ac_cpp='$CXXCPP $CPPFLAGS'
9952 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9953 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9954 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9955 >
9956 > cat >conftest.$ac_ext <<_ACEOF
9957   /* confdefs.h.  */
9958   _ACEOF
9959   cat confdefs.h >>conftest.$ac_ext
9960   cat >>conftest.$ac_ext <<_ACEOF
9961   /* end confdefs.h.  */
9962 < $ac_includes_default
9963 < #include <$ac_header>
9962 > namespace Outer { namespace Inner { int i = 0; }}
9963 > #ifdef FC_DUMMY_MAIN
9964 > #ifndef FC_DUMMY_MAIN_EQ_F77
9965 > #  ifdef __cplusplus
9966 >     extern "C"
9967 > #  endif
9968 >   int FC_DUMMY_MAIN() { return 1; }
9969 > #endif
9970 > #endif
9971 > int
9972 > main ()
9973 > {
9974 > using namespace Outer::Inner; return i;
9975 >  ;
9976 >  return 0;
9977 > }
9978   _ACEOF
9979   rm -f conftest.$ac_objext
9980   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5605 | Line 9985 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9985    cat conftest.err >&5
9986    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9987    (exit $ac_status); } &&
9988 <         { ac_try='test -z "$ac_c_werror_flag"
9988 >         { ac_try='test -z "$ac_cxx_werror_flag"
9989                           || test ! -s conftest.err'
9990    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9991    (eval $ac_try) 2>&5
# Line 5618 | Line 9998 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9998    ac_status=$?
9999    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10000    (exit $ac_status); }; }; then
10001 <  ac_header_compiler=yes
10001 >  ac_cv_cxx_namespaces=yes
10002   else
10003    echo "$as_me: failed program was:" >&5
10004   sed 's/^/| /' conftest.$ac_ext >&5
10005  
10006 < ac_header_compiler=no
10006 > ac_cv_cxx_namespaces=no
10007   fi
10008   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10009 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10010 < echo "${ECHO_T}$ac_header_compiler" >&6
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  
5632 # Is the header present?
5633 echo "$as_me:$LINENO: checking $ac_header presence" >&5
5634 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5635 cat >conftest.$ac_ext <<_ACEOF
5636 /* confdefs.h.  */
5637 _ACEOF
5638 cat confdefs.h >>conftest.$ac_ext
5639 cat >>conftest.$ac_ext <<_ACEOF
5640 /* end confdefs.h.  */
5641 #include <$ac_header>
5642 _ACEOF
5643 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5644  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5645  ac_status=$?
5646  grep -v '^ *+' conftest.er1 >conftest.err
5647  rm -f conftest.er1
5648  cat conftest.err >&5
5649  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5650  (exit $ac_status); } >/dev/null; then
5651  if test -s conftest.err; then
5652    ac_cpp_err=$ac_c_preproc_warn_flag
5653    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5654  else
5655    ac_cpp_err=
5656  fi
5657 else
5658  ac_cpp_err=yes
5659 fi
5660 if test -z "$ac_cpp_err"; then
5661  ac_header_preproc=yes
5662 else
5663  echo "$as_me: failed program was:" >&5
5664 sed 's/^/| /' conftest.$ac_ext >&5
10015  
5666  ac_header_preproc=no
10016   fi
10017 < rm -f conftest.err conftest.$ac_ext
10018 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10019 < echo "${ECHO_T}$ac_header_preproc" >&6
10017 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10018 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10019 > if test "$ac_cv_cxx_namespaces" = yes; then
10020  
10021 < # So?  What about this header?
10022 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5674 <  yes:no: )
5675 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5676 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5677 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5678 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5679 <    ac_header_preproc=yes
5680 <    ;;
5681 <  no:yes:* )
5682 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5683 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5684 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5685 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5686 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5687 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5688 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5689 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5690 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5691 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5692 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5693 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5694 <    (
5695 <      cat <<\_ASBOX
5696 < ## ------------------------------ ##
5697 < ## Report this to gezelter@nd.edu ##
5698 < ## ------------------------------ ##
5699 < _ASBOX
5700 <    ) |
5701 <      sed "s/^/$as_me: WARNING:     /" >&2
5702 <    ;;
5703 < esac
5704 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5705 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5706 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5707 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5708 < else
5709 <  eval "$as_ac_Header=\$ac_header_preproc"
5710 < fi
5711 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5712 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5713 <
5714 < fi
5715 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5716 <  cat >>confdefs.h <<_ACEOF
5717 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10021 > cat >>confdefs.h <<\_ACEOF
10022 > #define HAVE_NAMESPACES
10023   _ACEOF
10024  
10025   fi
10026  
5722 done
5723
10027   ac_ext=cc
10028   ac_cpp='$CXXCPP $CPPFLAGS'
10029   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10030   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10031   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5729
5730 ac_ext=cc
5731 ac_cpp='$CXXCPP $CPPFLAGS'
5732 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5733 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5734 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10032   echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10033   echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10034   if test -z "$CXXCPP"; then
# Line 5952 | Line 10249 | ac_cpp='$CXXCPP $CPPFLAGS'
10249   fi
10250  
10251   ac_ext=cc
10252 + ac_cpp='$CXXCPP $CPPFLAGS'
10253 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10254 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10255 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10256 +
10257 +
10258 + echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10259 + echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10260 + if test "${ac_cv_cxx_have_stl+set}" = set; then
10261 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10262 + else
10263 +
10264 +
10265 +
10266 + ac_ext=cc
10267 + ac_cpp='$CXXCPP $CPPFLAGS'
10268 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10269 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10270 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10271 +
10272 + cat >conftest.$ac_ext <<_ACEOF
10273 + /* confdefs.h.  */
10274 + _ACEOF
10275 + cat confdefs.h >>conftest.$ac_ext
10276 + cat >>conftest.$ac_ext <<_ACEOF
10277 + /* end confdefs.h.  */
10278 + #include <list>
10279 + #include <deque>
10280 + #ifdef HAVE_NAMESPACES
10281 + using namespace std;
10282 + #endif
10283 + #ifdef FC_DUMMY_MAIN
10284 + #ifndef FC_DUMMY_MAIN_EQ_F77
10285 + #  ifdef __cplusplus
10286 +     extern "C"
10287 + #  endif
10288 +   int FC_DUMMY_MAIN() { return 1; }
10289 + #endif
10290 + #endif
10291 + int
10292 + main ()
10293 + {
10294 + list<int> x; x.push_back(5);
10295 + list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10296 +  ;
10297 +  return 0;
10298 + }
10299 + _ACEOF
10300 + rm -f conftest.$ac_objext
10301 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10302 +  (eval $ac_compile) 2>conftest.er1
10303 +  ac_status=$?
10304 +  grep -v '^ *+' conftest.er1 >conftest.err
10305 +  rm -f conftest.er1
10306 +  cat conftest.err >&5
10307 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10308 +  (exit $ac_status); } &&
10309 +         { ac_try='test -z "$ac_cxx_werror_flag"
10310 +                         || test ! -s conftest.err'
10311 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10312 +  (eval $ac_try) 2>&5
10313 +  ac_status=$?
10314 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10315 +  (exit $ac_status); }; } &&
10316 +         { ac_try='test -s conftest.$ac_objext'
10317 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10318 +  (eval $ac_try) 2>&5
10319 +  ac_status=$?
10320 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10321 +  (exit $ac_status); }; }; then
10322 +  ac_cv_cxx_have_stl=yes
10323 + else
10324 +  echo "$as_me: failed program was:" >&5
10325 + sed 's/^/| /' conftest.$ac_ext >&5
10326 +
10327 + ac_cv_cxx_have_stl=no
10328 + fi
10329 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10330 + ac_ext=cc
10331   ac_cpp='$CXXCPP $CPPFLAGS'
10332   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10333   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10334   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10335  
10336  
10337 + fi
10338 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10339 + echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10340 + if test "$ac_cv_cxx_have_stl" = yes; then
10341  
10342 + cat >>confdefs.h <<\_ACEOF
10343 + #define HAVE_STL
10344 + _ACEOF
10345  
10346 + fi
10347  
10348  
10349  
10350 < for ac_header in ctype.h iostream fstream sstream strstream
10351 < do
10352 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10353 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5970 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5971 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5972 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10350 >  if test "${ac_cv_header_iostream+set}" = set; then
10351 >  echo "$as_me:$LINENO: checking for iostream" >&5
10352 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10353 > if test "${ac_cv_header_iostream+set}" = set; then
10354    echo $ECHO_N "(cached) $ECHO_C" >&6
10355   fi
10356 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10357 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10356 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10357 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10358   else
10359    # Is the header compilable?
10360 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
10361 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10360 > echo "$as_me:$LINENO: checking iostream usability" >&5
10361 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10362   cat >conftest.$ac_ext <<_ACEOF
10363   /* confdefs.h.  */
10364   _ACEOF
# Line 5985 | Line 10366 | $ac_includes_default
10366   cat >>conftest.$ac_ext <<_ACEOF
10367   /* end confdefs.h.  */
10368   $ac_includes_default
10369 < #include <$ac_header>
10369 > #include <iostream>
10370   _ACEOF
10371   rm -f conftest.$ac_objext
10372   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6021 | Line 10402 | echo "$as_me:$LINENO: checking $ac_header presence" >&
10402   echo "${ECHO_T}$ac_header_compiler" >&6
10403  
10404   # Is the header present?
10405 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
10406 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10405 > echo "$as_me:$LINENO: checking iostream presence" >&5
10406 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10407   cat >conftest.$ac_ext <<_ACEOF
10408   /* confdefs.h.  */
10409   _ACEOF
10410   cat confdefs.h >>conftest.$ac_ext
10411   cat >>conftest.$ac_ext <<_ACEOF
10412   /* end confdefs.h.  */
10413 < #include <$ac_header>
10413 > #include <iostream>
10414   _ACEOF
10415   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10416    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6063 | Line 10444 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
10444   # So?  What about this header?
10445   case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10446    yes:no: )
10447 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10448 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10449 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10450 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10447 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10448 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10449 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10450 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10451      ac_header_preproc=yes
10452      ;;
10453    no:yes:* )
10454 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10455 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10456 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10457 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10458 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10459 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10460 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10461 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10462 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10463 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10464 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10465 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10454 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10455 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10456 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10457 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10458 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10459 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10460 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10461 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10462 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10463 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10464 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10465 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10466      (
10467        cat <<\_ASBOX
10468   ## ------------------------------ ##
# Line 6092 | Line 10473 | echo "$as_me:$LINENO: checking for $ac_header" >&5
10473        sed "s/^/$as_me: WARNING:     /" >&2
10474      ;;
10475   esac
10476 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10477 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10478 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10476 > echo "$as_me:$LINENO: checking for iostream" >&5
10477 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10478 > if test "${ac_cv_header_iostream+set}" = set; then
10479    echo $ECHO_N "(cached) $ECHO_C" >&6
10480   else
10481 <  eval "$as_ac_Header=\$ac_header_preproc"
10481 >  ac_cv_header_iostream=$ac_header_preproc
10482   fi
10483 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10484 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10483 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10484 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10485  
10486   fi
10487 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6107 <  cat >>confdefs.h <<_ACEOF
6108 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6109 < _ACEOF
10487 > if test $ac_cv_header_iostream = yes; then
10488  
6111 fi
10489  
10490 < done
10490 > cat >>confdefs.h <<\_ACEOF
10491 > #define HAVE_IOSTREAM 1
10492 > _ACEOF
10493  
6115 ac_ext=c
6116 ac_cpp='$CPP $CPPFLAGS'
6117 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6118 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6119 ac_compiler_gnu=$ac_cv_c_compiler_gnu
10494  
10495 + else
10496  
10497  
10498 <
6124 < for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
10498 > for ac_header in iostream.h
10499   do
10500   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10501   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6154 | Line 10528 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10528    cat conftest.err >&5
10529    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10530    (exit $ac_status); } &&
10531 <         { ac_try='test -z "$ac_c_werror_flag"
10531 >         { ac_try='test -z "$ac_cxx_werror_flag"
10532                           || test ! -s conftest.err'
10533    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10534    (eval $ac_try) 2>&5
# Line 6198 | Line 10572 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10572    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10573    (exit $ac_status); } >/dev/null; then
10574    if test -s conftest.err; then
10575 <    ac_cpp_err=$ac_c_preproc_warn_flag
10576 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10575 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10576 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10577    else
10578      ac_cpp_err=
10579    fi
# Line 6219 | Line 10593 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
10593   echo "${ECHO_T}$ac_header_preproc" >&6
10594  
10595   # So?  What about this header?
10596 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10596 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10597    yes:no: )
10598      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10599   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6271 | Line 10645 | done
10645   done
10646  
10647  
10648 + fi
10649  
10650  
10651  
10652 < for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
10652 >
10653 >  if test "${ac_cv_header_iomanip+set}" = set; then
10654 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10655 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10656 > if test "${ac_cv_header_iomanip+set}" = set; then
10657 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10658 > fi
10659 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10660 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10661 > else
10662 >  # Is the header compilable?
10663 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10664 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10665 > cat >conftest.$ac_ext <<_ACEOF
10666 > /* confdefs.h.  */
10667 > _ACEOF
10668 > cat confdefs.h >>conftest.$ac_ext
10669 > cat >>conftest.$ac_ext <<_ACEOF
10670 > /* end confdefs.h.  */
10671 > $ac_includes_default
10672 > #include <iomanip>
10673 > _ACEOF
10674 > rm -f conftest.$ac_objext
10675 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10676 >  (eval $ac_compile) 2>conftest.er1
10677 >  ac_status=$?
10678 >  grep -v '^ *+' conftest.er1 >conftest.err
10679 >  rm -f conftest.er1
10680 >  cat conftest.err >&5
10681 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10682 >  (exit $ac_status); } &&
10683 >         { ac_try='test -z "$ac_cxx_werror_flag"
10684 >                         || test ! -s conftest.err'
10685 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10686 >  (eval $ac_try) 2>&5
10687 >  ac_status=$?
10688 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10689 >  (exit $ac_status); }; } &&
10690 >         { ac_try='test -s conftest.$ac_objext'
10691 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10692 >  (eval $ac_try) 2>&5
10693 >  ac_status=$?
10694 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10695 >  (exit $ac_status); }; }; then
10696 >  ac_header_compiler=yes
10697 > else
10698 >  echo "$as_me: failed program was:" >&5
10699 > sed 's/^/| /' conftest.$ac_ext >&5
10700 >
10701 > ac_header_compiler=no
10702 > fi
10703 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10704 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10705 > echo "${ECHO_T}$ac_header_compiler" >&6
10706 >
10707 > # Is the header present?
10708 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10709 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10710 > cat >conftest.$ac_ext <<_ACEOF
10711 > /* confdefs.h.  */
10712 > _ACEOF
10713 > cat confdefs.h >>conftest.$ac_ext
10714 > cat >>conftest.$ac_ext <<_ACEOF
10715 > /* end confdefs.h.  */
10716 > #include <iomanip>
10717 > _ACEOF
10718 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10719 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10720 >  ac_status=$?
10721 >  grep -v '^ *+' conftest.er1 >conftest.err
10722 >  rm -f conftest.er1
10723 >  cat conftest.err >&5
10724 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10725 >  (exit $ac_status); } >/dev/null; then
10726 >  if test -s conftest.err; then
10727 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10728 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10729 >  else
10730 >    ac_cpp_err=
10731 >  fi
10732 > else
10733 >  ac_cpp_err=yes
10734 > fi
10735 > if test -z "$ac_cpp_err"; then
10736 >  ac_header_preproc=yes
10737 > else
10738 >  echo "$as_me: failed program was:" >&5
10739 > sed 's/^/| /' conftest.$ac_ext >&5
10740 >
10741 >  ac_header_preproc=no
10742 > fi
10743 > rm -f conftest.err conftest.$ac_ext
10744 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10745 > echo "${ECHO_T}$ac_header_preproc" >&6
10746 >
10747 > # So?  What about this header?
10748 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10749 >  yes:no: )
10750 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10751 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10752 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10753 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10754 >    ac_header_preproc=yes
10755 >    ;;
10756 >  no:yes:* )
10757 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10758 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10759 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10760 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10761 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10762 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10763 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10764 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10765 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10766 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10767 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10768 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10769 >    (
10770 >      cat <<\_ASBOX
10771 > ## ------------------------------ ##
10772 > ## Report this to gezelter@nd.edu ##
10773 > ## ------------------------------ ##
10774 > _ASBOX
10775 >    ) |
10776 >      sed "s/^/$as_me: WARNING:     /" >&2
10777 >    ;;
10778 > esac
10779 > echo "$as_me:$LINENO: checking for iomanip" >&5
10780 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10781 > if test "${ac_cv_header_iomanip+set}" = set; then
10782 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10783 > else
10784 >  ac_cv_header_iomanip=$ac_header_preproc
10785 > fi
10786 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10787 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10788 >
10789 > fi
10790 > if test $ac_cv_header_iomanip = yes; then
10791 >
10792 >
10793 > cat >>confdefs.h <<\_ACEOF
10794 > #define HAVE_IOMANIP 1
10795 > _ACEOF
10796 >
10797 >
10798 > else
10799 >
10800 >
10801 > for ac_header in iomanip.h
10802   do
10803   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10804   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6307 | Line 10831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831    cat conftest.err >&5
10832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10833    (exit $ac_status); } &&
10834 <         { ac_try='test -z "$ac_c_werror_flag"
10834 >         { ac_try='test -z "$ac_cxx_werror_flag"
10835                           || test ! -s conftest.err'
10836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10837    (eval $ac_try) 2>&5
# Line 6351 | Line 10875 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10875    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10876    (exit $ac_status); } >/dev/null; then
10877    if test -s conftest.err; then
10878 <    ac_cpp_err=$ac_c_preproc_warn_flag
10879 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10878 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10879 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10880    else
10881      ac_cpp_err=
10882    fi
# Line 6372 | Line 10896 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
10896   echo "${ECHO_T}$ac_header_preproc" >&6
10897  
10898   # So?  What about this header?
10899 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10899 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10900    yes:no: )
10901      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10902   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6424 | Line 10948 | for ac_header in machine/hal_sysinfo.h
10948   done
10949  
10950  
10951 < for ac_header in machine/hal_sysinfo.h
10951 > fi
10952 >
10953 >
10954 >
10955 >
10956 > for ac_header in cmath
10957   do
10958   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10959   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6457 | Line 10986 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10986    cat conftest.err >&5
10987    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10988    (exit $ac_status); } &&
10989 <         { ac_try='test -z "$ac_c_werror_flag"
10989 >         { ac_try='test -z "$ac_cxx_werror_flag"
10990                           || test ! -s conftest.err'
10991    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10992    (eval $ac_try) 2>&5
# Line 6501 | Line 11030 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11030    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11031    (exit $ac_status); } >/dev/null; then
11032    if test -s conftest.err; then
11033 <    ac_cpp_err=$ac_c_preproc_warn_flag
11034 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11033 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11034 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11035    else
11036      ac_cpp_err=
11037    fi
# Line 6522 | Line 11051 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11051   echo "${ECHO_T}$ac_header_preproc" >&6
11052  
11053   # So?  What about this header?
11054 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11054 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11055    yes:no: )
11056      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11057   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6576 | Line 11105 | done
11105  
11106  
11107  
11108 <
11109 < for ac_func in rint snprintf sranddev strncasecmp
11110 < do
6582 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6583 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6584 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6585 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11108 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11109 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11110 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11111    echo $ECHO_N "(cached) $ECHO_C" >&6
11112   else
11113 <  cat >conftest.$ac_ext <<_ACEOF
11113 >
11114 >      ac_cv_cxx_have_std_iostream=no
11115 >      ac_cv_cxx_need_use_std_iostream=no
11116 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11117 >
11118 >
11119 >        ac_ext=cc
11120 > ac_cpp='$CXXCPP $CPPFLAGS'
11121 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11122 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11123 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11124 >
11125 >        cat >conftest.$ac_ext <<_ACEOF
11126   /* confdefs.h.  */
11127   _ACEOF
11128   cat confdefs.h >>conftest.$ac_ext
11129   cat >>conftest.$ac_ext <<_ACEOF
11130   /* end confdefs.h.  */
6594 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6595   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6596 #define $ac_func innocuous_$ac_func
11131  
11132 < /* System header to define __stub macros and hopefully few prototypes,
11133 <    which can conflict with char $ac_func (); below.
6600 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6601 <    <limits.h> exists even on freestanding compilers.  */
6602 <
6603 < #ifdef __STDC__
6604 < # include <limits.h>
11132 > #ifdef HAVE_IOSTREAM
11133 > #include <iostream>
11134   #else
11135 < # include <assert.h>
11135 > #include <iostream.h>
11136   #endif
11137  
11138 < #undef $ac_func
11139 <
11140 < /* Override any gcc2 internal prototype to avoid an error.  */
11141 < #ifdef __cplusplus
11142 < extern "C"
11143 < {
11138 > #ifdef FC_DUMMY_MAIN
11139 > #ifndef FC_DUMMY_MAIN_EQ_F77
11140 > #  ifdef __cplusplus
11141 >     extern "C"
11142 > #  endif
11143 >   int FC_DUMMY_MAIN() { return 1; }
11144   #endif
6616 /* We use char because int might match the return type of a gcc2
6617   builtin and then its argument prototype would still apply.  */
6618 char $ac_func ();
6619 /* The GNU C library defines this for functions which it implements
6620    to always fail with ENOSYS.  Some functions are actually named
6621    something starting with __ and the normal name is an alias.  */
6622 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6623 choke me
6624 #else
6625 char (*f) () = $ac_func;
11145   #endif
6627 #ifdef __cplusplus
6628 }
6629 #endif
6630
11146   int
11147   main ()
11148   {
11149 < return f != $ac_func;
11149 > std::cout<<"Hello World"<<std::endl;return 0;
11150    ;
11151    return 0;
11152   }
11153   _ACEOF
11154 < rm -f conftest.$ac_objext conftest$ac_exeext
11155 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11156 <  (eval $ac_link) 2>conftest.er1
11154 > rm -f conftest.$ac_objext
11155 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11156 >  (eval $ac_compile) 2>conftest.er1
11157    ac_status=$?
11158    grep -v '^ *+' conftest.er1 >conftest.err
11159    rm -f conftest.er1
11160    cat conftest.err >&5
11161    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11162    (exit $ac_status); } &&
11163 <         { ac_try='test -z "$ac_c_werror_flag"
11163 >         { ac_try='test -z "$ac_cxx_werror_flag"
11164                           || test ! -s conftest.err'
11165    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11166    (eval $ac_try) 2>&5
11167    ac_status=$?
11168    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11169    (exit $ac_status); }; } &&
11170 <         { ac_try='test -s conftest$ac_exeext'
11170 >         { ac_try='test -s conftest.$ac_objext'
11171    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11172    (eval $ac_try) 2>&5
11173    ac_status=$?
11174    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11175    (exit $ac_status); }; }; then
11176 <  eval "$as_ac_var=yes"
11176 >  ac_cv_cxx_have_std_iostream=yes
11177   else
11178    echo "$as_me: failed program was:" >&5
11179   sed 's/^/| /' conftest.$ac_ext >&5
11180  
6666 eval "$as_ac_var=no"
11181   fi
11182 < rm -f conftest.err conftest.$ac_objext \
11183 <      conftest$ac_exeext conftest.$ac_ext
6670 < fi
6671 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6672 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6673 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6674 <  cat >>confdefs.h <<_ACEOF
6675 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6676 < _ACEOF
6677 <
6678 < fi
6679 < done
6680 <
6681 <
6682 <
6683 <
6684 <
6685 <
6686 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6687 < do
6688 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6689 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6690 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6691 < if eval "test \"\${$as_ac_var+set}\" = set"; then
6692 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6693 < else
6694 <  cat >conftest.$ac_ext <<_ACEOF
11182 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11183 >        cat >conftest.$ac_ext <<_ACEOF
11184   /* confdefs.h.  */
11185   _ACEOF
11186   cat confdefs.h >>conftest.$ac_ext
11187   cat >>conftest.$ac_ext <<_ACEOF
11188   /* end confdefs.h.  */
6700 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6701   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6702 #define $ac_func innocuous_$ac_func
11189  
11190 < /* System header to define __stub macros and hopefully few prototypes,
11191 <    which can conflict with char $ac_func (); below.
11192 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6707 <    <limits.h> exists even on freestanding compilers.  */
6708 <
6709 < #ifdef __STDC__
6710 < # include <limits.h>
11190 > #define __USE_STD_IOSTREAM 1
11191 > #ifdef HAVE_IOSTREAM
11192 > #include <iostream>
11193   #else
11194 < # include <assert.h>
11194 > #include <iostream.h>
11195   #endif
11196  
11197 < #undef $ac_func
11198 <
11199 < /* Override any gcc2 internal prototype to avoid an error.  */
11200 < #ifdef __cplusplus
11201 < extern "C"
11202 < {
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
6722 /* We use char because int might match the return type of a gcc2
6723   builtin and then its argument prototype would still apply.  */
6724 char $ac_func ();
6725 /* The GNU C library defines this for functions which it implements
6726    to always fail with ENOSYS.  Some functions are actually named
6727    something starting with __ and the normal name is an alias.  */
6728 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6729 choke me
6730 #else
6731 char (*f) () = $ac_func;
11204   #endif
6733 #ifdef __cplusplus
6734 }
6735 #endif
6736
11205   int
11206   main ()
11207   {
11208 < return f != $ac_func;
11208 > std::cout<<"Hello World"<<std::endl;return 0;
11209    ;
11210    return 0;
11211   }
11212   _ACEOF
11213 < rm -f conftest.$ac_objext conftest$ac_exeext
11214 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11215 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"
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_exeext'
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 <  eval "$as_ac_var=yes"
11235 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11236   else
11237    echo "$as_me: failed program was:" >&5
11238   sed 's/^/| /' conftest.$ac_ext >&5
11239  
6772 eval "$as_ac_var=no"
11240   fi
11241 < rm -f conftest.err conftest.$ac_objext \
11242 <      conftest$ac_exeext conftest.$ac_ext
11243 < fi
11244 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11245 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11246 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6780 <  cat >>confdefs.h <<_ACEOF
6781 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6782 < _ACEOF
11241 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11242 >        ac_ext=cc
11243 > ac_cpp='$CXXCPP $CPPFLAGS'
11244 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11245 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11246 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11247  
11248 +      fi
11249 +
11250   fi
11251 < done
11251 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11252 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11253 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11254  
11255 < # special check for _system_configuration because AIX <4.3.2 do not
11256 < # contain the `physmem' member.
6789 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6790 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6791 < cat >conftest.$ac_ext <<_ACEOF
6792 < /* confdefs.h.  */
11255 > cat >>confdefs.h <<\_ACEOF
11256 > #define HAVE_STD_IOSTREAM 1
11257   _ACEOF
6794 cat confdefs.h >>conftest.$ac_ext
6795 cat >>conftest.$ac_ext <<_ACEOF
6796 /* end confdefs.h.  */
6797 #include <sys/systemcfg.h>
6798 int
6799 main ()
6800 {
6801 double x = _system_configuration.physmem;
6802  ;
6803  return 0;
6804 }
6805 _ACEOF
6806 rm -f conftest.$ac_objext
6807 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6808  (eval $ac_compile) 2>conftest.er1
6809  ac_status=$?
6810  grep -v '^ *+' conftest.er1 >conftest.err
6811  rm -f conftest.er1
6812  cat conftest.err >&5
6813  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6814  (exit $ac_status); } &&
6815         { ac_try='test -z "$ac_c_werror_flag"
6816                         || test ! -s conftest.err'
6817  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6818  (eval $ac_try) 2>&5
6819  ac_status=$?
6820  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6821  (exit $ac_status); }; } &&
6822         { ac_try='test -s conftest.$ac_objext'
6823  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6824  (eval $ac_try) 2>&5
6825  ac_status=$?
6826  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6827  (exit $ac_status); }; }; then
6828  echo "$as_me:$LINENO: result: yes" >&5
6829 echo "${ECHO_T}yes" >&6
11258  
11259 +  fi
11260 +  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11261 +
11262   cat >>confdefs.h <<\_ACEOF
11263 < #define HAVE__SYSTEM_CONFIGURATION 1
11263 > #define __USE_STD_IOSTREAM 1
11264   _ACEOF
11265  
11266 < else
6836 <  echo "$as_me: failed program was:" >&5
6837 < sed 's/^/| /' conftest.$ac_ext >&5
11266 >  fi
11267  
11268 < echo "$as_me:$LINENO: result: no" >&5
11269 < echo "${ECHO_T}no" >&6
11270 < fi
11271 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11272 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11273 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6845 < if test "${ac_cv_header_time+set}" = set; then
11268 >
11269 >
11270 >
11271 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11272 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11273 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11274    echo $ECHO_N "(cached) $ECHO_C" >&6
11275   else
11276 <  cat >conftest.$ac_ext <<_ACEOF
11276 >
11277 >      ac_cv_cxx_have_std_stl=no
11278 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11279 >
11280 >
11281 >        ac_ext=cc
11282 > ac_cpp='$CXXCPP $CPPFLAGS'
11283 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11284 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11285 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11286 >
11287 >        cat >conftest.$ac_ext <<_ACEOF
11288   /* confdefs.h.  */
11289   _ACEOF
11290   cat confdefs.h >>conftest.$ac_ext
11291   cat >>conftest.$ac_ext <<_ACEOF
11292   /* end confdefs.h.  */
11293 < #include <sys/types.h>
6855 < #include <sys/time.h>
6856 < #include <time.h>
11293 > #include <list>
11294  
11295 + #ifdef FC_DUMMY_MAIN
11296 + #ifndef FC_DUMMY_MAIN_EQ_F77
11297 + #  ifdef __cplusplus
11298 +     extern "C"
11299 + #  endif
11300 +   int FC_DUMMY_MAIN() { return 1; }
11301 + #endif
11302 + #endif
11303   int
11304   main ()
11305   {
11306 < if ((struct tm *) 0)
6862 < return 0;
11306 > std::list<int> foo;return 0;
11307    ;
11308    return 0;
11309   }
# Line 6873 | Line 11317 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11317    cat conftest.err >&5
11318    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11319    (exit $ac_status); } &&
11320 <         { ac_try='test -z "$ac_c_werror_flag"
11320 >         { ac_try='test -z "$ac_cxx_werror_flag"
11321                           || test ! -s conftest.err'
11322    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11323    (eval $ac_try) 2>&5
# Line 6886 | Line 11330 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11330    ac_status=$?
11331    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11332    (exit $ac_status); }; }; then
11333 <  ac_cv_header_time=yes
11333 >  ac_cv_cxx_have_std_stl=yes
11334   else
11335    echo "$as_me: failed program was:" >&5
11336   sed 's/^/| /' conftest.$ac_ext >&5
11337  
6894 ac_cv_header_time=no
11338   fi
11339   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
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 +      fi
11347 +
11348   fi
11349 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11350 < echo "${ECHO_T}$ac_cv_header_time" >&6
11351 < if test $ac_cv_header_time = yes; then
11349 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11350 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11351 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11352  
11353   cat >>confdefs.h <<\_ACEOF
11354 < #define TIME_WITH_SYS_TIME 1
11354 > #define HAVE_STD_STL 1
11355   _ACEOF
11356  
11357 < fi
11357 >  fi
11358  
11359  
11360 < echo "$as_me:$LINENO: checking for clock_t" >&5
11361 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11362 < if test "${ac_cv_type_clock_t+set}" = set; then
11360 >
11361 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11362 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11363 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11364    echo $ECHO_N "(cached) $ECHO_C" >&6
11365   else
11366 <  cat >conftest.$ac_ext <<_ACEOF
11366 >
11367 >    ac_cv_cxx_have_fstream_attach=no
11368 >
11369 >
11370 >    ac_ext=cc
11371 > ac_cpp='$CXXCPP $CPPFLAGS'
11372 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11373 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11374 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11375 >
11376 >    cat >conftest.$ac_ext <<_ACEOF
11377   /* confdefs.h.  */
11378   _ACEOF
11379   cat confdefs.h >>conftest.$ac_ext
11380   cat >>conftest.$ac_ext <<_ACEOF
11381   /* end confdefs.h.  */
11382 < $ac_includes_default
11382 >
11383 > #ifdef HAVE_IOSTREAM
11384 > #include <fstream>
11385 > #else
11386 > #include <fstream.h>
11387 > #endif
11388 > #ifdef HAVE_STD_IOSTREAM
11389 > using namespace std;
11390 > #endif
11391 >
11392 > #ifdef FC_DUMMY_MAIN
11393 > #ifndef FC_DUMMY_MAIN_EQ_F77
11394 > #  ifdef __cplusplus
11395 >     extern "C"
11396 > #  endif
11397 >   int FC_DUMMY_MAIN() { return 1; }
11398 > #endif
11399 > #endif
11400   int
11401   main ()
11402   {
11403 < if ((clock_t *) 0)
6925 <  return 0;
6926 < if (sizeof (clock_t))
6927 <  return 0;
11403 > int fd=0;ofstream s;s.attach(fd);
11404    ;
11405    return 0;
11406   }
# Line 6938 | Line 11414 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11414    cat conftest.err >&5
11415    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11416    (exit $ac_status); } &&
11417 <         { ac_try='test -z "$ac_c_werror_flag"
11417 >         { ac_try='test -z "$ac_cxx_werror_flag"
11418                           || test ! -s conftest.err'
11419    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11420    (eval $ac_try) 2>&5
# Line 6951 | Line 11427 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11427    ac_status=$?
11428    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11429    (exit $ac_status); }; }; then
11430 <  ac_cv_type_clock_t=yes
11430 >  ac_cv_cxx_have_fstream_attach=yes
11431   else
11432    echo "$as_me: failed program was:" >&5
11433   sed 's/^/| /' conftest.$ac_ext >&5
11434  
6959 ac_cv_type_clock_t=no
11435   fi
11436   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11437 < fi
11438 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11439 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11440 < if test $ac_cv_type_clock_t = yes; then
11437 >    ac_ext=cc
11438 > ac_cpp='$CXXCPP $CPPFLAGS'
11439 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11440 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11441 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11442  
6967 cat >>confdefs.h <<_ACEOF
6968 #define HAVE_CLOCK_T 1
6969 _ACEOF
11443  
6971
11444   fi
11445 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11446 + echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11447 +  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11448  
11449 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11450 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
6976 < if test "${ac_cv_c_const+set}" = set; then
6977 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6978 < else
6979 <  cat >conftest.$ac_ext <<_ACEOF
6980 < /* confdefs.h.  */
11449 > cat >>confdefs.h <<\_ACEOF
11450 > #define HAVE_FSTREAM_ATTACH 1
11451   _ACEOF
6982 cat confdefs.h >>conftest.$ac_ext
6983 cat >>conftest.$ac_ext <<_ACEOF
6984 /* end confdefs.h.  */
11452  
11453 < int
6987 < main ()
6988 < {
6989 < /* FIXME: Include the comments suggested by Paul. */
6990 < #ifndef __cplusplus
6991 <  /* Ultrix mips cc rejects this.  */
6992 <  typedef int charset[2];
6993 <  const charset x;
6994 <  /* SunOS 4.1.1 cc rejects this.  */
6995 <  char const *const *ccp;
6996 <  char **p;
6997 <  /* NEC SVR4.0.2 mips cc rejects this.  */
6998 <  struct point {int x, y;};
6999 <  static struct point const zero = {0,0};
7000 <  /* AIX XL C 1.02.0.0 rejects this.
7001 <     It does not let you subtract one const X* pointer from another in
7002 <     an arm of an if-expression whose if-part is not a constant
7003 <     expression */
7004 <  const char *g = "string";
7005 <  ccp = &g + (g ? g-g : 0);
7006 <  /* HPUX 7.0 cc rejects these. */
7007 <  ++ccp;
7008 <  p = (char**) ccp;
7009 <  ccp = (char const *const *) p;
7010 <  { /* SCO 3.2v4 cc rejects this.  */
7011 <    char *t;
7012 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
11453 >  fi
11454  
7014    *t++ = 0;
7015  }
7016  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7017    int x[] = {25, 17};
7018    const int *foo = &x[0];
7019    ++foo;
7020  }
7021  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7022    typedef const int *iptr;
7023    iptr p = 0;
7024    ++p;
7025  }
7026  { /* AIX XL C 1.02.0.0 rejects this saying
7027       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7028    struct s { int j; const int *ap[3]; };
7029    struct s *b; b->j = 5;
7030  }
7031  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7032    const int foo = 10;
7033  }
7034 #endif
11455  
11456 <  ;
11457 <  return 0;
11458 < }
11459 < _ACEOF
11460 < rm -f conftest.$ac_objext
7041 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7042 <  (eval $ac_compile) 2>conftest.er1
7043 <  ac_status=$?
7044 <  grep -v '^ *+' conftest.er1 >conftest.err
7045 <  rm -f conftest.er1
7046 <  cat conftest.err >&5
7047 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7048 <  (exit $ac_status); } &&
7049 <         { ac_try='test -z "$ac_c_werror_flag"
7050 <                         || test ! -s conftest.err'
7051 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7052 <  (eval $ac_try) 2>&5
7053 <  ac_status=$?
7054 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7055 <  (exit $ac_status); }; } &&
7056 <         { ac_try='test -s conftest.$ac_objext'
7057 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7058 <  (eval $ac_try) 2>&5
7059 <  ac_status=$?
7060 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7061 <  (exit $ac_status); }; }; then
7062 <  ac_cv_c_const=yes
11456 >
11457 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11458 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11459 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11460 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11461   else
7064  echo "$as_me: failed program was:" >&5
7065 sed 's/^/| /' conftest.$ac_ext >&5
11462  
11463 < ac_cv_c_const=no
11464 < fi
7069 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7070 < fi
7071 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7072 < echo "${ECHO_T}$ac_cv_c_const" >&6
7073 < if test $ac_cv_c_const = no; then
11463 >    ac_cv_cxx_have_fstream_open=no
11464 >    ac_cv_cxx_fstream_open_prot=no
11465  
11466 < cat >>confdefs.h <<\_ACEOF
11467 < #define const
11468 < _ACEOF
11466 >
11467 >    ac_ext=cc
11468 > ac_cpp='$CXXCPP $CPPFLAGS'
11469 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11470 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11471 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11472  
11473 < fi
11474 <
7081 < echo "$as_me:$LINENO: checking for inline" >&5
7082 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7083 < if test "${ac_cv_c_inline+set}" = set; then
7084 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7085 < else
7086 <  ac_cv_c_inline=no
7087 < for ac_kw in inline __inline__ __inline; do
7088 <  cat >conftest.$ac_ext <<_ACEOF
11473 >    # Try with 2 parameters
11474 >    cat >conftest.$ac_ext <<_ACEOF
11475   /* confdefs.h.  */
11476   _ACEOF
11477   cat confdefs.h >>conftest.$ac_ext
11478   cat >>conftest.$ac_ext <<_ACEOF
11479   /* end confdefs.h.  */
11480 < #ifndef __cplusplus
11481 < typedef int foo_t;
11482 < static $ac_kw foo_t static_foo () {return 0; }
11483 < $ac_kw foo_t foo () {return 0; }
11480 >
11481 > #ifdef HAVE_IOSTREAM
11482 > #include <fstream>
11483 > #else
11484 > #include <fstream.h>
11485   #endif
11486 + #ifdef HAVE_STD_IOSTREAM
11487 + using namespace std;
11488 + #endif
11489  
11490 + #ifdef FC_DUMMY_MAIN
11491 + #ifndef FC_DUMMY_MAIN_EQ_F77
11492 + #  ifdef __cplusplus
11493 +     extern "C"
11494 + #  endif
11495 +   int FC_DUMMY_MAIN() { return 1; }
11496 + #endif
11497 + #endif
11498 + int
11499 + main ()
11500 + {
11501 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11502 +  ;
11503 +  return 0;
11504 + }
11505   _ACEOF
11506   rm -f conftest.$ac_objext
11507   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7107 | Line 11512 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11512    cat conftest.err >&5
11513    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11514    (exit $ac_status); } &&
11515 <         { ac_try='test -z "$ac_c_werror_flag"
11515 >         { ac_try='test -z "$ac_cxx_werror_flag"
11516                           || test ! -s conftest.err'
11517    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11518    (eval $ac_try) 2>&5
# Line 7120 | Line 11525 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11525    ac_status=$?
11526    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11527    (exit $ac_status); }; }; then
11528 <  ac_cv_c_inline=$ac_kw; break
11528 >  ac_cv_cxx_have_fstream_open=yes
11529   else
11530    echo "$as_me: failed program was:" >&5
11531   sed 's/^/| /' conftest.$ac_ext >&5
11532  
11533   fi
11534   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11535 < done
11536 <
7132 < fi
7133 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7134 < echo "${ECHO_T}$ac_cv_c_inline" >&6
7135 <
7136 <
7137 < case $ac_cv_c_inline in
7138 <  inline | yes) ;;
7139 <  *)
7140 <    case $ac_cv_c_inline in
7141 <      no) ac_val=;;
7142 <      *) ac_val=$ac_cv_c_inline;;
7143 <    esac
7144 <    cat >>confdefs.h <<_ACEOF
7145 < #ifndef __cplusplus
7146 < #define inline $ac_val
7147 < #endif
7148 < _ACEOF
7149 <    ;;
7150 < esac
7151 <
7152 <
7153 <
7154 <
7155 < for ac_func in rint sranddev
7156 < do
7157 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7158 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7159 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7160 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7161 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7162 < else
7163 <  cat >conftest.$ac_ext <<_ACEOF
11535 >    # Try with mode parameter
11536 >    cat >conftest.$ac_ext <<_ACEOF
11537   /* confdefs.h.  */
11538   _ACEOF
11539   cat confdefs.h >>conftest.$ac_ext
11540   cat >>conftest.$ac_ext <<_ACEOF
11541   /* end confdefs.h.  */
7169 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7170   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7171 #define $ac_func innocuous_$ac_func
11542  
11543 < /* System header to define __stub macros and hopefully few prototypes,
11544 <    which can conflict with char $ac_func (); below.
7175 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7176 <    <limits.h> exists even on freestanding compilers.  */
7177 <
7178 < #ifdef __STDC__
7179 < # include <limits.h>
11543 > #ifdef HAVE_IOSTREAM
11544 > #include <fstream>
11545   #else
11546 < # include <assert.h>
11546 > #include <fstream.h>
11547   #endif
11548 + #ifdef HAVE_STD_IOSTREAM
11549 + using namespace std;
11550 + #endif
11551  
11552 < #undef $ac_func
11553 <
11554 < /* Override any gcc2 internal prototype to avoid an error.  */
11555 < #ifdef __cplusplus
11556 < extern "C"
11557 < {
11552 > #ifdef FC_DUMMY_MAIN
11553 > #ifndef FC_DUMMY_MAIN_EQ_F77
11554 > #  ifdef __cplusplus
11555 >     extern "C"
11556 > #  endif
11557 >   int FC_DUMMY_MAIN() { return 1; }
11558   #endif
7191 /* We use char because int might match the return type of a gcc2
7192   builtin and then its argument prototype would still apply.  */
7193 char $ac_func ();
7194 /* The GNU C library defines this for functions which it implements
7195    to always fail with ENOSYS.  Some functions are actually named
7196    something starting with __ and the normal name is an alias.  */
7197 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7198 choke me
7199 #else
7200 char (*f) () = $ac_func;
11559   #endif
7202 #ifdef __cplusplus
7203 }
7204 #endif
7205
11560   int
11561   main ()
11562   {
11563 < return f != $ac_func;
11563 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11564    ;
11565    return 0;
11566   }
11567   _ACEOF
11568 < rm -f conftest.$ac_objext conftest$ac_exeext
11569 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11570 <  (eval $ac_link) 2>conftest.er1
11568 > rm -f conftest.$ac_objext
11569 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11570 >  (eval $ac_compile) 2>conftest.er1
11571    ac_status=$?
11572    grep -v '^ *+' conftest.er1 >conftest.err
11573    rm -f conftest.er1
11574    cat conftest.err >&5
11575    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11576    (exit $ac_status); } &&
11577 <         { ac_try='test -z "$ac_c_werror_flag"
11577 >         { ac_try='test -z "$ac_cxx_werror_flag"
11578                           || test ! -s conftest.err'
11579    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11580    (eval $ac_try) 2>&5
11581    ac_status=$?
11582    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11583    (exit $ac_status); }; } &&
11584 <         { ac_try='test -s conftest$ac_exeext'
11584 >         { ac_try='test -s conftest.$ac_objext'
11585    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11586    (eval $ac_try) 2>&5
11587    ac_status=$?
11588    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11589    (exit $ac_status); }; }; then
11590 <  eval "$as_ac_var=yes"
11590 >  ac_cv_cxx_fstream_open_prot=yes
11591   else
11592    echo "$as_me: failed program was:" >&5
11593   sed 's/^/| /' conftest.$ac_ext >&5
11594  
7241 eval "$as_ac_var=no"
11595   fi
11596 < rm -f conftest.err conftest.$ac_objext \
11597 <      conftest$ac_exeext conftest.$ac_ext
11596 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11597 >    ac_ext=cc
11598 > ac_cpp='$CXXCPP $CPPFLAGS'
11599 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11600 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11601 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11602 >
11603 >
11604   fi
11605 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11606 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11607 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11608 <  cat >>confdefs.h <<_ACEOF
11609 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11605 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11606 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11607 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11608 >
11609 > cat >>confdefs.h <<\_ACEOF
11610 > #define HAVE_FSTREAM_OPEN 1
11611   _ACEOF
11612  
11613 < fi
11614 < done
11613 >  fi
11614 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11615  
11616 + cat >>confdefs.h <<\_ACEOF
11617 + #define FSTREAM_OPEN_PROT 1
11618 + _ACEOF
11619  
11620 <  # clean out junk possibly left behind by a previous configuration
7258 <  rm -f src/getopt.h
7259 <  # Check for getopt_long support
11620 >  fi
11621  
11622 < for ac_header in getopt.h
11622 >
11623 >
11624 >
11625 >
11626 >
11627 >
11628 > for ac_header in ctype.h iostream fstream sstream strstream
11629   do
11630   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11631   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7291 | Line 11658 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11658    cat conftest.err >&5
11659    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11660    (exit $ac_status); } &&
11661 <         { ac_try='test -z "$ac_c_werror_flag"
11661 >         { ac_try='test -z "$ac_cxx_werror_flag"
11662                           || test ! -s conftest.err'
11663    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11664    (eval $ac_try) 2>&5
# Line 7335 | Line 11702 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11702    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11703    (exit $ac_status); } >/dev/null; then
11704    if test -s conftest.err; then
11705 <    ac_cpp_err=$ac_c_preproc_warn_flag
11706 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11705 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11706 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11707    else
11708      ac_cpp_err=
11709    fi
# Line 7356 | Line 11723 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11723   echo "${ECHO_T}$ac_header_preproc" >&6
11724  
11725   # So?  What about this header?
11726 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11726 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11727    yes:no: )
11728      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11729   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7407 | Line 11774 | done
11774  
11775   done
11776  
11777 + # AC_CPP_FUNC
11778 + # ------------------ #
11779 + # Checks to see if ANSI C99 CPP variable __func__ works.
11780 + # If not, perhaps __FUNCTION__ works instead.
11781 + # If not, we'll just define __func__ to "".
11782 + # AC_CPP_FUNC
11783  
11784 < for ac_func in getopt_long
11785 < do
11786 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11787 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7415 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7416 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11784 >
11785 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11786 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11787 > if test "${ac_cv_cpp_func+set}" = set; then
11788    echo $ECHO_N "(cached) $ECHO_C" >&6
11789   else
11790    cat >conftest.$ac_ext <<_ACEOF
# Line 7422 | Line 11793 | cat >>conftest.$ac_ext <<_ACEOF
11793   cat confdefs.h >>conftest.$ac_ext
11794   cat >>conftest.$ac_ext <<_ACEOF
11795   /* end confdefs.h.  */
7425 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7426   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7427 #define $ac_func innocuous_$ac_func
11796  
11797 < /* System header to define __stub macros and hopefully few prototypes,
11798 <    which can conflict with char $ac_func (); below.
11799 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11800 <    <limits.h> exists even on freestanding compilers.  */
11801 <
11802 < #ifdef __STDC__
7435 < # include <limits.h>
7436 < #else
7437 < # include <assert.h>
11797 > #ifdef FC_DUMMY_MAIN
11798 > #ifndef FC_DUMMY_MAIN_EQ_F77
11799 > #  ifdef __cplusplus
11800 >     extern "C"
11801 > #  endif
11802 >   int FC_DUMMY_MAIN() { return 1; }
11803   #endif
7439
7440 #undef $ac_func
7441
7442 /* Override any gcc2 internal prototype to avoid an error.  */
7443 #ifdef __cplusplus
7444 extern "C"
7445 {
11804   #endif
7447 /* We use char because int might match the return type of a gcc2
7448   builtin and then its argument prototype would still apply.  */
7449 char $ac_func ();
7450 /* The GNU C library defines this for functions which it implements
7451    to always fail with ENOSYS.  Some functions are actually named
7452    something starting with __ and the normal name is an alias.  */
7453 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7454 choke me
7455 #else
7456 char (*f) () = $ac_func;
7457 #endif
7458 #ifdef __cplusplus
7459 }
7460 #endif
7461
11805   int
11806   main ()
11807   {
11808 < return f != $ac_func;
11808 > const char *foo = __func__;
11809    ;
11810    return 0;
11811   }
11812   _ACEOF
11813 < rm -f conftest.$ac_objext conftest$ac_exeext
11814 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11815 <  (eval $ac_link) 2>conftest.er1
11813 > rm -f conftest.$ac_objext
11814 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11815 >  (eval $ac_compile) 2>conftest.er1
11816    ac_status=$?
11817    grep -v '^ *+' conftest.er1 >conftest.err
11818    rm -f conftest.er1
11819    cat conftest.err >&5
11820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821    (exit $ac_status); } &&
11822 <         { ac_try='test -z "$ac_c_werror_flag"
11822 >         { ac_try='test -z "$ac_cxx_werror_flag"
11823                           || test ! -s conftest.err'
11824    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825    (eval $ac_try) 2>&5
11826    ac_status=$?
11827    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11828    (exit $ac_status); }; } &&
11829 <         { ac_try='test -s conftest$ac_exeext'
11829 >         { ac_try='test -s conftest.$ac_objext'
11830    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11831    (eval $ac_try) 2>&5
11832    ac_status=$?
11833    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834    (exit $ac_status); }; }; then
11835 <  eval "$as_ac_var=yes"
11835 >  ac_cv_cpp_func=yes
11836   else
11837    echo "$as_me: failed program was:" >&5
11838   sed 's/^/| /' conftest.$ac_ext >&5
11839  
7497 eval "$as_ac_var=no"
7498 fi
7499 rm -f conftest.err conftest.$ac_objext \
7500      conftest$ac_exeext conftest.$ac_ext
7501 fi
7502 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7503 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7504 if test `eval echo '${'$as_ac_var'}'` = yes; then
7505  cat >>confdefs.h <<_ACEOF
7506 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7507 _ACEOF
7508
7509 else
7510  # FreeBSD has a gnugetopt library for this
7511    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7512 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7513 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7514  echo $ECHO_N "(cached) $ECHO_C" >&6
7515 else
7516  ac_check_lib_save_LIBS=$LIBS
7517 LIBS="-lgnugetopt  $LIBS"
11840   cat >conftest.$ac_ext <<_ACEOF
11841   /* confdefs.h.  */
11842   _ACEOF
# Line 7522 | Line 11844 | cat >>conftest.$ac_ext <<_ACEOF
11844   cat >>conftest.$ac_ext <<_ACEOF
11845   /* end confdefs.h.  */
11846  
11847 < /* Override any gcc2 internal prototype to avoid an error.  */
11848 < #ifdef __cplusplus
11849 < extern "C"
11847 > #ifdef FC_DUMMY_MAIN
11848 > #ifndef FC_DUMMY_MAIN_EQ_F77
11849 > #  ifdef __cplusplus
11850 >     extern "C"
11851 > #  endif
11852 >   int FC_DUMMY_MAIN() { return 1; }
11853   #endif
11854 < /* We use char because int might match the return type of a gcc2
7530 <   builtin and then its argument prototype would still apply.  */
7531 < char getopt_long ();
11854 > #endif
11855   int
11856   main ()
11857   {
11858 < getopt_long ();
11858 > const char *foo = __FUNCTION__;
11859    ;
11860    return 0;
11861   }
11862   _ACEOF
11863 < rm -f conftest.$ac_objext conftest$ac_exeext
11864 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11865 <  (eval $ac_link) 2>conftest.er1
11863 > rm -f conftest.$ac_objext
11864 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11865 >  (eval $ac_compile) 2>conftest.er1
11866    ac_status=$?
11867    grep -v '^ *+' conftest.er1 >conftest.err
11868    rm -f conftest.er1
11869    cat conftest.err >&5
11870    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11871    (exit $ac_status); } &&
11872 <         { ac_try='test -z "$ac_c_werror_flag"
11872 >         { ac_try='test -z "$ac_cxx_werror_flag"
11873                           || test ! -s conftest.err'
11874    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11875    (eval $ac_try) 2>&5
11876    ac_status=$?
11877    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11878    (exit $ac_status); }; } &&
11879 <         { ac_try='test -s conftest$ac_exeext'
11879 >         { ac_try='test -s conftest.$ac_objext'
11880    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11881    (eval $ac_try) 2>&5
11882    ac_status=$?
11883    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11884    (exit $ac_status); }; }; then
11885 <  ac_cv_lib_gnugetopt_getopt_long=yes
11885 >  ac_cv_cpp_func=__FUNCTION__
11886   else
11887    echo "$as_me: failed program was:" >&5
11888   sed 's/^/| /' conftest.$ac_ext >&5
11889  
11890 < ac_cv_lib_gnugetopt_getopt_long=no
11890 > ac_cv_cpp_func=no
11891   fi
11892 < rm -f conftest.err conftest.$ac_objext \
7570 <      conftest$ac_exeext conftest.$ac_ext
7571 < LIBS=$ac_check_lib_save_LIBS
11892 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11893   fi
11894 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11895 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11896 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11897 <  cat >>confdefs.h <<\_ACEOF
11898 < #define HAVE_GETOPT_LONG 1
11894 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11895 > fi
11896 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11897 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11898 > if test $ac_cv_cpp_func = __FUNCTION__; then
11899 >
11900 > cat >>confdefs.h <<\_ACEOF
11901 > #define __func__ __FUNCTION__
11902   _ACEOF
11903  
11904 < else
7581 <  # use the GNU replacement
7582 <      case $LIBOBJS in
7583 <    "getopt.$ac_objext"   | \
7584 <  *" getopt.$ac_objext"   | \
7585 <    "getopt.$ac_objext "* | \
7586 <  *" getopt.$ac_objext "* ) ;;
7587 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7588 < esac
11904 > elif test $ac_cv_cpp_func = no; then
11905  
11906 <      case $LIBOBJS in
11907 <    "getopt1.$ac_objext"   | \
11908 <  *" getopt1.$ac_objext"   | \
7593 <    "getopt1.$ac_objext "* | \
7594 <  *" getopt1.$ac_objext "* ) ;;
7595 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7596 < esac
11906 > cat >>confdefs.h <<\_ACEOF
11907 > #define __func__ ""
11908 > _ACEOF
11909  
7598                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7599
11910   fi
11911  
7602 fi
7603 done
11912  
11913  
11914  
11915 +
11916   case $debug in
11917    1)
11918       ;;
11919    *)
11920 +
11921 +
11922 +
11923 +
11924 + # Try to determine "good" native compiler flags if none specified on command
11925 + # line
11926 +
11927 + if test "$ac_test_FFLAGS" != "set"; then
11928 +  FCFLAGS=""
11929 +  case "${host_cpu}-${host_os}" in
11930 +
11931 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11932 +                    FCFLAGS="-O3 -ip -no-prec-div"
11933 +                fi;;
11934 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11935 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11936 +                fi;;
11937 +   powerpc*-aix*)
11938 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11939 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11940 +                echo "*******************************************************"
11941 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11942 +                echo "*  recommended that you use                           *"
11943 +                echo "*                                                     *"
11944 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11945 +                echo "*                                 ^^^                 *"
11946 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11947 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11948 +                echo "*******************************************************"
11949 +        fi;;
11950 +   *darwin*)
11951 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11952 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11953 +        fi
11954 +        if test "$FC" = ifort; then
11955 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11956 +        fi;;
11957 +  esac
11958  
11959 +  if test -n "$CPU_FLAGS"; then
11960 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11961 +  fi
11962  
11963 +  if test -z "$FCFLAGS"; then
11964 +        echo ""
11965 +        echo "*********************************************************"
11966 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11967 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11968 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11969 +        echo "*********************************************************"
11970 +        echo ""
11971 +        FCFLAGS="-O3"
11972 +  fi
11973  
11974  
11975 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11976 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11977 + if test "${ac_guessed_f90flags+set}" = set; then
11978 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11979 + else
11980  
11981  
11982 +
11983 + ac_ext=${FC_SRCEXT-f}
11984 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11985 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11986 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11987 +
11988 + echo 'program main' > conftest.$ac_ext
11989 + echo 'end program main' >> conftest.$ac_ext
11990 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11991 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11992 +  (eval $ac_compile) 2>&5
11993 +  ac_status=$?
11994 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11995 +  (exit $ac_status); }; then
11996 +        ac_guessed_f90flags=yes
11997 + else
11998 +        ac_guessed_f90flags=no
11999 + fi
12000 + rm -f conftest*
12001 + ac_ext=cc
12002 + ac_cpp='$CXXCPP $CPPFLAGS'
12003 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12004 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12005 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12006 +
12007 +
12008 + fi
12009 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12010 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12011 + if test "$ac_guessed_f90flags" = yes; then
12012 +        :
12013 +
12014 + else
12015 +        :
12016 +
12017 +        echo ""
12018 +        echo "**********************************************************"
12019 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12020 +        echo "* your compiler.                                        *"
12021 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12022 +        echo "*********************************************************"
12023 +        echo ""
12024 +        FCFLAGS=""
12025 +
12026 + fi
12027 +
12028 +
12029 + fi
12030 +
12031 +
12032 +
12033 +
12034 +
12035 +
12036 +
12037   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12038   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12039   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 7662 | Line 12082 | if test "$ac_test_CFLAGS" != "set"; then
12082                      CFLAGS="-O"
12083                  fi;;
12084    sparc-solaris2*) if test "$CC" = cc; then
12085 <                    CFLAGS="-native -fast -xO5 -dalign"
12085 >                    CFLAGS="-O -dalign"
12086                   fi;;
12087  
12088    alpha*-osf*)  if test "$CC" = cc; then
# Line 7692 | Line 12112 | if test "$ac_test_CFLAGS" != "set"; then
12112     *darwin*)
12113          if test "$CC" = xlc -o "$CC" = cc; then
12114                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12115 +        fi
12116 +        if test "$CC" = icc; then
12117 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12118          fi;;
12119    esac
12120  
# Line 7705 | Line 12128 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12128      # -malign-double for x86 systems
12129  
12130  
12131 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12132 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12131 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12132 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12133   if test "${ac_align_double+set}" = set; then
12134    echo $ECHO_N "(cached) $ECHO_C" >&6
12135   else
12136    echo 'void f(){}' > conftest.c
12137 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12137 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12138          ac_align_double=yes
12139   else
12140          ac_align_double=no
# Line 7732 | Line 12155 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12155      # -fstrict-aliasing for gcc-2.95+
12156  
12157  
12158 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12159 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12158 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12159 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12160   if test "${ac_fstrict_aliasing+set}" = set; then
12161    echo $ECHO_N "(cached) $ECHO_C" >&6
12162   else
12163    echo 'void f(){}' > conftest.c
12164 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12164 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12165          ac_fstrict_aliasing=yes
12166   else
12167          ac_fstrict_aliasing=no
# Line 7763 | Line 12186 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12186                    case "${host_cpu}" in
12187            i586*)
12188  
12189 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12190 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12189 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12190 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12191   if test "${ac_cpu_pentium+set}" = set; then
12192    echo $ECHO_N "(cached) $ECHO_C" >&6
12193   else
12194    echo 'void f(){}' > conftest.c
12195 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12195 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12196          ac_cpu_pentium=yes
12197   else
12198          ac_cpu_pentium=no
# Line 7786 | Line 12209 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12209          :
12210  
12211  
12212 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12213 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12212 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12213 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12214   if test "${ac_pentium+set}" = set; then
12215    echo $ECHO_N "(cached) $ECHO_C" >&6
12216   else
12217    echo 'void f(){}' > conftest.c
12218 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12218 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12219          ac_pentium=yes
12220   else
12221          ac_pentium=no
# Line 7815 | Line 12238 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12238                    ;;
12239            i686*)
12240  
12241 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12242 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12241 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12242 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12243   if test "${ac_cpu_pentiumpro+set}" = set; then
12244    echo $ECHO_N "(cached) $ECHO_C" >&6
12245   else
12246    echo 'void f(){}' > conftest.c
12247 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12247 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12248          ac_cpu_pentiumpro=yes
12249   else
12250          ac_cpu_pentiumpro=no
# Line 7838 | Line 12261 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12261          :
12262  
12263  
12264 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12265 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12264 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12265 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12266   if test "${ac_pentiumpro+set}" = set; then
12267    echo $ECHO_N "(cached) $ECHO_C" >&6
12268   else
12269    echo 'void f(){}' > conftest.c
12270 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12270 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12271          ac_pentiumpro=yes
12272   else
12273          ac_pentiumpro=no
# Line 7871 | Line 12294 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12294                  if test -n "$is60x"; then
12295  
12296  
12297 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12298 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12297 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12298 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12299   if test "${ac_m_cpu_60x+set}" = set; then
12300    echo $ECHO_N "(cached) $ECHO_C" >&6
12301   else
12302    echo 'void f(){}' > conftest.c
12303 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12303 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12304          ac_m_cpu_60x=yes
12305   else
12306          ac_m_cpu_60x=no
# Line 7929 | Line 12352 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12352          :
12353  
12354  
12355 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12356 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12355 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12356 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12357   if test "${ac_m_cpu_750+set}" = set; then
12358    echo $ECHO_N "(cached) $ECHO_C" >&6
12359   else
12360    echo 'void f(){}' > conftest.c
12361 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12361 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12362          ac_m_cpu_750=yes
12363   else
12364          ac_m_cpu_750=no
# Line 7962 | Line 12385 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12385                  if test -z "$CPU_FLAGS"; then
12386  
12387  
12388 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12389 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12388 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12389 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12390   if test "${ac_m_cpu_powerpc+set}" = set; then
12391    echo $ECHO_N "(cached) $ECHO_C" >&6
12392   else
12393    echo 'void f(){}' > conftest.c
12394 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12394 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12395          ac_m_cpu_powerpc=yes
12396   else
12397          ac_m_cpu_powerpc=no
# Line 7990 | Line 12413 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12413                  if test -z "$CPU_FLAGS"; then
12414  
12415  
12416 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12417 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12416 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12417 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12418   if test "${ac_m_powerpc+set}" = set; then
12419    echo $ECHO_N "(cached) $ECHO_C" >&6
12420   else
12421    echo 'void f(){}' > conftest.c
12422 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12422 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12423          ac_m_powerpc=yes
12424   else
12425          ac_m_powerpc=no
# Line 8035 | Line 12458 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12458  
12459  
12460  
12461 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12462 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12461 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12462 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12463   if test "${ac_guessed_cflags+set}" = set; then
12464    echo $ECHO_N "(cached) $ECHO_C" >&6
12465   else
12466    echo 'void f(){}' > conftest.c
12467 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12467 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12468          ac_guessed_cflags=yes
12469   else
12470          ac_guessed_cflags=no
# Line 8125 | Line 12548 | if test "$ac_test_CXXFLAGS" != "set"; then
12548                      CXXFLAGS="-O"
12549                  fi;;
12550    sparc-solaris2*) if test "$CXX" = CC; then
12551 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12551 >                    CXXFLAGS="-features=extensions -O -dalign"
12552                   fi;;
12553     rs6000*-aix*)  if test "$CXX" = xlC; then
12554                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8146 | Line 12569 | if test "$ac_test_CXXFLAGS" != "set"; then
12569     *darwin*)
12570          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12571                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12572 +        fi
12573 +        if test "$CXX" = icpc; then
12574 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12575          fi;;
12576    esac
12577  
# Line 8159 | Line 12585 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12585      # -malign-double for x86 systems
12586  
12587  
12588 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12589 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12588 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12589 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12590   if test "${ac_align_double+set}" = set; then
12591    echo $ECHO_N "(cached) $ECHO_C" >&6
12592   else
12593    echo 'void f(){}' > conftest.cpp
12594 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12594 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12595          ac_align_double=yes
12596   else
12597          ac_align_double=no
# Line 8186 | Line 12612 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12612      # -fstrict-aliasing for gcc-2.95+
12613  
12614  
12615 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12616 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12615 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12616 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12617   if test "${ac_fstrict_aliasing+set}" = set; then
12618    echo $ECHO_N "(cached) $ECHO_C" >&6
12619   else
12620    echo 'void f(){}' > conftest.cpp
12621 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12621 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12622          ac_fstrict_aliasing=yes
12623   else
12624          ac_fstrict_aliasing=no
# Line 8217 | Line 12643 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12643                    case "${host_cpu}" in
12644            i586*)
12645  
12646 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12647 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12646 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12647 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12648   if test "${ac_cpu_pentium+set}" = set; then
12649    echo $ECHO_N "(cached) $ECHO_C" >&6
12650   else
12651    echo 'void f(){}' > conftest.cpp
12652 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12652 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12653          ac_cpu_pentium=yes
12654   else
12655          ac_cpu_pentium=no
# Line 8240 | Line 12666 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12666          :
12667  
12668  
12669 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12670 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12669 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12670 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12671   if test "${ac_pentium+set}" = set; then
12672    echo $ECHO_N "(cached) $ECHO_C" >&6
12673   else
12674    echo 'void f(){}' > conftest.cpp
12675 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12675 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12676          ac_pentium=yes
12677   else
12678          ac_pentium=no
# Line 8269 | Line 12695 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12695                    ;;
12696            i686*)
12697  
12698 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12699 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12698 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12699 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12700   if test "${ac_cpu_pentiumpro+set}" = set; then
12701    echo $ECHO_N "(cached) $ECHO_C" >&6
12702   else
12703    echo 'void f(){}' > conftest.cpp
12704 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12704 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12705          ac_cpu_pentiumpro=yes
12706   else
12707          ac_cpu_pentiumpro=no
# Line 8292 | Line 12718 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12718          :
12719  
12720  
12721 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12722 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12721 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12722 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12723   if test "${ac_pentiumpro+set}" = set; then
12724    echo $ECHO_N "(cached) $ECHO_C" >&6
12725   else
12726    echo 'void f(){}' > conftest.cpp
12727 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12727 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12728          ac_pentiumpro=yes
12729   else
12730          ac_pentiumpro=no
# Line 8325 | Line 12751 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12751                  if test -n "$is60x"; then
12752  
12753  
12754 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12755 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12754 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12755 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12756   if test "${ac_m_cpu_60x+set}" = set; then
12757    echo $ECHO_N "(cached) $ECHO_C" >&6
12758   else
12759    echo 'void f(){}' > conftest.cpp
12760 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12760 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12761          ac_m_cpu_60x=yes
12762   else
12763          ac_m_cpu_60x=no
# Line 8371 | Line 12797 | if { ac_try='${CXX-c++} -E conftest.cpp'
12797    ac_status=$?
12798    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12799    (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12800 <  ac_cv_prog_gxx_2_95=yes
12801 < else
12802 <  ac_cv_prog_gxx_2_95=no
8377 < fi
8378 <
8379 < fi
8380 < echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
8381 < echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
8382 < if test "$ac_cv_prog_gxx_2_95" = yes; then
8383 <        :
8384 <
8385 <
8386 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
8387 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
8388 < if test "${ac_m_cpu_750+set}" = set; then
8389 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8390 < else
8391 <  echo 'void f(){}' > conftest.cpp
8392 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
8393 <        ac_m_cpu_750=yes
8394 < else
8395 <        ac_m_cpu_750=no
8396 < fi
8397 < rm -f conftest*
8398 <
8399 < fi
8400 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
8401 < echo "${ECHO_T}$ac_m_cpu_750" >&6
8402 < if test "$ac_m_cpu_750" = yes; then
8403 <        :
8404 <        CPU_FLAGS=-mcpu=750
8405 < else
8406 <        :
8407 <
8408 < fi
8409 <
8410 < else
8411 <        :
8412 <
8413 < fi
8414 <
8415 <                fi
8416 <                if test -z "$CPU_FLAGS"; then
8417 <
8418 <
8419 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
8420 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
8421 < if test "${ac_m_cpu_powerpc+set}" = set; then
8422 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8423 < else
8424 <  echo 'void f(){}' > conftest.cpp
8425 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
8426 <        ac_m_cpu_powerpc=yes
8427 < else
8428 <        ac_m_cpu_powerpc=no
8429 < fi
8430 < rm -f conftest*
8431 <
8432 < fi
8433 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
8434 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
8435 < if test "$ac_m_cpu_powerpc" = yes; then
8436 <        :
8437 <        CPU_FLAGS=-mcpu=powerpc
8438 < else
8439 <        :
8440 <
8441 < fi
8442 <
8443 <                fi
8444 <                if test -z "$CPU_FLAGS"; then
8445 <
8446 <
8447 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
8448 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
8449 < if test "${ac_m_powerpc+set}" = set; then
8450 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8451 < else
8452 <  echo 'void f(){}' > conftest.cpp
8453 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
8454 <        ac_m_powerpc=yes
8455 < else
8456 <        ac_m_powerpc=no
8457 < fi
8458 < rm -f conftest*
8459 <
8460 < fi
8461 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
8462 < echo "${ECHO_T}$ac_m_powerpc" >&6
8463 < if test "$ac_m_powerpc" = yes; then
8464 <        :
8465 <        CPU_FLAGS=-mpowerpc
8466 < else
8467 <        :
8468 <
8469 < fi
8470 <
8471 <                fi
8472 <          esac
8473 <  fi
8474 <
8475 <  if test -n "$CPU_FLAGS"; then
8476 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
8477 <  fi
8478 <
8479 <  if test -z "$CXXFLAGS"; then
8480 <        echo ""
8481 <        echo "**********************************************************"
8482 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
8483 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8484 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
8485 <        echo "**********************************************************"
8486 <        echo ""
8487 <        CXXFLAGS="-O3"
8488 <  fi
8489 <
8490 <
8491 <
8492 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
8493 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
8494 < if test "${ac_guessed_cxxflags+set}" = set; then
8495 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8496 < else
8497 <  echo 'void f(){}' > conftest.cpp
8498 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
8499 <        ac_guessed_cxxflags=yes
8500 < else
8501 <        ac_guessed_cxxflags=no
8502 < fi
8503 < rm -f conftest*
8504 <
8505 < fi
8506 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
8507 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
8508 < if test "$ac_guessed_cxxflags" = yes; then
8509 <        :
8510 <
8511 < else
8512 <        :
8513 <
8514 <        echo ""
8515 <        echo "**********************************************************"
8516 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
8517 <        echo "* your compiler.                                         *"
8518 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8519 <        echo "**********************************************************"
8520 <        echo ""
8521 <        CXXFLAGS=""
8522 <
8523 < fi
8524 <
8525 <
8526 < fi
8527 <
8528 <
8529 <
8530 <
8531 <
8532 < # Try to determine "good" native compiler flags if none specified on command
8533 < # line
8534 <
8535 < if test x"$F90FLAGS" = x ; then
8536 <  F90FLAGS=""
8537 <  case "${host_cpu}-${host_os}" in
8538 <
8539 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8540 <                    F90FLAGS="-O"
8541 <                fi;;
8542 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8543 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8544 <                fi;;
8545 <   powerpc*-aix*)
8546 <        if test "$F90" = f90 -o "$F90" = xlf90; then
8547 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8548 <                echo "*******************************************************"
8549 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8550 <                echo "*  recommended that you use                           *"
8551 <                echo "*                                                     *"
8552 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8553 <                echo "*                                 ^^^                 *"
8554 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8555 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8556 <                echo "*******************************************************"
8557 <        fi;;
8558 <   *darwin*)
8559 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8560 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8561 <        fi;;
8562 <  esac
8563 <
8564 <  if test -n "$CPU_FLAGS"; then
8565 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
8566 <  fi
8567 <
8568 <  if test -z "$F90FLAGS"; then
8569 <        echo ""
8570 <        echo "**********************************************************"
8571 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8572 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8573 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8574 <        echo "**********************************************************"
8575 <        echo ""
8576 <        F90FLAGS="-O3"
8577 <  fi
8578 <
8579 <
8580 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8581 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8582 < if test "${ac_guessed_f90flags+set}" = set; then
8583 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8584 < else
8585 <
8586 <
8587 <
8588 < ac_ext=f90
8589 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8590 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8591 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8592 <
8593 < echo 'program main' > conftest.$ac_ext
8594 < echo 'end program main' >> conftest.$ac_ext
8595 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8596 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8597 <  (eval $ac_compile) 2>&5
8598 <  ac_status=$?
8599 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8600 <  (exit $ac_status); }; then
8601 <        ac_guessed_f90flags=yes
8602 < else
8603 <        ac_guessed_f90flags=no
8604 < fi
8605 < rm -f conftest*
8606 < ac_ext=c
8607 < ac_cpp='$CPP $CPPFLAGS'
8608 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8609 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8610 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8611 <
8612 <
8613 < fi
8614 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8615 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
8616 < if test "$ac_guessed_f90flags" = yes; then
8617 <        :
8618 <
8619 < else
8620 <        :
8621 <
8622 <        echo ""
8623 <        echo "**********************************************************"
8624 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8625 <        echo "* your compiler.                                         *"
8626 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8627 <        echo "**********************************************************"
8628 <        echo ""
8629 <        F90FLAGS=""
8630 <
8631 < fi
8632 <
8633 <
8634 < fi
8635 <
8636 <     ;;
8637 < esac
8638 <
8639 < # Find a good install program.  We prefer a C program (faster),
8640 < # so one script is as good as another.  But avoid the broken or
8641 < # incompatible versions:
8642 < # SysV /etc/install, /usr/sbin/install
8643 < # SunOS /usr/etc/install
8644 < # IRIX /sbin/install
8645 < # AIX /bin/install
8646 < # AmigaOS /C/install, which installs bootblocks on floppy discs
8647 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8648 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8649 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8650 < # OS/2's system install, which has a completely different semantic
8651 < # ./install, which can be erroneously created by make from ./install.sh.
8652 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8653 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8654 < if test -z "$INSTALL"; then
8655 < if test "${ac_cv_path_install+set}" = set; then
8656 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8657 < else
8658 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8659 < for as_dir in $PATH
8660 < do
8661 <  IFS=$as_save_IFS
8662 <  test -z "$as_dir" && as_dir=.
8663 <  # Account for people who put trailing slashes in PATH elements.
8664 < case $as_dir/ in
8665 <  ./ | .// | /cC/* | \
8666 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8667 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8668 <  /usr/ucb/* ) ;;
8669 <  *)
8670 <    # OSF1 and SCO ODT 3.0 have their own names for install.
8671 <    # Don't use installbsd from OSF since it installs stuff as root
8672 <    # by default.
8673 <    for ac_prog in ginstall scoinst install; do
8674 <      for ac_exec_ext in '' $ac_executable_extensions; do
8675 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8676 <          if test $ac_prog = install &&
8677 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8678 <            # AIX install.  It has an incompatible calling convention.
8679 <            :
8680 <          elif test $ac_prog = install &&
8681 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8682 <            # program-specific install script used by HP pwplus--don't use.
8683 <            :
8684 <          else
8685 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8686 <            break 3
8687 <          fi
8688 <        fi
8689 <      done
8690 <    done
8691 <    ;;
8692 < esac
8693 < done
8694 <
8695 <
8696 < fi
8697 <  if test "${ac_cv_path_install+set}" = set; then
8698 <    INSTALL=$ac_cv_path_install
8699 <  else
8700 <    # As a last resort, use the slow shell script.  We don't cache a
8701 <    # path for INSTALL within a source directory, because that will
8702 <    # break other packages using the cache if that directory is
8703 <    # removed, or if the path is relative.
8704 <    INSTALL=$ac_install_sh
8705 <  fi
8706 < fi
8707 < echo "$as_me:$LINENO: result: $INSTALL" >&5
8708 < echo "${ECHO_T}$INSTALL" >&6
8709 <
8710 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8711 < # It thinks the first close brace ends the variable substitution.
8712 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8713 <
8714 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8715 <
8716 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8717 <
8718 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
8719 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8720 < LN_S=$as_ln_s
8721 < if test "$LN_S" = "ln -s"; then
8722 <  echo "$as_me:$LINENO: result: yes" >&5
8723 < echo "${ECHO_T}yes" >&6
8724 < else
8725 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8726 < echo "${ECHO_T}no, using $LN_S" >&6
8727 < fi
8728 <
8729 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8730 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8731 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8732 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
8733 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8734 < else
8735 <  cat >conftest.make <<\_ACEOF
8736 < all:
8737 <        @echo 'ac_maketemp="$(MAKE)"'
8738 < _ACEOF
8739 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8740 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8741 < if test -n "$ac_maketemp"; then
8742 <  eval ac_cv_prog_make_${ac_make}_set=yes
8743 < else
8744 <  eval ac_cv_prog_make_${ac_make}_set=no
8745 < fi
8746 < rm -f conftest.make
8747 < fi
8748 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
8749 <  echo "$as_me:$LINENO: result: yes" >&5
8750 < echo "${ECHO_T}yes" >&6
8751 <  SET_MAKE=
8752 < else
8753 <  echo "$as_me:$LINENO: result: no" >&5
8754 < echo "${ECHO_T}no" >&6
8755 <  SET_MAKE="MAKE=${MAKE-make}"
8756 < fi
8757 <
8758 < if test -n "$ac_tool_prefix"; then
8759 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
8760 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
8761 < echo "$as_me:$LINENO: checking for $ac_word" >&5
8762 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8763 < if test "${ac_cv_prog_RANLIB+set}" = set; then
8764 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8765 < else
8766 <  if test -n "$RANLIB"; then
8767 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8768 < else
8769 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8770 < for as_dir in $PATH
8771 < do
8772 <  IFS=$as_save_IFS
8773 <  test -z "$as_dir" && as_dir=.
8774 <  for ac_exec_ext in '' $ac_executable_extensions; do
8775 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8776 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8777 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8778 <    break 2
8779 <  fi
8780 < done
8781 < done
8782 <
8783 < fi
8784 < fi
8785 < RANLIB=$ac_cv_prog_RANLIB
8786 < if test -n "$RANLIB"; then
8787 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
8788 < echo "${ECHO_T}$RANLIB" >&6
8789 < else
8790 <  echo "$as_me:$LINENO: result: no" >&5
8791 < echo "${ECHO_T}no" >&6
12800 >  ac_cv_prog_gxx_2_95=yes
12801 > else
12802 >  ac_cv_prog_gxx_2_95=no
12803   fi
12804  
12805   fi
12806 < if test -z "$ac_cv_prog_RANLIB"; then
12807 <  ac_ct_RANLIB=$RANLIB
12808 <  # Extract the first word of "ranlib", so it can be a program name with args.
12809 < set dummy ranlib; ac_word=$2
12810 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12811 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12812 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
12806 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12807 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12808 > if test "$ac_cv_prog_gxx_2_95" = yes; then
12809 >        :
12810 >
12811 >
12812 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12813 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12814 > if test "${ac_m_cpu_750+set}" = set; then
12815    echo $ECHO_N "(cached) $ECHO_C" >&6
12816   else
12817 <  if test -n "$ac_ct_RANLIB"; then
12818 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
12817 >  echo 'void f(){}' > conftest.cpp
12818 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12819 >        ac_m_cpu_750=yes
12820   else
12821 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12822 < for as_dir in $PATH
12823 < do
8810 <  IFS=$as_save_IFS
8811 <  test -z "$as_dir" && as_dir=.
8812 <  for ac_exec_ext in '' $ac_executable_extensions; do
8813 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8814 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
8815 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8816 <    break 2
8817 <  fi
8818 < done
8819 < done
12821 >        ac_m_cpu_750=no
12822 > fi
12823 > rm -f conftest*
12824  
8821  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
12825   fi
12826 < fi
12827 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
12828 < if test -n "$ac_ct_RANLIB"; then
12829 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
12830 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
12826 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12827 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12828 > if test "$ac_m_cpu_750" = yes; then
12829 >        :
12830 >        CPU_FLAGS=-mcpu=750
12831   else
12832 <  echo "$as_me:$LINENO: result: no" >&5
8830 < echo "${ECHO_T}no" >&6
8831 < fi
12832 >        :
12833  
8833  RANLIB=$ac_ct_RANLIB
8834 else
8835  RANLIB="$ac_cv_prog_RANLIB"
12834   fi
12835  
8838 for ac_prog in 'bison -y' byacc
8839 do
8840  # Extract the first word of "$ac_prog", so it can be a program name with args.
8841 set dummy $ac_prog; ac_word=$2
8842 echo "$as_me:$LINENO: checking for $ac_word" >&5
8843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8844 if test "${ac_cv_prog_YACC+set}" = set; then
8845  echo $ECHO_N "(cached) $ECHO_C" >&6
12836   else
12837 <  if test -n "$YACC"; then
8848 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
8849 < else
8850 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8851 < for as_dir in $PATH
8852 < do
8853 <  IFS=$as_save_IFS
8854 <  test -z "$as_dir" && as_dir=.
8855 <  for ac_exec_ext in '' $ac_executable_extensions; do
8856 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8857 <    ac_cv_prog_YACC="$ac_prog"
8858 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8859 <    break 2
8860 <  fi
8861 < done
8862 < done
12837 >        :
12838  
12839   fi
8865 fi
8866 YACC=$ac_cv_prog_YACC
8867 if test -n "$YACC"; then
8868  echo "$as_me:$LINENO: result: $YACC" >&5
8869 echo "${ECHO_T}$YACC" >&6
8870 else
8871  echo "$as_me:$LINENO: result: no" >&5
8872 echo "${ECHO_T}no" >&6
8873 fi
12840  
12841 <  test -n "$YACC" && break
12842 < done
8877 < test -n "$YACC" || YACC="yacc"
12841 >                fi
12842 >                if test -z "$CPU_FLAGS"; then
12843  
12844 < for ac_prog in flex lex
12845 < do
12846 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
12847 < set dummy $ac_prog; ac_word=$2
8883 < echo "$as_me:$LINENO: checking for $ac_word" >&5
8884 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8885 < if test "${ac_cv_prog_LEX+set}" = set; then
12844 >
12845 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12846 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12847 > if test "${ac_m_cpu_powerpc+set}" = set; then
12848    echo $ECHO_N "(cached) $ECHO_C" >&6
12849   else
12850 <  if test -n "$LEX"; then
12851 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12850 >  echo 'void f(){}' > conftest.cpp
12851 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12852 >        ac_m_cpu_powerpc=yes
12853   else
12854 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12855 < for as_dir in $PATH
12856 < do
8894 <  IFS=$as_save_IFS
8895 <  test -z "$as_dir" && as_dir=.
8896 <  for ac_exec_ext in '' $ac_executable_extensions; do
8897 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8898 <    ac_cv_prog_LEX="$ac_prog"
8899 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8900 <    break 2
8901 <  fi
8902 < done
8903 < done
12854 >        ac_m_cpu_powerpc=no
12855 > fi
12856 > rm -f conftest*
12857  
12858   fi
12859 < fi
12860 < LEX=$ac_cv_prog_LEX
12861 < if test -n "$LEX"; then
12862 <  echo "$as_me:$LINENO: result: $LEX" >&5
12863 < echo "${ECHO_T}$LEX" >&6
12859 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12860 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12861 > if test "$ac_m_cpu_powerpc" = yes; then
12862 >        :
12863 >        CPU_FLAGS=-mcpu=powerpc
12864   else
12865 <  echo "$as_me:$LINENO: result: no" >&5
12866 < echo "${ECHO_T}no" >&6
12865 >        :
12866 >
12867   fi
12868  
12869 <  test -n "$LEX" && break
12870 < done
8918 < test -n "$LEX" || LEX=":"
12869 >                fi
12870 >                if test -z "$CPU_FLAGS"; then
12871  
8920 if test -z "$LEXLIB"
8921 then
8922  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8923 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8924 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8925  echo $ECHO_N "(cached) $ECHO_C" >&6
8926 else
8927  ac_check_lib_save_LIBS=$LIBS
8928 LIBS="-lfl  $LIBS"
8929 cat >conftest.$ac_ext <<_ACEOF
8930 /* confdefs.h.  */
8931 _ACEOF
8932 cat confdefs.h >>conftest.$ac_ext
8933 cat >>conftest.$ac_ext <<_ACEOF
8934 /* end confdefs.h.  */
12872  
12873 < /* Override any gcc2 internal prototype to avoid an error.  */
12874 < #ifdef __cplusplus
12875 < extern "C"
8939 < #endif
8940 < /* We use char because int might match the return type of a gcc2
8941 <   builtin and then its argument prototype would still apply.  */
8942 < char yywrap ();
8943 < int
8944 < main ()
8945 < {
8946 < yywrap ();
8947 <  ;
8948 <  return 0;
8949 < }
8950 < _ACEOF
8951 < rm -f conftest.$ac_objext conftest$ac_exeext
8952 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8953 <  (eval $ac_link) 2>conftest.er1
8954 <  ac_status=$?
8955 <  grep -v '^ *+' conftest.er1 >conftest.err
8956 <  rm -f conftest.er1
8957 <  cat conftest.err >&5
8958 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8959 <  (exit $ac_status); } &&
8960 <         { ac_try='test -z "$ac_c_werror_flag"
8961 <                         || test ! -s conftest.err'
8962 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8963 <  (eval $ac_try) 2>&5
8964 <  ac_status=$?
8965 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8966 <  (exit $ac_status); }; } &&
8967 <         { ac_try='test -s conftest$ac_exeext'
8968 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8969 <  (eval $ac_try) 2>&5
8970 <  ac_status=$?
8971 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8972 <  (exit $ac_status); }; }; then
8973 <  ac_cv_lib_fl_yywrap=yes
8974 < else
8975 <  echo "$as_me: failed program was:" >&5
8976 < sed 's/^/| /' conftest.$ac_ext >&5
8977 <
8978 < ac_cv_lib_fl_yywrap=no
8979 < fi
8980 < rm -f conftest.err conftest.$ac_objext \
8981 <      conftest$ac_exeext conftest.$ac_ext
8982 < LIBS=$ac_check_lib_save_LIBS
8983 < fi
8984 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8985 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8986 < if test $ac_cv_lib_fl_yywrap = yes; then
8987 <  LEXLIB="-lfl"
8988 < else
8989 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8990 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8991 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
12873 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12874 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12875 > if test "${ac_m_powerpc+set}" = set; then
12876    echo $ECHO_N "(cached) $ECHO_C" >&6
12877   else
12878 <  ac_check_lib_save_LIBS=$LIBS
12879 < LIBS="-ll  $LIBS"
12880 < cat >conftest.$ac_ext <<_ACEOF
8997 < /* confdefs.h.  */
8998 < _ACEOF
8999 < cat confdefs.h >>conftest.$ac_ext
9000 < cat >>conftest.$ac_ext <<_ACEOF
9001 < /* end confdefs.h.  */
9002 <
9003 < /* Override any gcc2 internal prototype to avoid an error.  */
9004 < #ifdef __cplusplus
9005 < extern "C"
9006 < #endif
9007 < /* We use char because int might match the return type of a gcc2
9008 <   builtin and then its argument prototype would still apply.  */
9009 < char yywrap ();
9010 < int
9011 < main ()
9012 < {
9013 < yywrap ();
9014 <  ;
9015 <  return 0;
9016 < }
9017 < _ACEOF
9018 < rm -f conftest.$ac_objext conftest$ac_exeext
9019 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9020 <  (eval $ac_link) 2>conftest.er1
9021 <  ac_status=$?
9022 <  grep -v '^ *+' conftest.er1 >conftest.err
9023 <  rm -f conftest.er1
9024 <  cat conftest.err >&5
9025 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9026 <  (exit $ac_status); } &&
9027 <         { ac_try='test -z "$ac_c_werror_flag"
9028 <                         || test ! -s conftest.err'
9029 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9030 <  (eval $ac_try) 2>&5
9031 <  ac_status=$?
9032 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9033 <  (exit $ac_status); }; } &&
9034 <         { ac_try='test -s conftest$ac_exeext'
9035 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9036 <  (eval $ac_try) 2>&5
9037 <  ac_status=$?
9038 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9039 <  (exit $ac_status); }; }; then
9040 <  ac_cv_lib_l_yywrap=yes
12878 >  echo 'void f(){}' > conftest.cpp
12879 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12880 >        ac_m_powerpc=yes
12881   else
12882 <  echo "$as_me: failed program was:" >&5
9043 < sed 's/^/| /' conftest.$ac_ext >&5
9044 <
9045 < ac_cv_lib_l_yywrap=no
12882 >        ac_m_powerpc=no
12883   fi
12884 < rm -f conftest.err conftest.$ac_objext \
9048 <      conftest$ac_exeext conftest.$ac_ext
9049 < LIBS=$ac_check_lib_save_LIBS
9050 < fi
9051 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9052 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9053 < if test $ac_cv_lib_l_yywrap = yes; then
9054 <  LEXLIB="-ll"
9055 < fi
12884 > rm -f conftest*
12885  
12886   fi
12887 <
12888 < fi
12889 <
12890 < if test "x$LEX" != "x:"; then
12891 <  echo "$as_me:$LINENO: checking lex output file root" >&5
9063 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9064 < if test "${ac_cv_prog_lex_root+set}" = set; then
9065 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12887 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12888 > echo "${ECHO_T}$ac_m_powerpc" >&6
12889 > if test "$ac_m_powerpc" = yes; then
12890 >        :
12891 >        CPU_FLAGS=-mpowerpc
12892   else
12893 <  # The minimal lex program is just a single line: %%.  But some broken lexes
9068 < # (Solaris, I think it was) want two %% lines, so accommodate them.
9069 < cat >conftest.l <<_ACEOF
9070 < %%
9071 < %%
9072 < _ACEOF
9073 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9074 <  (eval $LEX conftest.l) 2>&5
9075 <  ac_status=$?
9076 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9077 <  (exit $ac_status); }
9078 < if test -f lex.yy.c; then
9079 <  ac_cv_prog_lex_root=lex.yy
9080 < elif test -f lexyy.c; then
9081 <  ac_cv_prog_lex_root=lexyy
9082 < else
9083 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9084 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9085 <   { (exit 1); exit 1; }; }
9086 < fi
9087 < fi
9088 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9089 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9090 < rm -f conftest.l
9091 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12893 >        :
12894  
9093 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9094 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9095 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9096  echo $ECHO_N "(cached) $ECHO_C" >&6
9097 else
9098  # POSIX says lex can declare yytext either as a pointer or an array; the
9099 # default is implementation-dependent. Figure out which it is, since
9100 # not all implementations provide the %pointer and %array declarations.
9101 ac_cv_prog_lex_yytext_pointer=no
9102 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9103 ac_save_LIBS=$LIBS
9104 LIBS="$LIBS $LEXLIB"
9105 cat >conftest.$ac_ext <<_ACEOF
9106 `cat $LEX_OUTPUT_ROOT.c`
9107 _ACEOF
9108 rm -f conftest.$ac_objext conftest$ac_exeext
9109 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9110  (eval $ac_link) 2>conftest.er1
9111  ac_status=$?
9112  grep -v '^ *+' conftest.er1 >conftest.err
9113  rm -f conftest.er1
9114  cat conftest.err >&5
9115  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9116  (exit $ac_status); } &&
9117         { ac_try='test -z "$ac_c_werror_flag"
9118                         || test ! -s conftest.err'
9119  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9120  (eval $ac_try) 2>&5
9121  ac_status=$?
9122  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9123  (exit $ac_status); }; } &&
9124         { ac_try='test -s conftest$ac_exeext'
9125  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9126  (eval $ac_try) 2>&5
9127  ac_status=$?
9128  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9129  (exit $ac_status); }; }; then
9130  ac_cv_prog_lex_yytext_pointer=yes
9131 else
9132  echo "$as_me: failed program was:" >&5
9133 sed 's/^/| /' conftest.$ac_ext >&5
9134
12895   fi
9136 rm -f conftest.err conftest.$ac_objext \
9137      conftest$ac_exeext conftest.$ac_ext
9138 LIBS=$ac_save_LIBS
9139 rm -f "${LEX_OUTPUT_ROOT}.c"
12896  
12897 < fi
12898 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
12899 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9144 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12897 >                fi
12898 >          esac
12899 >  fi
12900  
12901 < cat >>confdefs.h <<\_ACEOF
12902 < #define YYTEXT_POINTER 1
12903 < _ACEOF
12901 >  if test -n "$CPU_FLAGS"; then
12902 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12903 >  fi
12904  
12905 < fi
12905 >  if test -z "$CXXFLAGS"; then
12906 >        echo ""
12907 >        echo "**********************************************************"
12908 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12909 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12910 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12911 >        echo "**********************************************************"
12912 >        echo ""
12913 >        CXXFLAGS="-O3"
12914 >  fi
12915  
9152 fi
12916  
12917 <   # Extract the first word of "perl", so it can be a program name with args.
12918 < set dummy perl; ac_word=$2
12919 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12920 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9158 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
12917 >
12918 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12919 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12920 > if test "${ac_guessed_cxxflags+set}" = set; then
12921    echo $ECHO_N "(cached) $ECHO_C" >&6
12922   else
12923 <  case $PERLINTERP in
12924 <  [\\/]* | ?:[\\/]*)
12925 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9164 <  ;;
9165 <  *)
9166 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9167 < for as_dir in $PATH
9168 < do
9169 <  IFS=$as_save_IFS
9170 <  test -z "$as_dir" && as_dir=.
9171 <  for ac_exec_ext in '' $ac_executable_extensions; do
9172 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9173 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9174 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9175 <    break 2
9176 <  fi
9177 < done
9178 < done
9179 <
9180 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9181 <  ;;
9182 < esac
9183 < fi
9184 < PERLINTERP=$ac_cv_path_PERLINTERP
9185 <
9186 < if test -n "$PERLINTERP"; then
9187 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9188 < echo "${ECHO_T}$PERLINTERP" >&6
12923 >  echo 'void f(){}' > conftest.cpp
12924 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12925 >        ac_guessed_cxxflags=yes
12926   else
12927 <  echo "$as_me:$LINENO: result: no" >&5
9191 < echo "${ECHO_T}no" >&6
12927 >        ac_guessed_cxxflags=no
12928   fi
12929 + rm -f conftest*
12930  
9194   ac_cv_path_perlinterp="$PERLINTERP"
9195   _sHpB='#!'
9196
9197
9198 # Check whether --with-perl-shebang or --without-perl-shebang was given.
9199 if test "${with_perl_shebang+set}" = set; then
9200  withval="$with_perl_shebang"
9201  opt_perl_shebang="$withval"
9202 else
9203                opt_perl_shebang="not_set"
9204 fi;
9205   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9206 echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9207 if test "${ax_cv_opt_perl_shebang+set}" = set; then
9208  echo $ECHO_N "(cached) $ECHO_C" >&6
9209 else
9210   case "$opt_perl_shebang" in
9211                      not_set  ) ax_cv_opt_perl_shebang=''
9212                               ;;
9213                         *     )
9214        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9215                    esac
9216
12931   fi
12932 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
12933 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
12934 <   if test "A$ax_cv_opt_perl_shebang" != "A"
12935 <     then
9222 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9223 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9224 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9225 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
12932 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12933 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12934 > if test "$ac_guessed_cxxflags" = yes; then
12935 >        :
12936  
9227 # Automatic detection of sharpbang formula starts here
9228     else
9229   _somian_shbangperl=`$PERLINTERP -V:startperl`
9230   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9231   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9232 echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9233 if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9234  echo $ECHO_N "(cached) $ECHO_C" >&6
12937   else
12938 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9237 <        if test "x$_somian_kspb_perl" == x
9238 <          then _somian_ksbp_warn_empty='durnit'
9239 <          else
9240 <          case "A$_somian_kspb_perl" in
9241 <                 A#!*perl* )
9242 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9243 <                        ;;
9244 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9245 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9246 <          esac
9247 <        fi
12938 >        :
12939  
12940 < fi
12941 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
12942 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
12943 < # The above prints Checking ... result message to user.
12944 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
12940 >        echo ""
12941 >        echo "**********************************************************"
12942 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12943 >        echo "* your compiler.                                         *"
12944 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12945 >        echo "**********************************************************"
12946 >        echo ""
12947 >        CXXFLAGS=""
12948  
9255    if test A${_somian_ksbp_warn_empty+set} == Aset
9256      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9257 echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9258    fi
9259 # Inform user after printing result value
9260    if test A${_somian_ksbp_warn_defau+set} == Aset
9261      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9262 echo "$as_me: Maybe Not good -" >&6;}
9263           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9264 echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9265      else { echo "$as_me:$LINENO: OK Good result - " >&5
9266 echo "$as_me: OK Good result - " >&6;}
9267           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9268 echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9269    fi
9270  fi
9271
9272 # Extract the first word of "ar", so it can be a program name with args.
9273 set dummy ar; ac_word=$2
9274 echo "$as_me:$LINENO: checking for $ac_word" >&5
9275 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9276 if test "${ac_cv_prog_AR+set}" = set; then
9277  echo $ECHO_N "(cached) $ECHO_C" >&6
9278 else
9279  if test -n "$AR"; then
9280  ac_cv_prog_AR="$AR" # Let the user override the test.
9281 else
9282 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9283 for as_dir in $PATH
9284 do
9285  IFS=$as_save_IFS
9286  test -z "$as_dir" && as_dir=.
9287  for ac_exec_ext in '' $ac_executable_extensions; do
9288  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9289    ac_cv_prog_AR="ar"
9290    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9291    break 2
9292  fi
9293 done
9294 done
9295
9296  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12949   fi
9298 fi
9299 AR=$ac_cv_prog_AR
9300 if test -n "$AR"; then
9301  echo "$as_me:$LINENO: result: $AR" >&5
9302 echo "${ECHO_T}$AR" >&6
9303 else
9304  echo "$as_me:$LINENO: result: no" >&5
9305 echo "${ECHO_T}no" >&6
9306 fi
12950  
9308 if test "$AR" = "NONE"; then
9309  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9310 echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9311   { (exit 1); exit 1; }; }
9312  cat >confcache <<\_ACEOF
9313 # This file is a shell script that caches the results of configure
9314 # tests run on this system so they can be shared between configure
9315 # scripts and configure runs, see configure's option --config-cache.
9316 # It is not useful on other systems.  If it contains results you don't
9317 # want to keep, you may remove or edit it.
9318 #
9319 # config.status only pays attention to the cache file if you give it
9320 # the --recheck option to rerun configure.
9321 #
9322 # `ac_cv_env_foo' variables (set or unset) will be overridden when
9323 # loading this file, other *unset* `ac_cv_foo' will be assigned the
9324 # following values.
12951  
9326 _ACEOF
9327
9328 # The following way of writing the cache mishandles newlines in values,
9329 # but we know of no workaround that is simple, portable, and efficient.
9330 # So, don't put newlines in cache variables' values.
9331 # Ultrix sh set writes to stderr and can't be redirected directly,
9332 # and sets the high bit in the cache file unless we assign to the vars.
9333 {
9334  (set) 2>&1 |
9335    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9336    *ac_space=\ *)
9337      # `set' does not quote correctly, so add quotes (double-quote
9338      # substitution turns \\\\ into \\, and sed turns \\ into \).
9339      sed -n \
9340        "s/'/'\\\\''/g;
9341          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9342      ;;
9343    *)
9344      # `set' quotes correctly as required by POSIX, so do not add quotes.
9345      sed -n \
9346        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9347      ;;
9348    esac;
9349 } |
9350  sed '
9351     t clear
9352     : clear
9353     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9354     t end
9355     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9356     : end' >>confcache
9357 if diff $cache_file confcache >/dev/null 2>&1; then :; else
9358  if test -w $cache_file; then
9359    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9360    cat confcache >$cache_file
9361  else
9362    echo "not updating unwritable cache $cache_file"
9363  fi
12952   fi
9365 rm -f confcache
9366  exit 1
9367 fi
12953  
12954 < # Extract the first word of "ps", so it can be a program name with args.
9370 < set dummy ps; ac_word=$2
9371 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9372 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9373 < if test "${ac_cv_path_PS+set}" = set; then
9374 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9375 < else
9376 <  case $PS in
9377 <  [\\/]* | ?:[\\/]*)
9378 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
9379 <  ;;
9380 <  *)
9381 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9382 < for as_dir in $PATH
9383 < do
9384 <  IFS=$as_save_IFS
9385 <  test -z "$as_dir" && as_dir=.
9386 <  for ac_exec_ext in '' $ac_executable_extensions; do
9387 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9388 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9389 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9390 <    break 2
9391 <  fi
9392 < done
9393 < done
9394 <
9395 <  ;;
12954 >     ;;
12955   esac
9397 fi
9398 PS=$ac_cv_path_PS
12956  
9400 if test -n "$PS"; then
9401  echo "$as_me:$LINENO: result: $PS" >&5
9402 echo "${ECHO_T}$PS" >&6
9403 else
9404  echo "$as_me:$LINENO: result: no" >&5
9405 echo "${ECHO_T}no" >&6
9406 fi
12957  
9408 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9409 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9410 if test "${ac_cv_prog_ps_syntax+set}" = set; then
9411  echo $ECHO_N "(cached) $ECHO_C" >&6
9412 else
9413
9414        if $PS ax -o rss > /dev/null 2>&1; then
9415                ac_cv_prog_ps_ax=yes
9416        else
9417                ac_cv_prog_ps_ax=no
9418        fi
9419        if $PS -ef -o rss > /dev/null 2>&1; then
9420                ac_cv_prog_ps_ef=yes
9421        else
9422                ac_cv_prog_ps_ef=no
9423        fi
9424        if test "$ac_cv_prog_ps_ax" = yes; then
9425                ac_cv_prog_ps_syntax=BSD
9426        else
9427                if test "$ac_cv_prog_ps_ef" = yes; then
9428                        ac_cv_prog_ps_syntax=POSIX
9429                else
9430                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9431 echo "$as_me: error: Could not determine ps syntax" >&2;}
9432   { (exit 1); exit 1; }; }
9433                fi
9434        fi
9435
9436 fi
9437 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9438 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9439
9440
9441 cat >>confdefs.h <<_ACEOF
9442 #define PSCOMMAND $PS
9443 _ACEOF
9444
9445
12958   cat >>confdefs.h <<\_ACEOF
12959   #define OBAPI
12960   _ACEOF
12961  
12962  
12963  
9452 if test "$ac_cv_prog_ps_syntax" = BSD; then
12964  
9454 cat >>confdefs.h <<\_ACEOF
9455 #define PSTYPE_IS_BSD 1
9456 _ACEOF
9457
9458 else
9459   if test "$ac_cv_prog_ps_syntax" = POSIX; then
9460
9461 cat >>confdefs.h <<\_ACEOF
9462 #define PSTYPE_IS_POSIX 1
9463 _ACEOF
9464
9465   else
9466       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9467 echo "$as_me: error: Unknown ps syntax type!" >&2;}
9468   { (exit 1); exit 1; }; }
9469   fi
9470 fi
9471
9472
12965   # Check whether --with-mpi or --without-mpi was given.
12966   if test "${with_mpi+set}" = set; then
12967    withval="$with_mpi"
# Line 9495 | Line 12987 | echo "$as_me:$LINENO: checking for mpi.h" >&5
12987  
12988  
12989  
12990 + ac_ext=c
12991 + ac_cpp='$CPP $CPPFLAGS'
12992 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12993 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12994 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
12995 +
12996   echo "$as_me:$LINENO: checking for mpi.h" >&5
12997   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
12998   have_mpi_h=0
12999   rm -f conftest*
13000 < echo '#include <mpi.h>' > conftest.cc
13001 < if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13000 > echo '#include <mpi.h>' > conftest.c
13001 > if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13002          echo "$as_me:$LINENO: result: yes" >&5
13003   echo "${ECHO_T}yes" >&6
13004          have_mpi_h=1
# Line 9523 | Line 13021 | have_mpif_h=0
13021  
13022   echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13023   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13024 +
13025 +
13026 + ac_ext=${FC_SRCEXT-f}
13027 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13028 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13029 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13030 +
13031 + ac_save_ext=$ac_ext
13032 + ac_ext=F90
13033 + ac_save_FCFLAGS=$FCFLAGS
13034   have_mpif_h=0
13035   rm -f conftest*
13036 < cat >conftest.f90 <<EOF
13036 > cat >conftest.$ac_ext <<EOF
13037   program main
13038     include 'mpif.h'
13039   end
13040   EOF
13041 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13041 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13042          echo "$as_me:$LINENO: result: yes" >&5
13043   echo "${ECHO_T}yes" >&6
13044          MPI_F90_INC="$MPI_INC_DIR"
# Line 9552 | Line 13060 | fi
13060   _ACEOF
13061  
13062   fi
13063 + FCFLAGS=$ac_save_FCFLAGS
13064 + ac_ext=$ac_save_ext
13065 + ac_ext=c
13066 + ac_cpp='$CPP $CPPFLAGS'
13067 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13068 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13069 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13070  
13071 +
13072   ac_ext=c
13073   ac_cpp='$CPP $CPPFLAGS'
13074   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 9560 | Line 13076 | LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13076   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13077  
13078   ac_save_LDFLAGS=$LDFLAGS
13079 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13079 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13080  
13081   if test x = x"$MPI_LIB"; then
13082          echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
# Line 9584 | Line 13100 | int
13100   /* We use char because int might match the return type of a gcc2
13101     builtin and then its argument prototype would still apply.  */
13102   char MPI_Init ();
13103 + #ifdef FC_DUMMY_MAIN
13104 + #ifndef FC_DUMMY_MAIN_EQ_F77
13105 + #  ifdef __cplusplus
13106 +     extern "C"
13107 + #  endif
13108 +   int FC_DUMMY_MAIN() { return 1; }
13109 + #endif
13110 + #endif
13111   int
13112   main ()
13113   {
# Line 9632 | Line 13156 | if test x = x"$MPI_LIB"; then
13156   fi
13157  
13158   fi
13159 + $as_unset ac_cv_lib_mpich_MPI_Init
13160   if test x = x"$MPI_LIB"; then
13161 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13162 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13163 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13161 >        echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13162 > echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13163 > if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13164    echo $ECHO_N "(cached) $ECHO_C" >&6
13165   else
13166    ac_check_lib_save_LIBS=$LIBS
13167 < LIBS="-lmpi  $LIBS"
13167 > LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13168   cat >conftest.$ac_ext <<_ACEOF
13169   /* confdefs.h.  */
13170   _ACEOF
# Line 9654 | Line 13179 | int
13179   /* We use char because int might match the return type of a gcc2
13180     builtin and then its argument prototype would still apply.  */
13181   char MPI_Init ();
13182 + #ifdef FC_DUMMY_MAIN
13183 + #ifndef FC_DUMMY_MAIN_EQ_F77
13184 + #  ifdef __cplusplus
13185 +     extern "C"
13186 + #  endif
13187 +   int FC_DUMMY_MAIN() { return 1; }
13188 + #endif
13189 + #endif
13190   int
13191   main ()
13192   {
# Line 9684 | Line 13217 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13217    ac_status=$?
13218    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13219    (exit $ac_status); }; }; then
13220 <  ac_cv_lib_mpi_MPI_Init=yes
13220 >  ac_cv_lib_pmpich_MPI_Init=yes
13221   else
13222    echo "$as_me: failed program was:" >&5
13223   sed 's/^/| /' conftest.$ac_ext >&5
13224  
13225 < ac_cv_lib_mpi_MPI_Init=no
13225 > ac_cv_lib_pmpich_MPI_Init=no
13226   fi
13227   rm -f conftest.err conftest.$ac_objext \
13228        conftest$ac_exeext conftest.$ac_ext
13229   LIBS=$ac_check_lib_save_LIBS
13230   fi
13231 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13232 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13233 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13234 <  MPI_LIB="-lmpi"
13231 > echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13232 > echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13233 > if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13234 >  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13235   fi
13236  
13237   fi
9705 $as_unset ac_cv_lib_mpi_MPI_Init
13238   if test x = x"$MPI_LIB"; then
13239          echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13240   echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
# Line 9710 | Line 13242 | LIBS="-lmpi "-llam" $LIBS"
13242    echo $ECHO_N "(cached) $ECHO_C" >&6
13243   else
13244    ac_check_lib_save_LIBS=$LIBS
13245 < LIBS="-lmpi "-llam" $LIBS"
13245 > LIBS="-lmpi  $LIBS"
13246   cat >conftest.$ac_ext <<_ACEOF
13247   /* confdefs.h.  */
13248   _ACEOF
# Line 9725 | Line 13257 | int
13257   /* We use char because int might match the return type of a gcc2
13258     builtin and then its argument prototype would still apply.  */
13259   char MPI_Init ();
13260 + #ifdef FC_DUMMY_MAIN
13261 + #ifndef FC_DUMMY_MAIN_EQ_F77
13262 + #  ifdef __cplusplus
13263 +     extern "C"
13264 + #  endif
13265 +   int FC_DUMMY_MAIN() { return 1; }
13266 + #endif
13267 + #endif
13268   int
13269   main ()
13270   {
# Line 9769 | Line 13309 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13309   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13310   echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13311   if test $ac_cv_lib_mpi_MPI_Init = yes; then
13312 <  MPI_LIB="-lmpi -llam"
13312 >  MPI_LIB="-lmpi"
13313   fi
13314  
13315   fi
13316 < $as_unset ac_cv_lib_mpich_MPI_Init
13316 > $as_unset ac_cv_lib_mpi_MPI_Init
13317   if test x = x"$MPI_LIB"; then
13318 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13319 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13320 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13318 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13319 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13320 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13321    echo $ECHO_N "(cached) $ECHO_C" >&6
13322   else
13323    ac_check_lib_save_LIBS=$LIBS
13324 < LIBS="-lmpich "-lpmpich" $LIBS"
13324 > LIBS="-lmpi -llam $LIBS"
13325   cat >conftest.$ac_ext <<_ACEOF
13326   /* confdefs.h.  */
13327   _ACEOF
# Line 9796 | Line 13336 | int
13336   /* We use char because int might match the return type of a gcc2
13337     builtin and then its argument prototype would still apply.  */
13338   char MPI_Init ();
13339 + #ifdef FC_DUMMY_MAIN
13340 + #ifndef FC_DUMMY_MAIN_EQ_F77
13341 + #  ifdef __cplusplus
13342 +     extern "C"
13343 + #  endif
13344 +   int FC_DUMMY_MAIN() { return 1; }
13345 + #endif
13346 + #endif
13347   int
13348   main ()
13349   {
# Line 9826 | Line 13374 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13374    ac_status=$?
13375    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13376    (exit $ac_status); }; }; then
13377 <  ac_cv_lib_mpich_MPI_Init=yes
13377 >  ac_cv_lib_mpi_MPI_Init=yes
13378   else
13379    echo "$as_me: failed program was:" >&5
13380   sed 's/^/| /' conftest.$ac_ext >&5
13381  
13382 < ac_cv_lib_mpich_MPI_Init=no
13382 > ac_cv_lib_mpi_MPI_Init=no
13383   fi
13384   rm -f conftest.err conftest.$ac_objext \
13385        conftest$ac_exeext conftest.$ac_ext
13386   LIBS=$ac_check_lib_save_LIBS
13387   fi
13388 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13389 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13390 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13391 <  MPI_LIB="-lmpich -lpmpich"
13388 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13389 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13390 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13391 >  MPI_LIB="-lmpi -llam"
13392   fi
13393  
13394   fi
9847
13395   $as_unset ac_cv_lib_mpi_MPI_Init
13396   if test x = x"$MPI_LIB"; then
13397   echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
# Line 9868 | Line 13415 | int
13415   /* We use char because int might match the return type of a gcc2
13416     builtin and then its argument prototype would still apply.  */
13417   char MPI_Init ();
13418 + #ifdef FC_DUMMY_MAIN
13419 + #ifndef FC_DUMMY_MAIN_EQ_F77
13420 + #  ifdef __cplusplus
13421 +     extern "C"
13422 + #  endif
13423 +   int FC_DUMMY_MAIN() { return 1; }
13424 + #endif
13425 + #endif
13426   int
13427   main ()
13428   {
# Line 9944 | Line 13499 | fi
13499  
13500  
13501  
9947
13502   USE_CGAL=no
13503   cgal_makefile=auto
13504  
# Line 10286 | Line 13840 | int
13840   cat >>conftest.$ac_ext <<_ACEOF
13841   /* end confdefs.h.  */
13842   #include <CGAL/Cartesian.h>
13843 + #ifdef FC_DUMMY_MAIN
13844 + #ifndef FC_DUMMY_MAIN_EQ_F77
13845 + #  ifdef __cplusplus
13846 +     extern "C"
13847 + #  endif
13848 +   int FC_DUMMY_MAIN() { return 1; }
13849 + #endif
13850 + #endif
13851   int
13852   main ()
13853   {
# Line 10391 | Line 13953 | CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13953  
13954  
13955  
10394
13956   # Check whether --enable-doxygen or --disable-doxygen was given.
13957   if test "${enable_doxygen+set}" = set; then
13958    enableval="$enable_doxygen"
# Line 10533 | Line 14094 | OBJEXT=".$OBJEXT"
14094  
14095  
14096  
10536 OBJEXT=".$OBJEXT"
14097  
10538 OOPSE=oopse
14098  
10540 if test "x${prefix}" = "xNONE"
10541 then
10542  OOPSE_HOME=${ac_default_prefix}/oopse
10543 else
10544  OOPSE_HOME=${prefix}/oopse
10545 fi
10546 # Check whether --enable-oopse-home or --disable-oopse-home was given.
10547 if test "${enable_oopse_home+set}" = set; then
10548  enableval="$enable_oopse_home"
10549  OOPSE_HOME="${enableval}"
10550 fi;
10551
10552 case "x$INSTALL" in
10553   x/*) ;;
10554   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10555 esac
10556
10557 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
10558
10559 CFLAGS=${CFLAGS-""}
10560 CXXFLAGS=${CXXFLAGS-""}
10561 CPPFLAGS=${CPPFLAGS-""}
10562 FFLAGS=${FFLAGS-""}
10563 F90FLAGS=${F90FLAGS-""}
10564 LDFLAGS=${LDFLAGS-""}
10565 DEBUG=${DEBUG-"-g"}
10566
10567 case $debug in
10568  1)
10569     FFLAGS="$DEBUG $FFLAGS"
10570     F90FLAGS="$DEBUG $F90FLAGS"
10571     ;;
10572  *)
10573     ;;
10574 esac
10575
10576
10577
10578
14099  
14100  
14101  
# Line 10586 | Line 14106 | esac
14106  
14107  
14108  
14109 <
10590 <
10591 <
10592 <
10593 <          ac_config_headers="$ac_config_headers src/config.h"
10594 <
10595 <                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14109 >                                                            ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile src/applications/utilities/affineScale src/applications/utilities/waterBoxer scripts/filepp"
14110  
14111  
14112   cat >confcache <<\_ACEOF
# Line 10957 | Line 14471 | This file was extended by OOPSE $as_me 2.0, which was
14471   } >&5
14472   cat >&5 <<_CSEOF
14473  
14474 < This file was extended by OOPSE $as_me 2.0, which was
14474 > This file was extended by OOPSE $as_me 3.0, which was
14475   generated by GNU Autoconf 2.59.  Invocation command line was
14476  
14477    CONFIG_FILES    = $CONFIG_FILES
# Line 11020 | Line 14534 | OOPSE config.status 2.0
14534  
14535   cat >>$CONFIG_STATUS <<_ACEOF
14536   ac_cs_version="\\
14537 < OOPSE config.status 2.0
14537 > OOPSE config.status 3.0
14538   configured by $0, generated by GNU Autoconf 2.59,
14539    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14540  
# Line 11126 | Line 14640 | do
14640    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14641    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14642    "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14643 +  "src/applications/utilities/affineScale" ) CONFIG_FILES="$CONFIG_FILES src/applications/utilities/affineScale" ;;
14644 +  "src/applications/utilities/waterBoxer" ) CONFIG_FILES="$CONFIG_FILES src/applications/utilities/waterBoxer" ;;
14645    "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14646    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14647    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
# Line 11214 | Line 14730 | s,@PROGNAME@,$PROGNAME,;t t
14730   s,@ECHO_N@,$ECHO_N,;t t
14731   s,@ECHO_T@,$ECHO_T,;t t
14732   s,@LIBS@,$LIBS,;t t
11217 s,@PROGNAME@,$PROGNAME,;t t
11218 s,@debug@,$debug,;t t
14733   s,@build@,$build,;t t
14734   s,@build_cpu@,$build_cpu,;t t
14735   s,@build_vendor@,$build_vendor,;t t
# Line 11224 | Line 14738 | s,@CC@,$CC,;t t
14738   s,@host_cpu@,$host_cpu,;t t
14739   s,@host_vendor@,$host_vendor,;t t
14740   s,@host_os@,$host_os,;t t
14741 < s,@CC@,$CC,;t t
14742 < s,@CFLAGS@,$CFLAGS,;t t
14741 > s,@PROGNAME@,$PROGNAME,;t t
14742 > s,@debug@,$debug,;t t
14743 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
14744 > s,@CXX@,$CXX,;t t
14745 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14746   s,@LDFLAGS@,$LDFLAGS,;t t
14747   s,@CPPFLAGS@,$CPPFLAGS,;t t
14748 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14748 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14749   s,@EXEEXT@,$EXEEXT,;t t
14750   s,@OBJEXT@,$OBJEXT,;t t
14751 < s,@CXX@,$CXX,;t t
14752 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14753 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14751 > s,@CC@,$CC,;t t
14752 > s,@CFLAGS@,$CFLAGS,;t t
14753 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14754 > s,@FC@,$FC,;t t
14755 > s,@FCFLAGS@,$FCFLAGS,;t t
14756 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14757   s,@CPP@,$CPP,;t t
14758   s,@EGREP@,$EGREP,;t t
11239 s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11240 s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11241 s,@F90@,$F90,;t t
11242 s,@F90FLAGS@,$F90FLAGS,;t t
11243 s,@ac_ct_F90@,$ac_ct_F90,;t t
11244 s,@PREPFLAG@,$PREPFLAG,;t t
11245 s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11246 s,@F90LIBS@,$F90LIBS,;t t
11247 s,@F90_FUNC@,$F90_FUNC,;t t
11248 s,@F90_FUNC_@,$F90_FUNC_,;t t
11249 s,@MOD@,$MOD,;t t
11250 s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11251 s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11252 s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11253 s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
11254 s,@CXXCPP@,$CXXCPP,;t t
11255 s,@LIBOBJS@,$LIBOBJS,;t t
11256 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11257 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11258 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14759   s,@LN_S@,$LN_S,;t t
14760   s,@SET_MAKE@,$SET_MAKE,;t t
14761   s,@RANLIB@,$RANLIB,;t t
14762   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11263 s,@YACC@,$YACC,;t t
11264 s,@LEX@,$LEX,;t t
11265 s,@LEXLIB@,$LEXLIB,;t t
11266 s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14763   s,@PERLINTERP@,$PERLINTERP,;t t
14764   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14765 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14766 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14767 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14768   s,@AR@,$AR,;t t
14769   s,@PS@,$PS,;t t
14770 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14771 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14772 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14773 + s,@FCLIBS@,$FCLIBS,;t t
14774 + s,@FC_FUNC@,$FC_FUNC,;t t
14775 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14776 + s,@MOD@,$MOD,;t t
14777 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14778 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14779 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14780 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14781 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14782 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14783 + s,@ZLIB@,$ZLIB,;t t
14784 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14785 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14786 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14787 + s,@LIBOBJS@,$LIBOBJS,;t t
14788 + s,@POW_LIB@,$POW_LIB,;t t
14789 + s,@CXXCPP@,$CXXCPP,;t t
14790 + s,@__func__@,$__func__,;t t
14791   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14792   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14793   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11292 | Line 14812 | s,@FFLAGS@,$FFLAGS,;t t
14812   s,@OOPSE@,$OOPSE,;t t
14813   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14814   s,@SUBDIRS@,$SUBDIRS,;t t
11295 s,@FFLAGS@,$FFLAGS,;t t
14815   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14816   CEOF
14817  
# Line 11535 | Line 15054 | s,@INSTALL@,$ac_INSTALL,;t t
15054      make/Makefile ) chmod 0755 scripts/* ;;
15055      src/utils/Makefile ) chmod 0755 scripts/* ;;
15056      src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15057 +    src/applications/utilities/affineScale ) chmod 0755 scripts/* ;;
15058 +    src/applications/utilities/waterBoxer ) chmod 0755 scripts/* ;;
15059      scripts/filepp ) chmod 0755 scripts/* ;;
15060    esac
15061   done

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines