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

Comparing trunk/configure (file contents):
Revision 803 by gezelter, Thu Dec 8 22:04:30 2005 UTC vs.
Revision 1200 by chuckv, Fri Dec 7 00:00:05 2007 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 4.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='4.0'
273 > PACKAGE_STRING='OOPSE 4.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX CPP EGREP OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug USE_SINGLE_PRECISION CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS QHULL_INC_DIR QHULL_LIB_DIR QHULL LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_CXXFLAGS CGAL_LDFLAGS CGAL_CPPFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
764 ac_env_LDFLAGS_set=${LDFLAGS+set}
765 ac_env_LDFLAGS_value=$LDFLAGS
766 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 ac_cv_env_LDFLAGS_value=$LDFLAGS
768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 ac_env_CPPFLAGS_value=$CPPFLAGS
770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 + ac_env_LDFLAGS_set=${LDFLAGS+set}
765 + ac_env_LDFLAGS_value=$LDFLAGS
766 + ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 + ac_cv_env_LDFLAGS_value=$LDFLAGS
768 + ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 + ac_env_CPPFLAGS_value=$CPPFLAGS
770 + ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 + ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 + ac_env_CC_set=${CC+set}
773 + ac_env_CC_value=$CC
774 + ac_cv_env_CC_set=${CC+set}
775 + ac_cv_env_CC_value=$CC
776 + ac_env_CFLAGS_set=${CFLAGS+set}
777 + ac_env_CFLAGS_value=$CFLAGS
778 + ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 + ac_cv_env_CFLAGS_value=$CFLAGS
780 + ac_env_FC_set=${FC+set}
781 + ac_env_FC_value=$FC
782 + ac_cv_env_FC_set=${FC+set}
783 + ac_cv_env_FC_value=$FC
784 + ac_env_FCFLAGS_set=${FCFLAGS+set}
785 + ac_env_FCFLAGS_value=$FCFLAGS
786 + ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 + ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 ac_env_F90_set=${F90+set}
785 ac_env_F90_value=$F90
786 ac_cv_env_F90_set=${F90+set}
787 ac_cv_env_F90_value=$F90
788 ac_env_F90FLAGS_set=${F90FLAGS+set}
789 ac_env_F90FLAGS_value=$F90FLAGS
790 ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 4.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 4.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874 +  --enable-single         compile OOPSE in single precision
875 +  --enable-float          synonym for --enable-single
876    --enable-doxygen        enable documentation generation with doxygen (auto)
877    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
878    --enable-html-docs      enable HTML generation with doxygen (yes)
879    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880  
881   Optional Packages:
882    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882  --with-zlib=DIR root directory path of zlib installation defaults to
883                    /usr/local or /usr if not found in /usr/local
884  --without-zlib to disable zlib usage completely
884    --with-perl-shebang     override what perl thinks is the way for the kernel
885                            to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890 +  --with-qhull=DIR        root directory path of qhull installation (defaults
891 +                          to /usr/local or /usr if not found in /usr/local)
892    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
893 <  --with-cgal-makefile=FILE  CGAL makefile that should be used
893 >  --with-cgalmakefile=makefile
894 >                          Use the following CGAL makefile
895  
896   Some influential environment variables:
897 <  CC          C compiler command
898 <  CFLAGS      C compiler flags
897 >  CXX         C++ compiler command
898 >  CXXFLAGS    C++ compiler flags
899    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
900                nonstandard directory <lib dir>
901    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
902                headers in a nonstandard directory <include dir>
903 <  CXX         C++ compiler command
904 <  CXXFLAGS    C++ compiler flags
903 >  CC          C compiler command
904 >  CFLAGS      C compiler flags
905 >  FC          Fortran compiler command
906 >  FCFLAGS     Fortran compiler flags
907    CPP         C preprocessor
900  F90         Fortran 90 compiler command
901  F90FLAGS    Fortran 90 compiler flags
908    CXXCPP      C++ preprocessor
909  
910   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1006 | if $ac_init_version; then
1006   test -n "$ac_init_help" && exit 0
1007   if $ac_init_version; then
1008    cat <<\_ACEOF
1009 < OOPSE configure 2.0
1009 > OOPSE configure 4.0
1010   generated by GNU Autoconf 2.59
1011  
1012   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1020 | running configure, to aid debugging if configure makes
1020   This file contains any messages produced by compilers while
1021   running configure, to aid debugging if configure makes a mistake.
1022  
1023 < It was created by OOPSE $as_me 2.0, which was
1023 > It was created by OOPSE $as_me 4.0, which was
1024   generated by GNU Autoconf 2.59.  Invocation command line was
1025  
1026    $ $0 $@
# Line 1376 | Line 1382 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1382   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1383  
1384  
1385 < # 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).
1385 >          ac_config_headers="$ac_config_headers src/config.h"
1386  
1387  
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
1388  
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
1389  
1390  
1391  
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
1392  
1393  
1394  
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1395  
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1396  
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1397  
1398  
1399  
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1400  
1401  
1402  
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1403  
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1404  
1405  
1406  
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1407  
1408  
1409  
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1410  
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1411  
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1412  
1413  
1414  
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1415  
1416  
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1417  
1418  
1419  
1553 # ------------------------ #
1554 # 2c. Fortran 95 sources.  #
1555 # ------------------------ #
1420  
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1421  
1422  
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1423  
1424  
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1425  
1426  
1427  
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1428  
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1429  
1430 + #
1431 + #
1432 + #
1433  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1434  
1435  
1436  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1437  
1438  
1439  
1440 < # AC_PROG_F90([COMPILERS...])
1441 < # ---------------------------
1442 < # 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
1440 >
1441 > # AC_F90_MODULE_NAMES
1442 > # -------------------
1443   #
1444 < # pgf90 is the Portland Group F90 compilers.
1445 < # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1446 < # 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
1444 > # Figure out how the Fortran 90 compiler constructs module file names
1445 > #
1446 > # AC_F90_MODULE_NAMES
1447  
1448  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1449  
1450  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1451  
1452  
1453  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1454  
1455  
1456  
1627 # AC_PROG_F95([COMPILERS...])
1628 # ---------------------------
1629 # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 # for.
1631 #
1632 # Compilers are ordered by
1633 #  1. Good/tested native compilers, bad/untested native compilers
1634 #
1635 # xlf95 is the IBM (AIX) F95 compiler.
1636 # lf95 is the Lahey-Fujitsu compiler.
1637 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1638 # AC_PROG_F95
1457  
1458  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1459  
1460  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1461  
1462  
1651 # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1652 # -------------------------------------------------
1653 # Link a trivial Fortran program, compiling with a verbose output FLAG
1654 # (which default value, $ac_cv_prog_f90_v, is computed by
1655 # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1656 # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1657 # so that any link flags that are echoed by the compiler appear as
1658 # space-separated items.
1659 # _AC_PROG_F90_V_OUTPUT
1463  
1464  
1662 # _AC_PROG_F90_V
1663 # --------------
1664 #
1665 # Determine the flag that causes the Fortran 90 compiler to print
1666 # information of library and object files (normally -v)
1667 # Needed for AC_F90_LIBRARY_FLAGS
1668 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1669 # _AC_PROG_F90_V
1465  
1466  
1672 # AC_F90_LIBRARY_LDFLAGS
1673 # ----------------------
1674 #
1675 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 # intrinsic and run-time libraries that are required to successfully
1677 # link a Fortran 90 program or shared library.  The output variable
1678 # F90LIBS is set to these flags.
1679 #
1680 # This macro is intended to be used in those situations when it is
1681 # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 # program or shared library.
1683 #
1684 # For example, if object files from a C++ and Fortran 90 compiler must
1685 # be linked together, then the C++ compiler/linker must be used for
1686 # linking (since special C++-ish things need to happen at link time
1687 # like calling global constructors, instantiating templates, enabling
1688 # exception support, etc.).
1689 #
1690 # However, the Fortran 90 intrinsic and run-time libraries must be
1691 # linked in as well, but the C++ compiler/linker doesn't know how to
1692 # add these Fortran 90 libraries.  Hence, the macro
1693 # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 # libraries.
1695 #
1696 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 # AC_F90_LIBRARY_LDFLAGS
1467  
1468  
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
1469  
1717 # The replacement is empty.
1470  
1471  
1472  
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
1473  
1474  
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
1475  
1476  
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1477  
1478  
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
1479  
1480  
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
1481  
1482  
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
1483  
1484  
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
1485  
1809 # The replacement is empty.
1486  
1487  
1488  
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
1489  
1490  
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
1491  
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
1492  
1493  
1494  
# Line 1885 | Line 1542 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1542  
1543  
1544  
1888 #
1889 #
1890 #
1545  
1546  
1547  
# Line 1896 | Line 1550 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1550  
1551  
1552  
1899 # set program name
1900 PROGNAME="oopse"
1553  
1554  
1903 # there are two ways to do debugging.  One with the --enable-debug flag
1904 # and one using the DEBUG environment variable
1555  
1556 < debug=0
1557 < # Check whether --enable-debug or --disable-debug was given.
1558 < if test "${enable_debug+set}" = set; then
1909 <  enableval="$enable_debug"
1910 <  debug=1
1911 < fi;
1912 < if test "${DEBUG}"; then
1556 > # This is taken from http://autoqt.sourceforge.net/
1557 > # Copyright (c) 2002, Geoffrey Wossum
1558 > # All rights reserved.
1559  
1560 < cat >>confdefs.h <<\_ACEOF
1561 < #define debug 1
1562 < _ACEOF
1560 > # Redistribution and use in source and binary forms, with or without
1561 > # modification, are permitted provided that the following conditions are
1562 > # met:
1563  
1564 <  msg="$msg, debug mode"
1565 < fi
1564 > #  - Redistributions of source code must retain the above copyright notice,
1565 > #    this list of conditions and the following disclaimer.
1566  
1567 + #  - Redistributions in binary form must reproduce the above copyright
1568 + #    notice, this list of conditions and the following disclaimer in the
1569 + #    documentation and/or other materials provided with the distribution.
1570  
1571 + #  - Neither the name of Geoffrey Wossum nor the names of its
1572 + #    contributors may be used to endorse or promote products derived from
1573 + #    this software without specific prior written permission.
1574 +
1575 +
1576 + # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1577 + # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
1578 + # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1579 + # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1580 + # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1581 + # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1582 + # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1583 + # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1584 + # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1585 + # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1586 + # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1587 +
1588 +
1589 + # Check for Qt compiler flags, linker flags, and binary packages
1590 +
1591 +
1592 +
1593   # who am i
1594   # Make sure we can run config.sub.
1595   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1977 | Line 1648 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1648  
1649  
1650  
1651 < ac_ext=c
1652 < ac_cpp='$CPP $CPPFLAGS'
1653 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1654 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1655 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1651 > # set program name
1652 > PROGNAME="oopse"
1653 >
1654 >
1655 >
1656 >
1657 > OBJEXT=".$OBJEXT"
1658 >
1659 > OOPSE=oopse
1660 >
1661 > if test "x${prefix}" = "xNONE"
1662 > then
1663 >  OOPSE_HOME=${ac_default_prefix}/oopse
1664 > else
1665 >  OOPSE_HOME=${prefix}/oopse
1666 > fi
1667 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1668 > if test "${enable_oopse_home+set}" = set; then
1669 >  enableval="$enable_oopse_home"
1670 >  OOPSE_HOME="${enableval}"
1671 > fi;
1672 >
1673 > # there are two ways to do debugging.  One with the --enable-debug flag
1674 > # and one using the DEBUG environment variable
1675 >
1676 > debug=0
1677 > # Check whether --enable-debug or --disable-debug was given.
1678 > if test "${enable_debug+set}" = set; then
1679 >  enableval="$enable_debug"
1680 >  debug=1
1681 > fi;
1682 > if test "${DEBUG}"; then
1683 >
1684 > cat >>confdefs.h <<\_ACEOF
1685 > #define debug 1
1686 > _ACEOF
1687 >
1688 >  msg="$msg, debug mode"
1689 > fi
1690 >
1691 >
1692 > # Check whether --enable-single or --disable-single was given.
1693 > if test "${enable_single+set}" = set; then
1694 >  enableval="$enable_single"
1695 >  ok=$enableval
1696 > else
1697 >  ok=no
1698 > fi;
1699 > # Check whether --enable-float or --disable-float was given.
1700 > if test "${enable_float+set}" = set; then
1701 >  enableval="$enable_float"
1702 >  ok=$enableval
1703 > fi;
1704 > if test "$ok" = "yes"; then
1705 >
1706 > cat >>confdefs.h <<\_ACEOF
1707 > #define SINGLE_PRECISION 1
1708 > _ACEOF
1709 >
1710 >        USE_SINGLE_PRECISION=yes
1711 >
1712 > fi
1713 >
1714 > # Checks for programs.
1715 > ac_ext=cc
1716 > ac_cpp='$CXXCPP $CPPFLAGS'
1717 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1718 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1719 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1720   if test -n "$ac_tool_prefix"; then
1721 <  for ac_prog in pathcc icc xlc gcc cc
1721 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1722    do
1723      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1724   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1725   echo "$as_me:$LINENO: checking for $ac_word" >&5
1726   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1727 < if test "${ac_cv_prog_CC+set}" = set; then
1727 > if test "${ac_cv_prog_CXX+set}" = set; then
1728    echo $ECHO_N "(cached) $ECHO_C" >&6
1729   else
1730 <  if test -n "$CC"; then
1731 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1730 >  if test -n "$CXX"; then
1731 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1732   else
1733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1734   for as_dir in $PATH
# Line 2002 | Line 1737 | do
1737    test -z "$as_dir" && as_dir=.
1738    for ac_exec_ext in '' $ac_executable_extensions; do
1739    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1740 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1740 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1741      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1742      break 2
1743    fi
# Line 2011 | Line 1746 | fi
1746  
1747   fi
1748   fi
1749 < CC=$ac_cv_prog_CC
1750 < if test -n "$CC"; then
1751 <  echo "$as_me:$LINENO: result: $CC" >&5
1752 < echo "${ECHO_T}$CC" >&6
1749 > CXX=$ac_cv_prog_CXX
1750 > if test -n "$CXX"; then
1751 >  echo "$as_me:$LINENO: result: $CXX" >&5
1752 > echo "${ECHO_T}$CXX" >&6
1753   else
1754    echo "$as_me:$LINENO: result: no" >&5
1755   echo "${ECHO_T}no" >&6
1756   fi
1757  
1758 <    test -n "$CC" && break
1758 >    test -n "$CXX" && break
1759    done
1760   fi
1761 < if test -z "$CC"; then
1762 <  ac_ct_CC=$CC
1763 <  for ac_prog in pathcc icc xlc gcc cc
1761 > if test -z "$CXX"; then
1762 >  ac_ct_CXX=$CXX
1763 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1764   do
1765    # Extract the first word of "$ac_prog", so it can be a program name with args.
1766   set dummy $ac_prog; ac_word=$2
1767   echo "$as_me:$LINENO: checking for $ac_word" >&5
1768   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1769 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1769 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1770    echo $ECHO_N "(cached) $ECHO_C" >&6
1771   else
1772 <  if test -n "$ac_ct_CC"; then
1773 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1772 >  if test -n "$ac_ct_CXX"; then
1773 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1774   else
1775   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1776   for as_dir in $PATH
# Line 2044 | Line 1779 | do
1779    test -z "$as_dir" && as_dir=.
1780    for ac_exec_ext in '' $ac_executable_extensions; do
1781    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1782 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1782 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1783      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1784      break 2
1785    fi
# Line 2053 | Line 1788 | fi
1788  
1789   fi
1790   fi
1791 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1792 < if test -n "$ac_ct_CC"; then
1793 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1794 < echo "${ECHO_T}$ac_ct_CC" >&6
1791 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1792 > if test -n "$ac_ct_CXX"; then
1793 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1794 > echo "${ECHO_T}$ac_ct_CXX" >&6
1795   else
1796    echo "$as_me:$LINENO: result: no" >&5
1797   echo "${ECHO_T}no" >&6
1798   fi
1799  
1800 <  test -n "$ac_ct_CC" && break
1800 >  test -n "$ac_ct_CXX" && break
1801   done
1802 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1803  
1804 <  CC=$ac_ct_CC
1804 >  CXX=$ac_ct_CXX
1805   fi
1806  
1807  
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
1808   # Provide some information about the compiler.
1809   echo "$as_me:$LINENO:" \
1810 <     "checking for C compiler version" >&5
1810 >     "checking for C++ compiler version" >&5
1811   ac_compiler=`set X $ac_compile; echo $2`
1812   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1813    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2115 | Line 1845 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1845   # Try to create an executable without -o first, disregard a.out.
1846   # It will help us diagnose broken compilers, and finding out an intuition
1847   # of exeext.
1848 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1849 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1848 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1849 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1850   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1851   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1852    (eval $ac_link_default) 2>&5
# Line 2159 | Line 1889 | sed 's/^/| /' conftest.$ac_ext >&5
1889    echo "$as_me: failed program was:" >&5
1890   sed 's/^/| /' conftest.$ac_ext >&5
1891  
1892 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1892 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1893   See \`config.log' for more details." >&5
1894 < echo "$as_me: error: C compiler cannot create executables
1894 > echo "$as_me: error: C++ compiler cannot create executables
1895   See \`config.log' for more details." >&2;}
1896     { (exit 77); exit 77; }; }
1897   fi
# Line 2172 | Line 1902 | echo "${ECHO_T}$ac_file" >&6
1902  
1903   # Check the compiler produces executables we can run.  If not, either
1904   # the compiler is broken, or we cross compile.
1905 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1906 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1905 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1906 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1907   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1908   # If not cross compiling, check that we can run a simple program.
1909   if test "$cross_compiling" != yes; then
# Line 2188 | Line 1918 | if test "$cross_compiling" != yes; then
1918      if test "$cross_compiling" = maybe; then
1919          cross_compiling=yes
1920      else
1921 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1921 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1922   If you meant to cross compile, use \`--host'.
1923   See \`config.log' for more details." >&5
1924 < echo "$as_me: error: cannot run C compiled programs.
1924 > echo "$as_me: error: cannot run C++ compiled programs.
1925   If you meant to cross compile, use \`--host'.
1926   See \`config.log' for more details." >&2;}
1927     { (exit 1); exit 1; }; }
# Line 2296 | Line 2026 | ac_objext=$OBJEXT
2026   echo "${ECHO_T}$ac_cv_objext" >&6
2027   OBJEXT=$ac_cv_objext
2028   ac_objext=$OBJEXT
2029 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2030 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2031 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
2029 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2030 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2031 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2032    echo $ECHO_N "(cached) $ECHO_C" >&6
2033   else
2034    cat >conftest.$ac_ext <<_ACEOF
# Line 2328 | Line 2058 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2058    cat conftest.err >&5
2059    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2060    (exit $ac_status); } &&
2061 <         { ac_try='test -z "$ac_c_werror_flag"
2061 >         { ac_try='test -z "$ac_cxx_werror_flag"
2062                           || test ! -s conftest.err'
2063    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2064    (eval $ac_try) 2>&5
# Line 2349 | Line 2079 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2079   ac_compiler_gnu=no
2080   fi
2081   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2082 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
2082 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2083  
2084   fi
2085 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2086 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2087 < GCC=`test $ac_compiler_gnu = yes && echo yes`
2088 < ac_test_CFLAGS=${CFLAGS+set}
2089 < ac_save_CFLAGS=$CFLAGS
2090 < CFLAGS="-g"
2091 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2092 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2093 < if test "${ac_cv_prog_cc_g+set}" = set; then
2085 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2086 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2087 > GXX=`test $ac_compiler_gnu = yes && echo yes`
2088 > ac_test_CXXFLAGS=${CXXFLAGS+set}
2089 > ac_save_CXXFLAGS=$CXXFLAGS
2090 > CXXFLAGS="-g"
2091 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2092 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2093 > if test "${ac_cv_prog_cxx_g+set}" = set; then
2094    echo $ECHO_N "(cached) $ECHO_C" >&6
2095   else
2096    cat >conftest.$ac_ext <<_ACEOF
# Line 2387 | Line 2117 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2117    cat conftest.err >&5
2118    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2119    (exit $ac_status); } &&
2120 <         { ac_try='test -z "$ac_c_werror_flag"
2120 >         { ac_try='test -z "$ac_cxx_werror_flag"
2121                           || test ! -s conftest.err'
2122    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2123    (eval $ac_try) 2>&5
# Line 2400 | Line 2130 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2130    ac_status=$?
2131    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2132    (exit $ac_status); }; }; then
2133 <  ac_cv_prog_cc_g=yes
2133 >  ac_cv_prog_cxx_g=yes
2134   else
2135    echo "$as_me: failed program was:" >&5
2136   sed 's/^/| /' conftest.$ac_ext >&5
2137  
2138 < ac_cv_prog_cc_g=no
2138 > ac_cv_prog_cxx_g=no
2139   fi
2140   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2141   fi
2142 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2143 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2144 < if test "$ac_test_CFLAGS" = set; then
2145 <  CFLAGS=$ac_save_CFLAGS
2146 < elif test $ac_cv_prog_cc_g = yes; then
2147 <  if test "$GCC" = yes; then
2148 <    CFLAGS="-g -O2"
2142 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2143 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2144 > if test "$ac_test_CXXFLAGS" = set; then
2145 >  CXXFLAGS=$ac_save_CXXFLAGS
2146 > elif test $ac_cv_prog_cxx_g = yes; then
2147 >  if test "$GXX" = yes; then
2148 >    CXXFLAGS="-g -O2"
2149    else
2150 <    CFLAGS="-g"
2150 >    CXXFLAGS="-g"
2151    fi
2152   else
2153 <  if test "$GCC" = yes; then
2154 <    CFLAGS="-O2"
2153 >  if test "$GXX" = yes; then
2154 >    CXXFLAGS="-O2"
2155    else
2156 <    CFLAGS=
2156 >    CXXFLAGS=
2157    fi
2158   fi
2159 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2430 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2431 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2432 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2433 < else
2434 <  ac_cv_prog_cc_stdc=no
2435 < ac_save_CC=$CC
2436 < cat >conftest.$ac_ext <<_ACEOF
2437 < /* confdefs.h.  */
2438 < _ACEOF
2439 < cat confdefs.h >>conftest.$ac_ext
2440 < cat >>conftest.$ac_ext <<_ACEOF
2441 < /* end confdefs.h.  */
2442 < #include <stdarg.h>
2443 < #include <stdio.h>
2444 < #include <sys/types.h>
2445 < #include <sys/stat.h>
2446 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2447 < struct buf { int x; };
2448 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2449 < static char *e (p, i)
2450 <     char **p;
2451 <     int i;
2452 < {
2453 <  return p[i];
2454 < }
2455 < static char *f (char * (*g) (char **, int), char **p, ...)
2456 < {
2457 <  char *s;
2458 <  va_list v;
2459 <  va_start (v,p);
2460 <  s = g (p, va_arg (v,int));
2461 <  va_end (v);
2462 <  return s;
2463 < }
2464 <
2465 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2466 <   function prototypes and stuff, but not '\xHH' hex character constants.
2467 <   These don't provoke an error unfortunately, instead are silently treated
2468 <   as 'x'.  The following induces an error, until -std1 is added to get
2469 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2470 <   array size at least.  It's necessary to write '\x00'==0 to get something
2471 <   that's true only with -std1.  */
2472 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2473 <
2474 < int test (int i, double x);
2475 < struct s1 {int (*f) (int a);};
2476 < struct s2 {int (*f) (double a);};
2477 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2478 < int argc;
2479 < char **argv;
2480 < int
2481 < main ()
2482 < {
2483 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2484 <  ;
2485 <  return 0;
2486 < }
2487 < _ACEOF
2488 < # Don't try gcc -ansi; that turns off useful extensions and
2489 < # breaks some systems' header files.
2490 < # AIX                   -qlanglvl=ansi
2491 < # Ultrix and OSF/1      -std1
2492 < # HP-UX 10.20 and later -Ae
2493 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2494 < # SVR4                  -Xc -D__EXTENSIONS__
2495 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2496 < do
2497 <  CC="$ac_save_CC $ac_arg"
2498 <  rm -f conftest.$ac_objext
2499 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2500 <  (eval $ac_compile) 2>conftest.er1
2501 <  ac_status=$?
2502 <  grep -v '^ *+' conftest.er1 >conftest.err
2503 <  rm -f conftest.er1
2504 <  cat conftest.err >&5
2505 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2506 <  (exit $ac_status); } &&
2507 <         { ac_try='test -z "$ac_c_werror_flag"
2508 <                         || test ! -s conftest.err'
2509 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2510 <  (eval $ac_try) 2>&5
2511 <  ac_status=$?
2512 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2513 <  (exit $ac_status); }; } &&
2514 <         { ac_try='test -s conftest.$ac_objext'
2515 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2516 <  (eval $ac_try) 2>&5
2517 <  ac_status=$?
2518 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519 <  (exit $ac_status); }; }; then
2520 <  ac_cv_prog_cc_stdc=$ac_arg
2521 < break
2522 < else
2523 <  echo "$as_me: failed program was:" >&5
2524 < sed 's/^/| /' conftest.$ac_ext >&5
2525 <
2526 < fi
2527 < rm -f conftest.err conftest.$ac_objext
2528 < done
2529 < rm -f conftest.$ac_ext conftest.$ac_objext
2530 < CC=$ac_save_CC
2531 <
2532 < fi
2533 <
2534 < case "x$ac_cv_prog_cc_stdc" in
2535 <  x|xno)
2536 <    echo "$as_me:$LINENO: result: none needed" >&5
2537 < echo "${ECHO_T}none needed" >&6 ;;
2538 <  *)
2539 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2540 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2541 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2542 < esac
2543 <
2544 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2545 < # in C++ we need to declare it.  In case someone uses the same compiler
2546 < # for both compiling C and C++ we need to have the C++ compiler decide
2547 < # the declaration of exit, since it's the most demanding environment.
2548 < cat >conftest.$ac_ext <<_ACEOF
2549 < #ifndef __cplusplus
2550 <  choke me
2551 < #endif
2552 < _ACEOF
2553 < rm -f conftest.$ac_objext
2554 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2555 <  (eval $ac_compile) 2>conftest.er1
2556 <  ac_status=$?
2557 <  grep -v '^ *+' conftest.er1 >conftest.err
2558 <  rm -f conftest.er1
2559 <  cat conftest.err >&5
2560 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2561 <  (exit $ac_status); } &&
2562 <         { ac_try='test -z "$ac_c_werror_flag"
2563 <                         || test ! -s conftest.err'
2564 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2565 <  (eval $ac_try) 2>&5
2566 <  ac_status=$?
2567 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2568 <  (exit $ac_status); }; } &&
2569 <         { ac_try='test -s conftest.$ac_objext'
2570 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2571 <  (eval $ac_try) 2>&5
2572 <  ac_status=$?
2573 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2574 <  (exit $ac_status); }; }; then
2575 <  for ac_declaration in \
2159 > for ac_declaration in \
2160     '' \
2161     'extern "C" void std::exit (int) throw (); using std::exit;' \
2162     'extern "C" void std::exit (int); using std::exit;' \
# Line 2605 | Line 2189 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2189    cat conftest.err >&5
2190    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2191    (exit $ac_status); } &&
2192 <         { ac_try='test -z "$ac_c_werror_flag"
2192 >         { ac_try='test -z "$ac_cxx_werror_flag"
2193                           || test ! -s conftest.err'
2194    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2195    (eval $ac_try) 2>&5
# Line 2650 | Line 2234 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2234    cat conftest.err >&5
2235    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2236    (exit $ac_status); } &&
2237 <         { ac_try='test -z "$ac_c_werror_flag"
2237 >         { ac_try='test -z "$ac_cxx_werror_flag"
2238                           || test ! -s conftest.err'
2239    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2240    (eval $ac_try) 2>&5
# Line 2678 | Line 2262 | fi
2262    echo '#endif'             >>confdefs.h
2263   fi
2264  
2681 else
2682  echo "$as_me: failed program was:" >&5
2683 sed 's/^/| /' conftest.$ac_ext >&5
2684
2685 fi
2686 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2265   ac_ext=c
2266   ac_cpp='$CPP $CPPFLAGS'
2267   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2268   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2269   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2270  
2271 <
2272 < ac_ext=cc
2273 < ac_cpp='$CXXCPP $CPPFLAGS'
2274 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2275 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2698 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2271 > ac_ext=c
2272 > ac_cpp='$CPP $CPPFLAGS'
2273 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2274 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2275 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2276   if test -n "$ac_tool_prefix"; then
2277 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2277 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2278    do
2279      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2280   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2281   echo "$as_me:$LINENO: checking for $ac_word" >&5
2282   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2283 < if test "${ac_cv_prog_CXX+set}" = set; then
2283 > if test "${ac_cv_prog_CC+set}" = set; then
2284    echo $ECHO_N "(cached) $ECHO_C" >&6
2285   else
2286 <  if test -n "$CXX"; then
2287 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2286 >  if test -n "$CC"; then
2287 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2288   else
2289   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2290   for as_dir in $PATH
# Line 2716 | Line 2293 | do
2293    test -z "$as_dir" && as_dir=.
2294    for ac_exec_ext in '' $ac_executable_extensions; do
2295    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2296 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2296 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2297      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2298      break 2
2299    fi
# Line 2725 | Line 2302 | fi
2302  
2303   fi
2304   fi
2305 < CXX=$ac_cv_prog_CXX
2306 < if test -n "$CXX"; then
2307 <  echo "$as_me:$LINENO: result: $CXX" >&5
2308 < echo "${ECHO_T}$CXX" >&6
2305 > CC=$ac_cv_prog_CC
2306 > if test -n "$CC"; then
2307 >  echo "$as_me:$LINENO: result: $CC" >&5
2308 > echo "${ECHO_T}$CC" >&6
2309   else
2310    echo "$as_me:$LINENO: result: no" >&5
2311   echo "${ECHO_T}no" >&6
2312   fi
2313  
2314 <    test -n "$CXX" && break
2314 >    test -n "$CC" && break
2315    done
2316   fi
2317 < if test -z "$CXX"; then
2318 <  ac_ct_CXX=$CXX
2319 <  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
2317 > if test -z "$CC"; then
2318 >  ac_ct_CC=$CC
2319 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2320   do
2321    # Extract the first word of "$ac_prog", so it can be a program name with args.
2322   set dummy $ac_prog; ac_word=$2
2323   echo "$as_me:$LINENO: checking for $ac_word" >&5
2324   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2325 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2325 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2326    echo $ECHO_N "(cached) $ECHO_C" >&6
2327   else
2328 <  if test -n "$ac_ct_CXX"; then
2329 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2328 >  if test -n "$ac_ct_CC"; then
2329 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2330   else
2331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2332   for as_dir in $PATH
# Line 2758 | Line 2335 | do
2335    test -z "$as_dir" && as_dir=.
2336    for ac_exec_ext in '' $ac_executable_extensions; do
2337    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2338 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2338 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2339      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2340      break 2
2341    fi
# Line 2767 | Line 2344 | fi
2344  
2345   fi
2346   fi
2347 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2348 < if test -n "$ac_ct_CXX"; then
2349 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2350 < echo "${ECHO_T}$ac_ct_CXX" >&6
2347 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2348 > if test -n "$ac_ct_CC"; then
2349 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2350 > echo "${ECHO_T}$ac_ct_CC" >&6
2351   else
2352    echo "$as_me:$LINENO: result: no" >&5
2353   echo "${ECHO_T}no" >&6
2354   fi
2355  
2356 <  test -n "$ac_ct_CXX" && break
2356 >  test -n "$ac_ct_CC" && break
2357   done
2781 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2358  
2359 <  CXX=$ac_ct_CXX
2359 >  CC=$ac_ct_CC
2360   fi
2361  
2362  
2363 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2364 + See \`config.log' for more details." >&5
2365 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2366 + See \`config.log' for more details." >&2;}
2367 +   { (exit 1); exit 1; }; }
2368 +
2369   # Provide some information about the compiler.
2370   echo "$as_me:$LINENO:" \
2371 <     "checking for C++ compiler version" >&5
2371 >     "checking for C compiler version" >&5
2372   ac_compiler=`set X $ac_compile; echo $2`
2373   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2374    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2804 | Line 2386 | ac_compiler=`set X $ac_compile; echo $2`
2386    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2387    (exit $ac_status); }
2388  
2389 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2390 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2391 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2389 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2390 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2391 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2392    echo $ECHO_N "(cached) $ECHO_C" >&6
2393   else
2394    cat >conftest.$ac_ext <<_ACEOF
# Line 2836 | Line 2418 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2418    cat conftest.err >&5
2419    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2420    (exit $ac_status); } &&
2421 <         { ac_try='test -z "$ac_cxx_werror_flag"
2421 >         { ac_try='test -z "$ac_c_werror_flag"
2422                           || test ! -s conftest.err'
2423    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2424    (eval $ac_try) 2>&5
# Line 2857 | Line 2439 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2439   ac_compiler_gnu=no
2440   fi
2441   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2442 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2442 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2443  
2444   fi
2445 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2446 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2447 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2448 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2449 < ac_save_CXXFLAGS=$CXXFLAGS
2450 < CXXFLAGS="-g"
2451 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2452 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2453 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2445 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2446 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2447 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2448 > ac_test_CFLAGS=${CFLAGS+set}
2449 > ac_save_CFLAGS=$CFLAGS
2450 > CFLAGS="-g"
2451 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2452 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2453 > if test "${ac_cv_prog_cc_g+set}" = set; then
2454    echo $ECHO_N "(cached) $ECHO_C" >&6
2455   else
2456    cat >conftest.$ac_ext <<_ACEOF
# Line 2895 | Line 2477 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2477    cat conftest.err >&5
2478    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2479    (exit $ac_status); } &&
2480 <         { ac_try='test -z "$ac_cxx_werror_flag"
2480 >         { ac_try='test -z "$ac_c_werror_flag"
2481                           || test ! -s conftest.err'
2482    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2483    (eval $ac_try) 2>&5
# Line 2908 | Line 2490 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2490    ac_status=$?
2491    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2492    (exit $ac_status); }; }; then
2493 <  ac_cv_prog_cxx_g=yes
2493 >  ac_cv_prog_cc_g=yes
2494   else
2495    echo "$as_me: failed program was:" >&5
2496   sed 's/^/| /' conftest.$ac_ext >&5
2497  
2498 < ac_cv_prog_cxx_g=no
2498 > ac_cv_prog_cc_g=no
2499   fi
2500   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2501   fi
2502 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2503 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2504 < if test "$ac_test_CXXFLAGS" = set; then
2505 <  CXXFLAGS=$ac_save_CXXFLAGS
2506 < elif test $ac_cv_prog_cxx_g = yes; then
2507 <  if test "$GXX" = yes; then
2508 <    CXXFLAGS="-g -O2"
2502 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2503 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2504 > if test "$ac_test_CFLAGS" = set; then
2505 >  CFLAGS=$ac_save_CFLAGS
2506 > elif test $ac_cv_prog_cc_g = yes; then
2507 >  if test "$GCC" = yes; then
2508 >    CFLAGS="-g -O2"
2509    else
2510 <    CXXFLAGS="-g"
2510 >    CFLAGS="-g"
2511    fi
2512   else
2513 <  if test "$GXX" = yes; then
2514 <    CXXFLAGS="-O2"
2513 >  if test "$GCC" = yes; then
2514 >    CFLAGS="-O2"
2515    else
2516 <    CXXFLAGS=
2516 >    CFLAGS=
2517    fi
2518   fi
2519 < for ac_declaration in \
2520 <   '' \
2521 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2522 <   'extern "C" void std::exit (int); using std::exit;' \
2523 <   'extern "C" void exit (int) throw ();' \
2524 <   'extern "C" void exit (int);' \
2525 <   'void exit (int);'
2526 < do
2945 <  cat >conftest.$ac_ext <<_ACEOF
2519 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2520 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2521 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2522 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2523 > else
2524 >  ac_cv_prog_cc_stdc=no
2525 > ac_save_CC=$CC
2526 > cat >conftest.$ac_ext <<_ACEOF
2527   /* confdefs.h.  */
2528   _ACEOF
2529   cat confdefs.h >>conftest.$ac_ext
2530   cat >>conftest.$ac_ext <<_ACEOF
2531   /* end confdefs.h.  */
2532 < $ac_declaration
2533 < #include <stdlib.h>
2534 < int
2535 < main ()
2532 > #include <stdarg.h>
2533 > #include <stdio.h>
2534 > #include <sys/types.h>
2535 > #include <sys/stat.h>
2536 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2537 > struct buf { int x; };
2538 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2539 > static char *e (p, i)
2540 >     char **p;
2541 >     int i;
2542   {
2543 < exit (42);
2544 <  ;
2543 >  return p[i];
2544 > }
2545 > static char *f (char * (*g) (char **, int), char **p, ...)
2546 > {
2547 >  char *s;
2548 >  va_list v;
2549 >  va_start (v,p);
2550 >  s = g (p, va_arg (v,int));
2551 >  va_end (v);
2552 >  return s;
2553 > }
2554 >
2555 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2556 >   function prototypes and stuff, but not '\xHH' hex character constants.
2557 >   These don't provoke an error unfortunately, instead are silently treated
2558 >   as 'x'.  The following induces an error, until -std1 is added to get
2559 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2560 >   array size at least.  It's necessary to write '\x00'==0 to get something
2561 >   that's true only with -std1.  */
2562 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2563 >
2564 > int test (int i, double x);
2565 > struct s1 {int (*f) (int a);};
2566 > struct s2 {int (*f) (double a);};
2567 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2568 > int argc;
2569 > char **argv;
2570 > int
2571 > main ()
2572 > {
2573 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2574 >  ;
2575    return 0;
2576   }
2577   _ACEOF
2578 + # Don't try gcc -ansi; that turns off useful extensions and
2579 + # breaks some systems' header files.
2580 + # AIX                   -qlanglvl=ansi
2581 + # Ultrix and OSF/1      -std1
2582 + # HP-UX 10.20 and later -Ae
2583 + # HP-UX older versions  -Aa -D_HPUX_SOURCE
2584 + # SVR4                  -Xc -D__EXTENSIONS__
2585 + for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2586 + do
2587 +  CC="$ac_save_CC $ac_arg"
2588 +  rm -f conftest.$ac_objext
2589 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2590 +  (eval $ac_compile) 2>conftest.er1
2591 +  ac_status=$?
2592 +  grep -v '^ *+' conftest.er1 >conftest.err
2593 +  rm -f conftest.er1
2594 +  cat conftest.err >&5
2595 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2596 +  (exit $ac_status); } &&
2597 +         { ac_try='test -z "$ac_c_werror_flag"
2598 +                         || test ! -s conftest.err'
2599 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2600 +  (eval $ac_try) 2>&5
2601 +  ac_status=$?
2602 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2603 +  (exit $ac_status); }; } &&
2604 +         { ac_try='test -s conftest.$ac_objext'
2605 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2606 +  (eval $ac_try) 2>&5
2607 +  ac_status=$?
2608 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2609 +  (exit $ac_status); }; }; then
2610 +  ac_cv_prog_cc_stdc=$ac_arg
2611 + break
2612 + else
2613 +  echo "$as_me: failed program was:" >&5
2614 + sed 's/^/| /' conftest.$ac_ext >&5
2615 +
2616 + fi
2617 + rm -f conftest.err conftest.$ac_objext
2618 + done
2619 + rm -f conftest.$ac_ext conftest.$ac_objext
2620 + CC=$ac_save_CC
2621 +
2622 + fi
2623 +
2624 + case "x$ac_cv_prog_cc_stdc" in
2625 +  x|xno)
2626 +    echo "$as_me:$LINENO: result: none needed" >&5
2627 + echo "${ECHO_T}none needed" >&6 ;;
2628 +  *)
2629 +    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2630 + echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2631 +    CC="$CC $ac_cv_prog_cc_stdc" ;;
2632 + esac
2633 +
2634 + # Some people use a C++ compiler to compile C.  Since we use `exit',
2635 + # in C++ we need to declare it.  In case someone uses the same compiler
2636 + # for both compiling C and C++ we need to have the C++ compiler decide
2637 + # the declaration of exit, since it's the most demanding environment.
2638 + cat >conftest.$ac_ext <<_ACEOF
2639 + #ifndef __cplusplus
2640 +  choke me
2641 + #endif
2642 + _ACEOF
2643   rm -f conftest.$ac_objext
2644   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2645    (eval $ac_compile) 2>conftest.er1
# Line 2967 | Line 2649 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2649    cat conftest.err >&5
2650    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2651    (exit $ac_status); } &&
2652 <         { ac_try='test -z "$ac_cxx_werror_flag"
2652 >         { ac_try='test -z "$ac_c_werror_flag"
2653                           || test ! -s conftest.err'
2654    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2655    (eval $ac_try) 2>&5
# Line 2980 | Line 2662 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2662    ac_status=$?
2663    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2664    (exit $ac_status); }; }; then
2665 +  for ac_declaration in \
2666 +   '' \
2667 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2668 +   'extern "C" void std::exit (int); using std::exit;' \
2669 +   'extern "C" void exit (int) throw ();' \
2670 +   'extern "C" void exit (int);' \
2671 +   'void exit (int);'
2672 + do
2673 +  cat >conftest.$ac_ext <<_ACEOF
2674 + /* confdefs.h.  */
2675 + _ACEOF
2676 + cat confdefs.h >>conftest.$ac_ext
2677 + cat >>conftest.$ac_ext <<_ACEOF
2678 + /* end confdefs.h.  */
2679 + $ac_declaration
2680 + #include <stdlib.h>
2681 + int
2682 + main ()
2683 + {
2684 + exit (42);
2685 +  ;
2686 +  return 0;
2687 + }
2688 + _ACEOF
2689 + rm -f conftest.$ac_objext
2690 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2691 +  (eval $ac_compile) 2>conftest.er1
2692 +  ac_status=$?
2693 +  grep -v '^ *+' conftest.er1 >conftest.err
2694 +  rm -f conftest.er1
2695 +  cat conftest.err >&5
2696 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2697 +  (exit $ac_status); } &&
2698 +         { ac_try='test -z "$ac_c_werror_flag"
2699 +                         || test ! -s conftest.err'
2700 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2701 +  (eval $ac_try) 2>&5
2702 +  ac_status=$?
2703 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2704 +  (exit $ac_status); }; } &&
2705 +         { ac_try='test -s conftest.$ac_objext'
2706 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2707 +  (eval $ac_try) 2>&5
2708 +  ac_status=$?
2709 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2710 +  (exit $ac_status); }; }; then
2711    :
2712   else
2713    echo "$as_me: failed program was:" >&5
# Line 3012 | Line 2740 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2740    cat conftest.err >&5
2741    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2742    (exit $ac_status); } &&
2743 <         { ac_try='test -z "$ac_cxx_werror_flag"
2743 >         { ac_try='test -z "$ac_c_werror_flag"
2744                           || test ! -s conftest.err'
2745    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2746    (eval $ac_try) 2>&5
# Line 3040 | Line 2768 | fi
2768    echo '#endif'             >>confdefs.h
2769   fi
2770  
2771 + else
2772 +  echo "$as_me: failed program was:" >&5
2773 + sed 's/^/| /' conftest.$ac_ext >&5
2774 +
2775 + fi
2776 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2777   ac_ext=c
2778   ac_cpp='$CPP $CPPFLAGS'
2779   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2780   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2781   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2782 +
2783 + ac_ext=${FC_SRCEXT-f}
2784 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2785 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2786 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2787 + if test -n "$ac_tool_prefix"; then
2788 +  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2789 +  do
2790 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2791 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2792 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2793 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2794 + if test "${ac_cv_prog_FC+set}" = set; then
2795 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2796 + else
2797 +  if test -n "$FC"; then
2798 +  ac_cv_prog_FC="$FC" # Let the user override the test.
2799 + else
2800 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2801 + for as_dir in $PATH
2802 + do
2803 +  IFS=$as_save_IFS
2804 +  test -z "$as_dir" && as_dir=.
2805 +  for ac_exec_ext in '' $ac_executable_extensions; do
2806 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2807 +    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2808 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2809 +    break 2
2810 +  fi
2811 + done
2812 + done
2813 +
2814 + fi
2815 + fi
2816 + FC=$ac_cv_prog_FC
2817 + if test -n "$FC"; then
2818 +  echo "$as_me:$LINENO: result: $FC" >&5
2819 + echo "${ECHO_T}$FC" >&6
2820 + else
2821 +  echo "$as_me:$LINENO: result: no" >&5
2822 + echo "${ECHO_T}no" >&6
2823 + fi
2824 +
2825 +    test -n "$FC" && break
2826 +  done
2827 + fi
2828 + if test -z "$FC"; then
2829 +  ac_ct_FC=$FC
2830 +  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2831 + do
2832 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2833 + set dummy $ac_prog; ac_word=$2
2834 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2835 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2836 + if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2837 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2838 + else
2839 +  if test -n "$ac_ct_FC"; then
2840 +  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2841 + else
2842 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2843 + for as_dir in $PATH
2844 + do
2845 +  IFS=$as_save_IFS
2846 +  test -z "$as_dir" && as_dir=.
2847 +  for ac_exec_ext in '' $ac_executable_extensions; do
2848 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2849 +    ac_cv_prog_ac_ct_FC="$ac_prog"
2850 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2851 +    break 2
2852 +  fi
2853 + done
2854 + done
2855 +
2856 + fi
2857 + fi
2858 + ac_ct_FC=$ac_cv_prog_ac_ct_FC
2859 + if test -n "$ac_ct_FC"; then
2860 +  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2861 + echo "${ECHO_T}$ac_ct_FC" >&6
2862 + else
2863 +  echo "$as_me:$LINENO: result: no" >&5
2864 + echo "${ECHO_T}no" >&6
2865 + fi
2866 +
2867 +  test -n "$ac_ct_FC" && break
2868 + done
2869 +
2870 +  FC=$ac_ct_FC
2871 + fi
2872 +
2873 +
2874 + # Provide some information about the compiler.
2875 + echo "$as_me:2875:" \
2876 +     "checking for Fortran compiler version" >&5
2877 + ac_compiler=`set X $ac_compile; echo $2`
2878 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2879 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2880 +  ac_status=$?
2881 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2882 +  (exit $ac_status); }
2883 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2884 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2885 +  ac_status=$?
2886 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2887 +  (exit $ac_status); }
2888 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2889 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2890 +  ac_status=$?
2891 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2892 +  (exit $ac_status); }
2893 + rm -f a.out
2894 +
2895 + # If we don't use `.F' as extension, the preprocessor is not run on the
2896 + # input file.  (Note that this only needs to work for GNU compilers.)
2897 + ac_save_ext=$ac_ext
2898 + ac_ext=F
2899 + echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2900 + echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2901 + if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2902 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2903 + else
2904 +  cat >conftest.$ac_ext <<_ACEOF
2905 +      program main
2906 + #ifndef __GNUC__
2907 +       choke me
2908 + #endif
2909 +
2910 +      end
2911 + _ACEOF
2912 + rm -f conftest.$ac_objext
2913 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2914 +  (eval $ac_compile) 2>conftest.er1
2915 +  ac_status=$?
2916 +  grep -v '^ *+' conftest.er1 >conftest.err
2917 +  rm -f conftest.er1
2918 +  cat conftest.err >&5
2919 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920 +  (exit $ac_status); } &&
2921 +         { ac_try='test -z "$ac_fc_werror_flag"
2922 +                         || test ! -s conftest.err'
2923 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2924 +  (eval $ac_try) 2>&5
2925 +  ac_status=$?
2926 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2927 +  (exit $ac_status); }; } &&
2928 +         { ac_try='test -s conftest.$ac_objext'
2929 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2930 +  (eval $ac_try) 2>&5
2931 +  ac_status=$?
2932 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2933 +  (exit $ac_status); }; }; then
2934 +  ac_compiler_gnu=yes
2935 + else
2936 +  echo "$as_me: failed program was:" >&5
2937 + sed 's/^/| /' conftest.$ac_ext >&5
2938 +
2939 + ac_compiler_gnu=no
2940 + fi
2941 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2942 + ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2943 +
2944 + fi
2945 + echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2946 + echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2947 + ac_ext=$ac_save_ext
2948 + ac_test_FFLAGS=${FCFLAGS+set}
2949 + ac_save_FFLAGS=$FCFLAGS
2950 + FCFLAGS=
2951 + echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2952 + echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2953 + if test "${ac_cv_prog_fc_g+set}" = set; then
2954 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2955 + else
2956 +  FCFLAGS=-g
2957 + cat >conftest.$ac_ext <<_ACEOF
2958 +      program main
2959 +
2960 +      end
2961 + _ACEOF
2962 + rm -f conftest.$ac_objext
2963 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2964 +  (eval $ac_compile) 2>conftest.er1
2965 +  ac_status=$?
2966 +  grep -v '^ *+' conftest.er1 >conftest.err
2967 +  rm -f conftest.er1
2968 +  cat conftest.err >&5
2969 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2970 +  (exit $ac_status); } &&
2971 +         { ac_try='test -z "$ac_fc_werror_flag"
2972 +                         || test ! -s conftest.err'
2973 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2974 +  (eval $ac_try) 2>&5
2975 +  ac_status=$?
2976 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2977 +  (exit $ac_status); }; } &&
2978 +         { ac_try='test -s conftest.$ac_objext'
2979 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2980 +  (eval $ac_try) 2>&5
2981 +  ac_status=$?
2982 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2983 +  (exit $ac_status); }; }; then
2984 +  ac_cv_prog_fc_g=yes
2985 + else
2986 +  echo "$as_me: failed program was:" >&5
2987 + sed 's/^/| /' conftest.$ac_ext >&5
2988 +
2989 + ac_cv_prog_fc_g=no
2990 + fi
2991 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2992  
2993 + fi
2994 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2995 + echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2996 + if test "$ac_test_FFLAGS" = set; then
2997 +  FCFLAGS=$ac_save_FFLAGS
2998 + elif test $ac_cv_prog_fc_g = yes; then
2999 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3000 +    FCFLAGS="-g -O2"
3001 +  else
3002 +    FCFLAGS="-g"
3003 +  fi
3004 + else
3005 +  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3006 +    FCFLAGS="-O2"
3007 +  else
3008 +    FCFLAGS=
3009 +  fi
3010 + fi
3011  
3012   ac_ext=c
3013   ac_cpp='$CPP $CPPFLAGS'
3014   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3015   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3016   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3017 +
3018 + ac_ext=c
3019 + ac_cpp='$CPP $CPPFLAGS'
3020 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3021 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3022 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
3023   echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
3024   echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
3025   # On Suns, sometimes $CPP names a directory.
# Line 3281 | Line 3249 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3249   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3250   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3251  
3284
3252   echo "$as_me:$LINENO: checking for egrep" >&5
3253   echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3254   if test "${ac_cv_prog_egrep+set}" = set; then
# Line 3297 | Line 3264 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3264   EGREP=$ac_cv_prog_egrep
3265  
3266  
3267 + echo "$as_me:$LINENO: checking whether ln -s works" >&5
3268 + echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3269 + LN_S=$as_ln_s
3270 + if test "$LN_S" = "ln -s"; then
3271 +  echo "$as_me:$LINENO: result: yes" >&5
3272 + echo "${ECHO_T}yes" >&6
3273 + else
3274 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3275 + echo "${ECHO_T}no, using $LN_S" >&6
3276 + fi
3277  
3278 < OOPSE_TEMPLATE_FLAGS=""
3279 < if test $ac_cv_cxx_compiler_gnu = no; then
3280 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3281 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3282 <  echo 'void f(){}' > conftest.cc
3283 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3284 <    echo "$as_me:$LINENO: result: yes" >&5
3278 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3279 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3280 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3281 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3282 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3283 > else
3284 >  cat >conftest.make <<\_ACEOF
3285 > all:
3286 >        @echo 'ac_maketemp="$(MAKE)"'
3287 > _ACEOF
3288 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3289 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3290 > if test -n "$ac_maketemp"; then
3291 >  eval ac_cv_prog_make_${ac_make}_set=yes
3292 > else
3293 >  eval ac_cv_prog_make_${ac_make}_set=no
3294 > fi
3295 > rm -f conftest.make
3296 > fi
3297 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3298 >  echo "$as_me:$LINENO: result: yes" >&5
3299   echo "${ECHO_T}yes" >&6
3300 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3301 <  else
3302 <    echo "$as_me:$LINENO: result: no" >&5
3300 >  SET_MAKE=
3301 > else
3302 >  echo "$as_me:$LINENO: result: no" >&5
3303   echo "${ECHO_T}no" >&6
3304 +  SET_MAKE="MAKE=${MAKE-make}"
3305 + fi
3306 +
3307 + if test -n "$ac_tool_prefix"; then
3308 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3309 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3310 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3311 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3312 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3313 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3314 + else
3315 +  if test -n "$RANLIB"; then
3316 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3317 + else
3318 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3319 + for as_dir in $PATH
3320 + do
3321 +  IFS=$as_save_IFS
3322 +  test -z "$as_dir" && as_dir=.
3323 +  for ac_exec_ext in '' $ac_executable_extensions; do
3324 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3325 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3326 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3327 +    break 2
3328    fi
3329 <  rm -f conftest*
3330 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3331 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3332 <  echo 'void f(){}' > conftest.cc
3333 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3334 <    echo "$as_me:$LINENO: result: yes" >&5
3335 < echo "${ECHO_T}yes" >&6
3336 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3337 <  else
3338 <    echo "$as_me:$LINENO: result: no" >&5
3329 > done
3330 > done
3331 >
3332 > fi
3333 > fi
3334 > RANLIB=$ac_cv_prog_RANLIB
3335 > if test -n "$RANLIB"; then
3336 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3337 > echo "${ECHO_T}$RANLIB" >&6
3338 > else
3339 >  echo "$as_me:$LINENO: result: no" >&5
3340   echo "${ECHO_T}no" >&6
3341 + fi
3342 +
3343 + fi
3344 + if test -z "$ac_cv_prog_RANLIB"; then
3345 +  ac_ct_RANLIB=$RANLIB
3346 +  # Extract the first word of "ranlib", so it can be a program name with args.
3347 + set dummy ranlib; ac_word=$2
3348 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3349 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3350 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3351 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3352 + else
3353 +  if test -n "$ac_ct_RANLIB"; then
3354 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3355 + else
3356 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3357 + for as_dir in $PATH
3358 + do
3359 +  IFS=$as_save_IFS
3360 +  test -z "$as_dir" && as_dir=.
3361 +  for ac_exec_ext in '' $ac_executable_extensions; do
3362 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3363 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3364 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3365 +    break 2
3366    fi
3367 <  rm -f conftest*
3368 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3369 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3370 <  echo 'void f(){}' > conftest.cc
3371 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3372 <    echo "$as_me:$LINENO: result: yes" >&5
3373 < echo "${ECHO_T}yes" >&6
3374 <    OOPSE_TEMPLATE_FLAGS="-pto"
3375 <  else
3376 <    echo "$as_me:$LINENO: result: no" >&5
3367 > done
3368 > done
3369 >
3370 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3371 > fi
3372 > fi
3373 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3374 > if test -n "$ac_ct_RANLIB"; then
3375 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3376 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3377 > else
3378 >  echo "$as_me:$LINENO: result: no" >&5
3379   echo "${ECHO_T}no" >&6
3380 + fi
3381 +
3382 +  RANLIB=$ac_ct_RANLIB
3383 + else
3384 +  RANLIB="$ac_cv_prog_RANLIB"
3385 + fi
3386 +
3387 +
3388 +   # Extract the first word of "perl", so it can be a program name with args.
3389 + set dummy perl; ac_word=$2
3390 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3391 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3392 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3393 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3394 + else
3395 +  case $PERLINTERP in
3396 +  [\\/]* | ?:[\\/]*)
3397 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3398 +  ;;
3399 +  *)
3400 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3401 + for as_dir in $PATH
3402 + do
3403 +  IFS=$as_save_IFS
3404 +  test -z "$as_dir" && as_dir=.
3405 +  for ac_exec_ext in '' $ac_executable_extensions; do
3406 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3407 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3408 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3409 +    break 2
3410    fi
3411 <  rm -f conftest*
3412 <  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
3411 > done
3412 > done
3413  
3414 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3415 +  ;;
3416 + esac
3417 + fi
3418 + PERLINTERP=$ac_cv_path_PERLINTERP
3419  
3420 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3421 <  else
3422 <    echo "$as_me:$LINENO: result: no" >&5
3420 > if test -n "$PERLINTERP"; then
3421 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3422 > echo "${ECHO_T}$PERLINTERP" >&6
3423 > else
3424 >  echo "$as_me:$LINENO: result: no" >&5
3425   echo "${ECHO_T}no" >&6
3426 + fi
3427 +
3428 +   ac_cv_path_perlinterp="$PERLINTERP"
3429 +   _sHpB='#!'
3430 +
3431 +
3432 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3433 + if test "${with_perl_shebang+set}" = set; then
3434 +  withval="$with_perl_shebang"
3435 +  opt_perl_shebang="$withval"
3436 + else
3437 +                opt_perl_shebang="not_set"
3438 + fi;
3439 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3440 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3441 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3442 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3443 + else
3444 +   case "$opt_perl_shebang" in
3445 +                      not_set  ) ax_cv_opt_perl_shebang=''
3446 +                               ;;
3447 +                         *     )
3448 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3449 +                    esac
3450 +
3451 + fi
3452 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3453 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3454 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3455 +     then
3456 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3457 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3458 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3459 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3460 +
3461 + # Automatic detection of sharpbang formula starts here
3462 +     else
3463 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3464 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3465 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3466 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3467 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3468 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3469 + else
3470 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3471 +        if test "x$_somian_kspb_perl" == x
3472 +          then _somian_ksbp_warn_empty='durnit'
3473 +          else
3474 +          case "A$_somian_kspb_perl" in
3475 +                 A#!*perl* )
3476 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3477 +                        ;;
3478 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3479 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3480 +          esac
3481 +        fi
3482 +
3483 + fi
3484 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3485 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3486 + # The above prints Checking ... result message to user.
3487 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3488 +
3489 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3490 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3491 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3492 +    fi
3493 + # Inform user after printing result value
3494 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3495 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3496 + echo "$as_me: Maybe Not good -" >&6;}
3497 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3498 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3499 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3500 + echo "$as_me: OK Good result - " >&6;}
3501 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3502 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3503 +    fi
3504    fi
3505 +
3506 + # Find a good install program.  We prefer a C program (faster),
3507 + # so one script is as good as another.  But avoid the broken or
3508 + # incompatible versions:
3509 + # SysV /etc/install, /usr/sbin/install
3510 + # SunOS /usr/etc/install
3511 + # IRIX /sbin/install
3512 + # AIX /bin/install
3513 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3514 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3515 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3516 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3517 + # OS/2's system install, which has a completely different semantic
3518 + # ./install, which can be erroneously created by make from ./install.sh.
3519 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3520 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3521 + if test -z "$INSTALL"; then
3522 + if test "${ac_cv_path_install+set}" = set; then
3523 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3524 + else
3525 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3526 + for as_dir in $PATH
3527 + do
3528 +  IFS=$as_save_IFS
3529 +  test -z "$as_dir" && as_dir=.
3530 +  # Account for people who put trailing slashes in PATH elements.
3531 + case $as_dir/ in
3532 +  ./ | .// | /cC/* | \
3533 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3534 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3535 +  /usr/ucb/* ) ;;
3536 +  *)
3537 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3538 +    # Don't use installbsd from OSF since it installs stuff as root
3539 +    # by default.
3540 +    for ac_prog in ginstall scoinst install; do
3541 +      for ac_exec_ext in '' $ac_executable_extensions; do
3542 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3543 +          if test $ac_prog = install &&
3544 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3545 +            # AIX install.  It has an incompatible calling convention.
3546 +            :
3547 +          elif test $ac_prog = install &&
3548 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3549 +            # program-specific install script used by HP pwplus--don't use.
3550 +            :
3551 +          else
3552 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3553 +            break 3
3554 +          fi
3555 +        fi
3556 +      done
3557 +    done
3558 +    ;;
3559 + esac
3560 + done
3561 +
3562 +
3563   fi
3564 +  if test "${ac_cv_path_install+set}" = set; then
3565 +    INSTALL=$ac_cv_path_install
3566 +  else
3567 +    # As a last resort, use the slow shell script.  We don't cache a
3568 +    # path for INSTALL within a source directory, because that will
3569 +    # break other packages using the cache if that directory is
3570 +    # removed, or if the path is relative.
3571 +    INSTALL=$ac_install_sh
3572 +  fi
3573 + fi
3574 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3575 + echo "${ECHO_T}$INSTALL" >&6
3576  
3577 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3578 + # It thinks the first close brace ends the variable substitution.
3579 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3580  
3581 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3582  
3583 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3584  
3585 < ac_ext=f90
3586 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3587 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3588 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3589 < if test -n "$ac_tool_prefix"; then
3590 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3591 <  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
3585 > case "x$INSTALL" in
3586 >   x/*) ;;
3587 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3588 > esac
3589 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3590 > # Extract the first word of "ar", so it can be a program name with args.
3591 > set dummy ar; ac_word=$2
3592   echo "$as_me:$LINENO: checking for $ac_word" >&5
3593   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3594 < if test "${ac_cv_prog_F90+set}" = set; then
3594 > if test "${ac_cv_prog_AR+set}" = set; then
3595    echo $ECHO_N "(cached) $ECHO_C" >&6
3596   else
3597 <  if test -n "$F90"; then
3598 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3597 >  if test -n "$AR"; then
3598 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3599   else
3600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3601   for as_dir in $PATH
# Line 3378 | Line 3604 | do
3604    test -z "$as_dir" && as_dir=.
3605    for ac_exec_ext in '' $ac_executable_extensions; do
3606    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3607 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3607 >    ac_cv_prog_AR="ar"
3608      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3609      break 2
3610    fi
3611   done
3612   done
3613  
3614 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3615   fi
3616   fi
3617 < F90=$ac_cv_prog_F90
3618 < if test -n "$F90"; then
3619 <  echo "$as_me:$LINENO: result: $F90" >&5
3620 < echo "${ECHO_T}$F90" >&6
3617 > AR=$ac_cv_prog_AR
3618 > if test -n "$AR"; then
3619 >  echo "$as_me:$LINENO: result: $AR" >&5
3620 > echo "${ECHO_T}$AR" >&6
3621   else
3622    echo "$as_me:$LINENO: result: no" >&5
3623   echo "${ECHO_T}no" >&6
3624   fi
3625  
3626 <    test -n "$F90" && break
3627 <  done
3626 > if test "$AR" = "NONE"; then
3627 >  cat >confcache <<\_ACEOF
3628 > # This file is a shell script that caches the results of configure
3629 > # tests run on this system so they can be shared between configure
3630 > # scripts and configure runs, see configure's option --config-cache.
3631 > # It is not useful on other systems.  If it contains results you don't
3632 > # want to keep, you may remove or edit it.
3633 > #
3634 > # config.status only pays attention to the cache file if you give it
3635 > # the --recheck option to rerun configure.
3636 > #
3637 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3638 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3639 > # following values.
3640 >
3641 > _ACEOF
3642 >
3643 > # The following way of writing the cache mishandles newlines in values,
3644 > # but we know of no workaround that is simple, portable, and efficient.
3645 > # So, don't put newlines in cache variables' values.
3646 > # Ultrix sh set writes to stderr and can't be redirected directly,
3647 > # and sets the high bit in the cache file unless we assign to the vars.
3648 > {
3649 >  (set) 2>&1 |
3650 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3651 >    *ac_space=\ *)
3652 >      # `set' does not quote correctly, so add quotes (double-quote
3653 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3654 >      sed -n \
3655 >        "s/'/'\\\\''/g;
3656 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3657 >      ;;
3658 >    *)
3659 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3660 >      sed -n \
3661 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3662 >      ;;
3663 >    esac;
3664 > } |
3665 >  sed '
3666 >     t clear
3667 >     : clear
3668 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3669 >     t end
3670 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3671 >     : end' >>confcache
3672 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3673 >  if test -w $cache_file; then
3674 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3675 >    cat confcache >$cache_file
3676 >  else
3677 >    echo "not updating unwritable cache $cache_file"
3678 >  fi
3679   fi
3680 < if test -z "$F90"; then
3681 <  ac_ct_F90=$F90
3682 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3683 < do
3684 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3407 < set dummy $ac_prog; ac_word=$2
3680 > rm -f confcache
3681 >  exit 1
3682 > fi
3683 > # Extract the first word of "ps", so it can be a program name with args.
3684 > set dummy ps; ac_word=$2
3685   echo "$as_me:$LINENO: checking for $ac_word" >&5
3686   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3687 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3687 > if test "${ac_cv_path_PS+set}" = set; then
3688    echo $ECHO_N "(cached) $ECHO_C" >&6
3689   else
3690 <  if test -n "$ac_ct_F90"; then
3691 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3692 < else
3693 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3690 >  case $PS in
3691 >  [\\/]* | ?:[\\/]*)
3692 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3693 >  ;;
3694 >  *)
3695 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3696   for as_dir in $PATH
3697   do
3698    IFS=$as_save_IFS
3699    test -z "$as_dir" && as_dir=.
3700    for ac_exec_ext in '' $ac_executable_extensions; do
3701    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3702 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3702 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3703      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3704      break 2
3705    fi
3706   done
3707   done
3708  
3709 +  ;;
3710 + esac
3711   fi
3712 < fi
3713 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3714 < if test -n "$ac_ct_F90"; then
3715 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3716 < echo "${ECHO_T}$ac_ct_F90" >&6
3712 > PS=$ac_cv_path_PS
3713 >
3714 > if test -n "$PS"; then
3715 >  echo "$as_me:$LINENO: result: $PS" >&5
3716 > echo "${ECHO_T}$PS" >&6
3717   else
3718    echo "$as_me:$LINENO: result: no" >&5
3719   echo "${ECHO_T}no" >&6
3720   fi
3721  
3722 <  test -n "$ac_ct_F90" && break
3723 < done
3722 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3723 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3724 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3725 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3726 > else
3727  
3728 <  F90=$ac_ct_F90
3728 >        if $PS ax -o rss > /dev/null 2>&1; then
3729 >                ac_cv_prog_ps_ax=yes
3730 >        else
3731 >                ac_cv_prog_ps_ax=no
3732 >        fi
3733 >        if $PS -ef -o rss > /dev/null 2>&1; then
3734 >                ac_cv_prog_ps_ef=yes
3735 >        else
3736 >                ac_cv_prog_ps_ef=no
3737 >        fi
3738 >        if test "$ac_cv_prog_ps_ax" = yes; then
3739 >                ac_cv_prog_ps_syntax=BSD
3740 >        else
3741 >                if test "$ac_cv_prog_ps_ef" = yes; then
3742 >                        ac_cv_prog_ps_syntax=POSIX
3743 >                else
3744 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3745 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3746 >   { (exit 1); exit 1; }; }
3747 >                fi
3748 >        fi
3749 >
3750   fi
3751 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3752 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3753  
3754 + cat >>confdefs.h <<_ACEOF
3755 + #define PSCOMMAND $PS
3756 + _ACEOF
3757  
3758 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3759 < # input file.
3760 < ac_save_ext=$ac_ext
3761 < ac_ext=F90
3762 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3763 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3764 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3765 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3766 < else
3767 <  cat >conftest.$ac_ext <<_ACEOF
3758 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3759 >
3760 > cat >>confdefs.h <<\_ACEOF
3761 > #define PSTYPE_IS_BSD 1
3762 > _ACEOF
3763 >
3764 > else
3765 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3766 >
3767 > cat >>confdefs.h <<\_ACEOF
3768 > #define PSTYPE_IS_POSIX 1
3769 > _ACEOF
3770  
3771 < program main
3771 >   else
3772 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3773 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3774 >   { (exit 1); exit 1; }; }
3775 >   fi
3776 > fi
3777  
3778 < #ifndef __GNUC__
3779 <       choke me
3780 < #endif
3778 > ac_ext=${FC_SRCEXT-f}
3779 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3780 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3781 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3782  
3465 end program main
3783  
3784 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3785 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3786 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3787 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3788 + else
3789 +  ac_ext=F90
3790 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3791 + FCFLAGS_SRCEXT=""
3792 + ac_cv_fc_srcext_F90=unknown
3793 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3794 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3795 +  cat >conftest.$ac_ext <<_ACEOF
3796 +      program main
3797 +
3798 +      end
3799   _ACEOF
3800   rm -f conftest.$ac_objext
3801   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3474 | Line 3806 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3806    cat conftest.err >&5
3807    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808    (exit $ac_status); } &&
3809 <         { ac_try='test -z "$ac_f90_werror_flag"
3809 >         { ac_try='test -z "$ac_fc_werror_flag"
3810                           || test ! -s conftest.err'
3811    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3812    (eval $ac_try) 2>&5
# Line 3487 | Line 3819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3819    ac_status=$?
3820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821    (exit $ac_status); }; }; then
3822 <  ac_compiler_gnu=yes
3822 >  ac_cv_fc_srcext_F90=$ac_flag; break
3823   else
3824    echo "$as_me: failed program was:" >&5
3825   sed 's/^/| /' conftest.$ac_ext >&5
3826  
3495 ac_compiler_gnu=no
3827   fi
3828   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3829 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3829 > done
3830 > rm -f conftest.$ac_objext conftest.F90
3831 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3832  
3833   fi
3834 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3835 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3836 < ac_ext=$ac_save_ext
3837 < G95=`test $ac_compiler_gnu = yes && echo yes`
3838 < ac_ext=c
3839 < ac_cpp='$CPP $CPPFLAGS'
3840 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3841 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3842 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3834 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3835 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3836 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3837 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3838 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3839 >   { (exit 1); exit 1; }; }
3840 > else
3841 >  FC_SRCEXT=F90
3842 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3843 >    FCFLAGS_SRCEXT=""
3844 >    FCFLAGS_F90=""
3845 >  else
3846 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3847 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3848 >  fi
3849  
3850  
3851 + fi
3852  
3853  
3854  
3855 +
3856 +
3857   # Try to determine native compiler flags that allow us to use F90 suffix
3858   # for preprocessed f90 source.
3859  
# Line 3519 | Line 3861 | if test "$ac_test_PREPFLAG" != "set"; then
3861    PREPFLAG=""
3862    case "${host_cpu}-${host_os}" in
3863  
3864 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3864 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3865                      PREPFLAG="-fpp1 "
3866                  fi;;
3867 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3867 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3868                      PREPFLAG="-qsuffix=cpp=F90 "
3869                  fi;;
3870    *darwin*)
3871 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3871 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3872                  PREPFLAG="-qsuffix=cpp=F90 "
3873          fi;;
3874    esac
# Line 3541 | Line 3883 | echo $ECHO_N "checking to make sure F90 preprocessor f
3883   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3884  
3885  
3886 <  ac_ext=f90
3887 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3888 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3889 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3886 >  ac_ext=${FC_SRCEXT-f}
3887 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3888 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3889 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3890  
3891    ac_save_ext=$ac_ext
3892    ac_ext=F90
3893 <  ac_save_F90FLAGS=$F90FLAGS
3893 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3894  
3895    if test "$PREPFLAG"; then
3896 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3896 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3897   fi
3898  
3899      cat >conftest.$ac_ext <<_ACEOF
3900  
3901  
3902 < program main
3561 <
3902 > program conftest
3903    integer :: i
3904    i = 1
3905 + end program conftest
3906  
3565
3566 end program main
3567
3907   _ACEOF
3908   rm -f conftest.$ac_objext
3909   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3575 | Line 3914 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3914    cat conftest.err >&5
3915    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3916    (exit $ac_status); } &&
3917 <         { ac_try='test -z "$ac_f90_werror_flag"
3917 >         { ac_try='test -z "$ac_fc_werror_flag"
3918                           || test ! -s conftest.err'
3919    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3920    (eval $ac_try) 2>&5
# Line 3597 | Line 3936 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3936   fi
3937   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3938  
3939 <  F90FLAGS=$ac_save_F90FLAGS
3939 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3940    ac_ext=$ac_save_ext
3941 <  ac_ext=c
3942 < ac_cpp='$CPP $CPPFLAGS'
3943 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3944 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3606 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3941 >  ac_ext=${FC_SRCEXT-f}
3942 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3943 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3944 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3945  
3946  
3947    if test "$prepflagworks" = 1; then
3948      echo "$as_me:$LINENO: result: yes" >&5
3949   echo "${ECHO_T}yes" >&6
3950 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3951  
3952    else
3953      echo "$as_me:$LINENO: result: no" >&5
# Line 3630 | Line 3969 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3969    PREPDEFFLAG=""
3970    case "${host_cpu}-${host_os}" in
3971  
3972 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3972 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3973                      PREPDEFFLAG=" "
3974                  fi;;
3975 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3975 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3976                      PREPDEFFLAG="-WF,"
3977                  fi;;
3978    *darwin*)
3979 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3979 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3980                  PREPDEFFLAG="-WF,"
3981          fi;;
3982    esac
# Line 3652 | Line 3991 | echo $ECHO_N "checking to make sure F90 preprocessor d
3991   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3992  
3993  
3994 <  ac_ext=f90
3995 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3996 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3997 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3998 <
3994 >  ac_ext=${FC_SRCEXT-f}
3995 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3996 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3997 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3998 >
3999    ac_save_ext=$ac_ext
4000    ac_ext=F90
4001 <  ac_save_F90FLAGS=$F90FLAGS
4001 >  ac_save_FCFLAGS=$FCFLAGS
4002  
4003    if test "$PREPDEFFLAG"; then
4004 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
4004 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
4005   fi
4006  
4007      cat >conftest.$ac_ext <<_ACEOF
4008  
4009  
4010 < program main
3672 <
4010 > program conftest
4011    integer :: i
4012   #ifdef TEST
4013    i = 1
4014   #else
4015    choke me
4016   #endif
4017 + end program conftest
4018  
3680
3681 end program main
3682
4019   _ACEOF
4020   rm -f conftest.$ac_objext
4021   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3690 | Line 4026 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4026    cat conftest.err >&5
4027    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4028    (exit $ac_status); } &&
4029 <         { ac_try='test -z "$ac_f90_werror_flag"
4029 >         { ac_try='test -z "$ac_fc_werror_flag"
4030                           || test ! -s conftest.err'
4031    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4032    (eval $ac_try) 2>&5
# Line 3712 | Line 4048 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
4048   fi
4049   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4050  
4051 <  F90FLAGS=$ac_save_F90FLAGS
4051 >  FCFLAGS=$ac_save_FCFLAGS
4052    ac_ext=$ac_save_ext
4053 <  ac_ext=c
4054 < ac_cpp='$CPP $CPPFLAGS'
4055 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4056 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3721 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4053 >  ac_ext=${FC_SRCEXT-f}
4054 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4055 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4056 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4057  
4058  
3724
4059    if test "$prepdefflagworks" = 1; then
4060      echo "$as_me:$LINENO: result: yes" >&5
4061   echo "${ECHO_T}yes" >&6
# Line 3735 | Line 4069 | fi
4069    fi
4070   fi
4071  
4072 < ac_ext=f90
4073 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4074 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4075 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4076 <
4077 <
4078 <
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
4072 > ac_ext=${FC_SRCEXT-f}
4073 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4074 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4075 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4076 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4077 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4078 > if test "${ac_cv_prog_fc_v+set}" = set; then
4079    echo $ECHO_N "(cached) $ECHO_C" >&6
4080   else
4081 +  cat >conftest.$ac_ext <<_ACEOF
4082 +      program main
4083  
4084 < cat >conftest.$ac_ext <<_ACEOF
3756 <
3757 < program main
3758 <
3759 <
3760 < end program main
3761 <
4084 >      end
4085   _ACEOF
4086   rm -f conftest.$ac_objext
4087   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3769 | Line 4092 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4092    cat conftest.err >&5
4093    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4094    (exit $ac_status); } &&
4095 <         { ac_try='test -z "$ac_f90_werror_flag"
4095 >         { ac_try='test -z "$ac_fc_werror_flag"
4096                           || test ! -s conftest.err'
4097    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4098    (eval $ac_try) 2>&5
# Line 3782 | Line 4105 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4105    ac_status=$?
4106    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4107    (exit $ac_status); }; }; then
4108 <  ac_cv_prog_f90_v=
4108 >  ac_cv_prog_fc_v=
4109   # Try some options frequently used verbose output
4110   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4111 <  ac_ext=f90
4112 < 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
4111 >  cat >conftest.$ac_ext <<_ACEOF
4112 >      program main
4113  
4114 < cat >conftest.$ac_ext <<_ACEOF
3794 <
3795 < program main
3796 <
3797 <
3798 < end program main
3799 <
4114 >      end
4115   _ACEOF
4116  
4117   # Compile and link our simple test program by passing a flag (argument
4118 < # 1 to this macro) to the Fortran 90 compiler in order to get
4119 < # "verbose" output that we can then parse for the Fortran 90 linker
4118 > # 1 to this macro) to the Fortran compiler in order to get
4119 > # "verbose" output that we can then parse for the Fortran linker
4120   # flags.
4121 < ac_save_F90FLAGS=$F90FLAGS
4122 < F90FLAGS="$F90FLAGS $ac_verb"
4121 > ac_save_FFLAGS=$FCFLAGS
4122 > FCFLAGS="$FCFLAGS $ac_verb"
4123 > (eval echo $as_me:4123: \"$ac_link\") >&5
4124 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4125 > echo "$ac_fc_v_output" >&5
4126 > FCFLAGS=$ac_save_FFLAGS
4127  
4128 < (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
4128 > rm -f conftest*
4129  
4130 < rm -f conftest.*
4131 < ac_ext=f90
4132 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4133 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4134 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4130 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4131 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4132 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4133 > ac_fc_v_output="`echo $ac_fc_v_output |
4134 >        grep 'LPATH is:' |
4135 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4136  
4137 < # If we are using xlf then replace all the commas with spaces.
4138 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4139 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4140 < fi
4137 > case $ac_fc_v_output in
4138 >  # If we are using xlf then replace all the commas with spaces.
4139 >  *xlfentry*)
4140 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4141  
4142 < # If we are using Cray Fortran then delete quotes.
4143 < # Use "\"" instead of '"' for font-lock-mode.
4144 < # FIXME: a more general fix for quoted arguments with spaces?
4145 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4146 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4147 < fi
4142 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4143 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4144 >  *mGLOB_options_string*)
4145 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4146 >
4147 >  # If we are using Cray Fortran then delete quotes.
4148 >  # Use "\"" instead of '"' for font-lock-mode.
4149 >  # FIXME: a more general fix for quoted arguments with spaces?
4150 >  *cft90*)
4151 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4152 > esac
4153 >
4154 >
4155    # look for -l* and *.a constructs in the output
4156 <  for ac_arg in $ac_f90_v_output; do
4156 >  for ac_arg in $ac_fc_v_output; do
4157       case $ac_arg in
4158          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4159 <          ac_cv_prog_f90_v=$ac_verb
4159 >          ac_cv_prog_fc_v=$ac_verb
4160            break 2 ;;
4161       esac
4162    done
4163   done
4164 < if test -z "$ac_cv_prog_f90_v"; then
4165 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4166 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4164 > if test -z "$ac_cv_prog_fc_v"; then
4165 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4166 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4167   fi
4168   else
4169    echo "$as_me: failed program was:" >&5
# Line 3851 | Line 4175 | fi
4175   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4176  
4177   fi
4178 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4179 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4180 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4181 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4182 < if test "${ac_cv_flibs+set}" = set; then
4178 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4179 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4180 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4181 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4182 > if test "${ac_cv_fc_libs+set}" = set; then
4183    echo $ECHO_N "(cached) $ECHO_C" >&6
4184   else
4185 <  if test "x$F90LIBS" != "x"; then
4186 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4185 >  if test "x$FCLIBS" != "x"; then
4186 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4187   else
4188  
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
4189   cat >conftest.$ac_ext <<_ACEOF
4190 +      program main
4191  
4192 < program main
3873 <
3874 <
3875 < end program main
3876 <
4192 >      end
4193   _ACEOF
4194  
4195   # Compile and link our simple test program by passing a flag (argument
4196 < # 1 to this macro) to the Fortran 90 compiler in order to get
4197 < # "verbose" output that we can then parse for the Fortran 90 linker
4196 > # 1 to this macro) to the Fortran compiler in order to get
4197 > # "verbose" output that we can then parse for the Fortran linker
4198   # flags.
4199 < ac_save_F90FLAGS=$F90FLAGS
4200 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4199 > ac_save_FFLAGS=$FCFLAGS
4200 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4201 > (eval echo $as_me:4201: \"$ac_link\") >&5
4202 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4203 > echo "$ac_fc_v_output" >&5
4204 > FCFLAGS=$ac_save_FFLAGS
4205  
4206 < (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
4206 > rm -f conftest*
4207  
4208 < rm -f conftest.*
4209 < ac_ext=f90
4210 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4211 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4212 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4208 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4209 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4210 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4211 > ac_fc_v_output="`echo $ac_fc_v_output |
4212 >        grep 'LPATH is:' |
4213 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4214  
4215 < # If we are using xlf then replace all the commas with spaces.
4216 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4217 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4218 < fi
4215 > case $ac_fc_v_output in
4216 >  # If we are using xlf then replace all the commas with spaces.
4217 >  *xlfentry*)
4218 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4219  
4220 < # If we are using Cray Fortran then delete quotes.
4221 < # Use "\"" instead of '"' for font-lock-mode.
4222 < # FIXME: a more general fix for quoted arguments with spaces?
4223 < 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
4220 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4221 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4222 >  *mGLOB_options_string*)
4223 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4224  
4225 < ac_cv_f90libs=
4225 >  # If we are using Cray Fortran then delete quotes.
4226 >  # Use "\"" instead of '"' for font-lock-mode.
4227 >  # FIXME: a more general fix for quoted arguments with spaces?
4228 >  *cft90*)
4229 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4230 > esac
4231  
4232 +
4233 +
4234 + ac_cv_fc_libs=
4235 +
4236   # Save positional arguments (if any)
4237   ac_save_positional="$@"
4238  
4239 < set X $ac_f90_v_output
4239 > set X $ac_fc_v_output
4240   while test $# != 1; do
4241    shift
4242    ac_arg=$1
4243    case $ac_arg in
4244          [\\/]*.a | ?:[\\/]*.a)
4245              ac_exists=false
4246 <  for ac_i in $ac_cv_f90libs; do
4246 >  for ac_i in $ac_cv_fc_libs; do
4247      if test x"$ac_arg" = x"$ac_i"; then
4248        ac_exists=true
4249        break
# Line 3928 | Line 4253 | else
4253    if test x"$ac_exists" = xtrue; then
4254    :
4255   else
4256 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4256 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4257   fi
4258  
4259            ;;
4260          -bI:*)
4261              ac_exists=false
4262 <  for ac_i in $ac_cv_f90libs; do
4262 >  for ac_i in $ac_cv_fc_libs; do
4263      if test x"$ac_arg" = x"$ac_i"; then
4264        ac_exists=true
4265        break
# Line 3946 | Line 4271 | else
4271   else
4272    if test "$ac_compiler_gnu" = yes; then
4273    for ac_link_opt in $ac_arg; do
4274 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4274 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4275    done
4276   else
4277 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4277 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4278   fi
4279   fi
4280  
4281            ;;
4282            # Ignore these flags.
4283 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4283 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4284            ;;
4285          -lkernel32)
4286 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4286 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4287            ;;
4288          -[LRuY])
4289            # These flags, when seen by themselves, take an argument.
4290            # We remove the space between option and argument and re-iterate
4291            # unless we find an empty arg or a new option (starting with -)
4292            case $2 in
4293 <             "" | -*);;
4294 <             *)
4293 >             "" | -*);;
4294 >             *)
4295                  ac_arg="$ac_arg$2"
3971
4296                  shift; shift
4297                  set X $ac_arg "$@"
4298                  ;;
# Line 3977 | Line 4301 | fi
4301          -YP,*)
4302            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4303                ac_exists=false
4304 <  for ac_i in $ac_cv_f90libs; do
4304 >  for ac_i in $ac_cv_fc_libs; do
4305      if test x"$ac_j" = x"$ac_i"; then
4306        ac_exists=true
4307        break
# Line 3988 | Line 4312 | else
4312    :
4313   else
4314    ac_arg="$ac_arg $ac_j"
4315 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4315 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4316   fi
4317  
4318            done
4319            ;;
4320          -[lLR]*)
4321              ac_exists=false
4322 <  for ac_i in $ac_cv_f90libs; do
4322 >  for ac_i in $ac_cv_fc_libs; do
4323      if test x"$ac_arg" = x"$ac_i"; then
4324        ac_exists=true
4325        break
# Line 4005 | Line 4329 | else
4329    if test x"$ac_exists" = xtrue; then
4330    :
4331   else
4332 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4332 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4333   fi
4334  
4335            ;;
# Line 4020 | Line 4344 | case `(uname -sr) 2>/dev/null` in
4344   # must begin with a "/").
4345   case `(uname -sr) 2>/dev/null` in
4346     "SunOS 5"*)
4347 <      ac_ld_run_path=`echo $ac_f90_v_output |
4347 >      ac_ld_run_path=`echo $ac_fc_v_output |
4348                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4349        test "x$ac_ld_run_path" != x &&
4026
4350          if test "$ac_compiler_gnu" = yes; then
4351    for ac_link_opt in $ac_ld_run_path; do
4352 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4352 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4353    done
4354   else
4355 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4355 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4356   fi
4357        ;;
4358   esac
4359 < fi # test "x$F90LIBS" = "x"
4359 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4360  
4361   fi
4362 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4363 < echo "${ECHO_T}$ac_cv_flibs" >&6
4364 < F90LIBS="$ac_cv_f90libs"
4362 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4363 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4364 > FCLIBS="$ac_cv_fc_libs"
4365  
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
4366  
4367 + ac_ext=${FC_SRCEXT-f}
4368 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4369 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4370 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4371  
4372 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4373 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4374 < if test "${ac_cv_f90_mangling+set}" = set; then
4372 >
4373 > ac_ext=${FC_SRCEXT-f}
4374 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4375 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4376 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4377 >
4378 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4379 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4380 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4381    echo $ECHO_N "(cached) $ECHO_C" >&6
4382   else
4383 <  ac_ext=f90
4384 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4385 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4386 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4387 < cat >conftest.$ac_ext <<_ACEOF
4388 < subroutine foobar()
4389 < return
4390 < end
4391 < subroutine foo_bar()
4392 < return
4393 < end
4383 >  ac_fc_dm_save_LIBS=$LIBS
4384 > LIBS="$LIBS $FCLIBS"
4385 > ac_fortran_dm_var=FC_DUMMY_MAIN
4386 > ac_ext=c
4387 > ac_cpp='$CPP $CPPFLAGS'
4388 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4389 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4390 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4391 >
4392 > # First, try linking without a dummy main:
4393 > cat >conftest.$ac_ext <<_ACEOF
4394 > /* confdefs.h.  */
4395   _ACEOF
4396 + cat confdefs.h >>conftest.$ac_ext
4397 + cat >>conftest.$ac_ext <<_ACEOF
4398 + /* end confdefs.h.  */
4399 +
4400 + #ifdef FC_DUMMY_MAIN
4401 + #ifndef FC_DUMMY_MAIN_EQ_F77
4402 + #  ifdef __cplusplus
4403 +     extern "C"
4404 + #  endif
4405 +   int FC_DUMMY_MAIN() { return 1; }
4406 + #endif
4407 + #endif
4408 + int
4409 + main ()
4410 + {
4411 +
4412 +  ;
4413 +  return 0;
4414 + }
4415 + _ACEOF
4416 + rm -f conftest.$ac_objext conftest$ac_exeext
4417 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4418 +  (eval $ac_link) 2>conftest.er1
4419 +  ac_status=$?
4420 +  grep -v '^ *+' conftest.er1 >conftest.err
4421 +  rm -f conftest.er1
4422 +  cat conftest.err >&5
4423 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4424 +  (exit $ac_status); } &&
4425 +         { ac_try='test -z "$ac_c_werror_flag"
4426 +                         || test ! -s conftest.err'
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); }; } &&
4432 +         { ac_try='test -s conftest$ac_exeext'
4433 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4434 +  (eval $ac_try) 2>&5
4435 +  ac_status=$?
4436 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4437 +  (exit $ac_status); }; }; then
4438 +  ac_cv_fortran_dummy_main=none
4439 + else
4440 +  echo "$as_me: failed program was:" >&5
4441 + sed 's/^/| /' conftest.$ac_ext >&5
4442 +
4443 + ac_cv_fortran_dummy_main=unknown
4444 + fi
4445 + rm -f conftest.err conftest.$ac_objext \
4446 +      conftest$ac_exeext conftest.$ac_ext
4447 +
4448 + if test $ac_cv_fortran_dummy_main = unknown; then
4449 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4450 +     cat >conftest.$ac_ext <<_ACEOF
4451 + /* confdefs.h.  */
4452 + _ACEOF
4453 + cat confdefs.h >>conftest.$ac_ext
4454 + cat >>conftest.$ac_ext <<_ACEOF
4455 + /* end confdefs.h.  */
4456 + #define $ac_fortran_dm_var $ac_func
4457 + #ifdef FC_DUMMY_MAIN
4458 + #ifndef FC_DUMMY_MAIN_EQ_F77
4459 + #  ifdef __cplusplus
4460 +     extern "C"
4461 + #  endif
4462 +   int FC_DUMMY_MAIN() { return 1; }
4463 + #endif
4464 + #endif
4465 + int
4466 + main ()
4467 + {
4468 +
4469 +  ;
4470 +  return 0;
4471 + }
4472 + _ACEOF
4473 + rm -f conftest.$ac_objext conftest$ac_exeext
4474 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4475 +  (eval $ac_link) 2>conftest.er1
4476 +  ac_status=$?
4477 +  grep -v '^ *+' conftest.er1 >conftest.err
4478 +  rm -f conftest.er1
4479 +  cat conftest.err >&5
4480 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4481 +  (exit $ac_status); } &&
4482 +         { ac_try='test -z "$ac_c_werror_flag"
4483 +                         || test ! -s conftest.err'
4484 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4485 +  (eval $ac_try) 2>&5
4486 +  ac_status=$?
4487 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4488 +  (exit $ac_status); }; } &&
4489 +         { ac_try='test -s conftest$ac_exeext'
4490 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4491 +  (eval $ac_try) 2>&5
4492 +  ac_status=$?
4493 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4494 +  (exit $ac_status); }; }; then
4495 +  ac_cv_fortran_dummy_main=$ac_func; break
4496 + else
4497 +  echo "$as_me: failed program was:" >&5
4498 + sed 's/^/| /' conftest.$ac_ext >&5
4499 +
4500 + fi
4501 + rm -f conftest.err conftest.$ac_objext \
4502 +      conftest$ac_exeext conftest.$ac_ext
4503 +   done
4504 + fi
4505 + ac_ext=${FC_SRCEXT-f}
4506 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4507 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4508 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4509 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4510 + rm -f conftest*
4511 + LIBS=$ac_fc_dm_save_LIBS
4512 +
4513 + fi
4514 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4515 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4516 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4517 + if test "$FC_DUMMY_MAIN" != unknown; then
4518 +  if test $FC_DUMMY_MAIN != none; then
4519 +
4520 + cat >>confdefs.h <<_ACEOF
4521 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4522 + _ACEOF
4523 +
4524 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4525 +
4526 + cat >>confdefs.h <<\_ACEOF
4527 + #define FC_DUMMY_MAIN_EQ_F77 1
4528 + _ACEOF
4529 +
4530 +  fi
4531 + fi
4532 + else
4533 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4534 + See \`config.log' for more details." >&5
4535 + echo "$as_me: error: linking to Fortran libraries from C fails
4536 + See \`config.log' for more details." >&2;}
4537 +   { (exit 1); exit 1; }; }
4538 + fi
4539 +
4540 +
4541 + ac_ext=${FC_SRCEXT-f}
4542 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4543 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4544 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4545 +
4546 + ac_ext=${FC_SRCEXT-f}
4547 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4548 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4549 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4550 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4551 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4552 + if test "${ac_cv_fc_mangling+set}" = set; then
4553 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4554 + else
4555 +  cat >conftest.$ac_ext <<_ACEOF
4556 +      subroutine foobar()
4557 +      return
4558 +      end
4559 +      subroutine foo_bar()
4560 +      return
4561 +      end
4562 + _ACEOF
4563   rm -f conftest.$ac_objext
4564   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4565    (eval $ac_compile) 2>conftest.er1
# Line 4072 | Line 4569 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4569    cat conftest.err >&5
4570    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4571    (exit $ac_status); } &&
4572 <         { ac_try='test -z "$ac_f90_werror_flag"
4572 >         { ac_try='test -z "$ac_fc_werror_flag"
4573                           || test ! -s conftest.err'
4574    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4575    (eval $ac_try) 2>&5
# Line 4085 | Line 4582 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4582    ac_status=$?
4583    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4584    (exit $ac_status); }; }; then
4585 <  mv conftest.$ac_objext cf90_test.$ac_objext
4585 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4586  
4587 +  ac_save_LIBS=$LIBS
4588 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4589 +
4590    ac_ext=c
4591   ac_cpp='$CPP $CPPFLAGS'
4592   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4593   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4594   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4095
4096  ac_save_LIBS=$LIBS
4097  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4098
4595    ac_success=no
4596    for ac_foobar in foobar FOOBAR; do
4597      for ac_underscore in "" "_"; do
# Line 4114 | Line 4610 | char $ac_func ();
4610   /* We use char because int might match the return type of a gcc2
4611     builtin and then its argument prototype would still apply.  */
4612   char $ac_func ();
4613 + #ifdef FC_DUMMY_MAIN
4614 + #ifndef FC_DUMMY_MAIN_EQ_F77
4615 + #  ifdef __cplusplus
4616 +     extern "C"
4617 + #  endif
4618 +   int FC_DUMMY_MAIN() { return 1; }
4619 + #endif
4620 + #endif
4621   int
4622   main ()
4623   {
# Line 4154 | Line 4658 | rm -f conftest.err conftest.$ac_objext \
4658        conftest$ac_exeext conftest.$ac_ext
4659      done
4660    done
4661 +  ac_ext=${FC_SRCEXT-f}
4662 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4663 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4664 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4665  
4666    if test "$ac_success" = "yes"; then
4667       case $ac_foobar in
4668 <        foobar)
4669 <           ac_case=lower
4670 <           ac_foo_bar=foo_bar
4671 <           ;;
4672 <        FOOBAR)
4673 <           ac_case=upper
4674 <           ac_foo_bar=FOO_BAR
4675 <           ;;
4668 >        foobar)
4669 >           ac_case=lower
4670 >           ac_foo_bar=foo_bar
4671 >           ;;
4672 >        FOOBAR)
4673 >           ac_case=upper
4674 >           ac_foo_bar=FOO_BAR
4675 >           ;;
4676       esac
4677  
4678 +     ac_ext=c
4679 + ac_cpp='$CPP $CPPFLAGS'
4680 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4681 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4682 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4683       ac_success_extra=no
4684       for ac_extra in "" "_"; do
4685 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4686 <
4174 <        cat >conftest.$ac_ext <<_ACEOF
4685 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4686 >        cat >conftest.$ac_ext <<_ACEOF
4687   /* confdefs.h.  */
4688   _ACEOF
4689   cat confdefs.h >>conftest.$ac_ext
# Line 4185 | Line 4697 | char $ac_func ();
4697   /* We use char because int might match the return type of a gcc2
4698     builtin and then its argument prototype would still apply.  */
4699   char $ac_func ();
4700 + #ifdef FC_DUMMY_MAIN
4701 + #ifndef FC_DUMMY_MAIN_EQ_F77
4702 + #  ifdef __cplusplus
4703 +     extern "C"
4704 + #  endif
4705 +   int FC_DUMMY_MAIN() { return 1; }
4706 + #endif
4707 + #endif
4708   int
4709   main ()
4710   {
# Line 4224 | Line 4744 | rm -f conftest.err conftest.$ac_objext \
4744   rm -f conftest.err conftest.$ac_objext \
4745        conftest$ac_exeext conftest.$ac_ext
4746       done
4747 +     ac_ext=${FC_SRCEXT-f}
4748 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4749 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4750 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4751  
4752       if test "$ac_success_extra" = "yes"; then
4753 <        ac_cv_f90_mangling="$ac_case case"
4753 >        ac_cv_fc_mangling="$ac_case case"
4754          if test -z "$ac_underscore"; then
4755 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4755 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4756          else
4757 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4234 <
4757 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4758          fi
4759          if test -z "$ac_extra"; then
4760 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4760 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4761          else
4762 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4762 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4763          fi
4764        else
4765 <        ac_cv_f90_mangling="unknown"
4765 >        ac_cv_fc_mangling="unknown"
4766        fi
4767    else
4768 <     ac_cv_f90_mangling="unknown"
4246 <
4768 >     ac_cv_fc_mangling="unknown"
4769    fi
4770  
4771    LIBS=$ac_save_LIBS
4772 <  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*
4772 >  rm -f cfortran_test* conftest*
4773   else
4774    echo "$as_me: failed program was:" >&5
4775   sed 's/^/| /' conftest.$ac_ext >&5
4776  
4777 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4778 + See \`config.log' for more details." >&5
4779 + echo "$as_me: error: cannot compile a simple Fortran program
4780 + See \`config.log' for more details." >&2;}
4781 +   { (exit 1); exit 1; }; }
4782   fi
4783   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
4784  
4785   fi
4786 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4787 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4786 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4787 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4788  
4789 + ac_ext=${FC_SRCEXT-f}
4790 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4791 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4792 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4793  
4794 + ac_ext=${FC_SRCEXT-f}
4795 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4796 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4797 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4798  
4799 < case $ac_cv_f90_mangling in
4799 >
4800 > case $ac_cv_fc_mangling in
4801    "lower case, no underscore, no 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    "lower case, no underscore, extra underscore")
4811            cat >>confdefs.h <<\_ACEOF
4812 < #define F90_FUNC(name,NAME) name
4812 > #define FC_FUNC(name,NAME) name
4813   _ACEOF
4814  
4815            cat >>confdefs.h <<\_ACEOF
4816 < #define F90_FUNC_(name,NAME) name ## _
4816 > #define FC_FUNC_(name,NAME) name ## _
4817   _ACEOF
4818   ;;
4819    "lower case, underscore, no extra underscore")
4820            cat >>confdefs.h <<\_ACEOF
4821 < #define F90_FUNC(name,NAME) name ## _
4821 > #define FC_FUNC(name,NAME) name ## _
4822   _ACEOF
4823  
4824            cat >>confdefs.h <<\_ACEOF
4825 < #define F90_FUNC_(name,NAME) name ## _
4825 > #define FC_FUNC_(name,NAME) name ## _
4826   _ACEOF
4827   ;;
4828    "lower case, underscore, extra underscore")
4829            cat >>confdefs.h <<\_ACEOF
4830 < #define F90_FUNC(name,NAME) name ## _
4830 > #define FC_FUNC(name,NAME) name ## _
4831   _ACEOF
4832  
4833            cat >>confdefs.h <<\_ACEOF
4834 < #define F90_FUNC_(name,NAME) name ## __
4834 > #define FC_FUNC_(name,NAME) name ## __
4835   _ACEOF
4836   ;;
4837    "upper case, no underscore, no extra underscore")
4838            cat >>confdefs.h <<\_ACEOF
4839 < #define F90_FUNC(name,NAME) NAME
4839 > #define FC_FUNC(name,NAME) NAME
4840   _ACEOF
4841  
4842            cat >>confdefs.h <<\_ACEOF
4843 < #define F90_FUNC_(name,NAME) NAME
4843 > #define FC_FUNC_(name,NAME) NAME
4844   _ACEOF
4845   ;;
4846    "upper case, no underscore, extra underscore")
4847            cat >>confdefs.h <<\_ACEOF
4848 < #define F90_FUNC(name,NAME) NAME
4848 > #define FC_FUNC(name,NAME) NAME
4849   _ACEOF
4850  
4851            cat >>confdefs.h <<\_ACEOF
4852 < #define F90_FUNC_(name,NAME) NAME ## _
4852 > #define FC_FUNC_(name,NAME) NAME ## _
4853   _ACEOF
4854   ;;
4855    "upper case, underscore, no extra underscore")
4856            cat >>confdefs.h <<\_ACEOF
4857 < #define F90_FUNC(name,NAME) NAME ## _
4857 > #define FC_FUNC(name,NAME) NAME ## _
4858   _ACEOF
4859  
4860            cat >>confdefs.h <<\_ACEOF
4861 < #define F90_FUNC_(name,NAME) NAME ## _
4861 > #define FC_FUNC_(name,NAME) NAME ## _
4862   _ACEOF
4863   ;;
4864    "upper case, underscore, extra underscore")
4865            cat >>confdefs.h <<\_ACEOF
4866 < #define F90_FUNC(name,NAME) NAME ## _
4866 > #define FC_FUNC(name,NAME) NAME ## _
4867   _ACEOF
4868  
4869            cat >>confdefs.h <<\_ACEOF
4870 < #define F90_FUNC_(name,NAME) NAME ## __
4870 > #define FC_FUNC_(name,NAME) NAME ## __
4871   _ACEOF
4872   ;;
4873    *)
4874 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4875 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4874 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4875 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4876 >          ;;
4877 > esac
4878 >
4879 > ac_ext=${FC_SRCEXT-f}
4880 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4881 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4882 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4883 >
4884 >
4885 >
4886 > ac_ext=${FC_SRCEXT-f}
4887 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4888 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4889 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4890 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4891 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4892 > if test "${ac_cv_prog_fc_v+set}" = set; then
4893 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4894 > else
4895 >  cat >conftest.$ac_ext <<_ACEOF
4896 >      program main
4897 >
4898 >      end
4899 > _ACEOF
4900 > rm -f conftest.$ac_objext
4901 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4902 >  (eval $ac_compile) 2>conftest.er1
4903 >  ac_status=$?
4904 >  grep -v '^ *+' conftest.er1 >conftest.err
4905 >  rm -f conftest.er1
4906 >  cat conftest.err >&5
4907 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4908 >  (exit $ac_status); } &&
4909 >         { ac_try='test -z "$ac_fc_werror_flag"
4910 >                         || test ! -s conftest.err'
4911 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4912 >  (eval $ac_try) 2>&5
4913 >  ac_status=$?
4914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4915 >  (exit $ac_status); }; } &&
4916 >         { ac_try='test -s conftest.$ac_objext'
4917 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4918 >  (eval $ac_try) 2>&5
4919 >  ac_status=$?
4920 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4921 >  (exit $ac_status); }; }; then
4922 >  ac_cv_prog_fc_v=
4923 > # Try some options frequently used verbose output
4924 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4925 >  cat >conftest.$ac_ext <<_ACEOF
4926 >      program main
4927 >
4928 >      end
4929 > _ACEOF
4930 >
4931 > # Compile and link our simple test program by passing a flag (argument
4932 > # 1 to this macro) to the Fortran compiler in order to get
4933 > # "verbose" output that we can then parse for the Fortran linker
4934 > # flags.
4935 > ac_save_FFLAGS=$FCFLAGS
4936 > FCFLAGS="$FCFLAGS $ac_verb"
4937 > (eval echo $as_me:4937: \"$ac_link\") >&5
4938 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4939 > echo "$ac_fc_v_output" >&5
4940 > FCFLAGS=$ac_save_FFLAGS
4941 >
4942 > rm -f conftest*
4943 >
4944 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4945 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4946 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4947 > ac_fc_v_output="`echo $ac_fc_v_output |
4948 >        grep 'LPATH is:' |
4949 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4950 >
4951 > case $ac_fc_v_output in
4952 >  # If we are using xlf then replace all the commas with spaces.
4953 >  *xlfentry*)
4954 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4955 >
4956 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4957 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4958 >  *mGLOB_options_string*)
4959 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4960 >
4961 >  # If we are using Cray Fortran then delete quotes.
4962 >  # Use "\"" instead of '"' for font-lock-mode.
4963 >  # FIXME: a more general fix for quoted arguments with spaces?
4964 >  *cft90*)
4965 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4966 > esac
4967 >
4968 >
4969 >  # look for -l* and *.a constructs in the output
4970 >  for ac_arg in $ac_fc_v_output; do
4971 >     case $ac_arg in
4972 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4973 >          ac_cv_prog_fc_v=$ac_verb
4974 >          break 2 ;;
4975 >     esac
4976 >  done
4977 > done
4978 > if test -z "$ac_cv_prog_fc_v"; then
4979 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4980 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4981 > fi
4982 > else
4983 >  echo "$as_me: failed program was:" >&5
4984 > sed 's/^/| /' conftest.$ac_ext >&5
4985 >
4986 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4987 > echo "$as_me: WARNING: compilation failed" >&2;}
4988 > fi
4989 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4990 >
4991 > fi
4992 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4993 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4994 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4995 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4996 > if test "${ac_cv_fc_libs+set}" = set; then
4997 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4998 > else
4999 >  if test "x$FCLIBS" != "x"; then
5000 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
5001 > else
5002 >
5003 > cat >conftest.$ac_ext <<_ACEOF
5004 >      program main
5005 >
5006 >      end
5007 > _ACEOF
5008 >
5009 > # Compile and link our simple test program by passing a flag (argument
5010 > # 1 to this macro) to the Fortran compiler in order to get
5011 > # "verbose" output that we can then parse for the Fortran linker
5012 > # flags.
5013 > ac_save_FFLAGS=$FCFLAGS
5014 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5015 > (eval echo $as_me:5015: \"$ac_link\") >&5
5016 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5017 > echo "$ac_fc_v_output" >&5
5018 > FCFLAGS=$ac_save_FFLAGS
5019 >
5020 > rm -f conftest*
5021 >
5022 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5023 > # /foo, /bar, and /baz are search directories for the Fortran linker.
5024 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5025 > ac_fc_v_output="`echo $ac_fc_v_output |
5026 >        grep 'LPATH is:' |
5027 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5028 >
5029 > case $ac_fc_v_output in
5030 >  # If we are using xlf then replace all the commas with spaces.
5031 >  *xlfentry*)
5032 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5033 >
5034 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5035 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
5036 >  *mGLOB_options_string*)
5037 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
5038 >
5039 >  # If we are using Cray Fortran then delete quotes.
5040 >  # Use "\"" instead of '"' for font-lock-mode.
5041 >  # FIXME: a more general fix for quoted arguments with spaces?
5042 >  *cft90*)
5043 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
5044 > esac
5045 >
5046 >
5047 >
5048 > ac_cv_fc_libs=
5049 >
5050 > # Save positional arguments (if any)
5051 > ac_save_positional="$@"
5052 >
5053 > set X $ac_fc_v_output
5054 > while test $# != 1; do
5055 >  shift
5056 >  ac_arg=$1
5057 >  case $ac_arg in
5058 >        [\\/]*.a | ?:[\\/]*.a)
5059 >            ac_exists=false
5060 >  for ac_i in $ac_cv_fc_libs; do
5061 >    if test x"$ac_arg" = x"$ac_i"; then
5062 >      ac_exists=true
5063 >      break
5064 >    fi
5065 >  done
5066 >
5067 >  if test x"$ac_exists" = xtrue; then
5068 >  :
5069 > else
5070 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5071 > fi
5072 >
5073            ;;
5074 +        -bI:*)
5075 +            ac_exists=false
5076 +  for ac_i in $ac_cv_fc_libs; do
5077 +    if test x"$ac_arg" = x"$ac_i"; then
5078 +      ac_exists=true
5079 +      break
5080 +    fi
5081 +  done
5082 +
5083 +  if test x"$ac_exists" = xtrue; then
5084 +  :
5085 + else
5086 +  if test "$ac_compiler_gnu" = yes; then
5087 +  for ac_link_opt in $ac_arg; do
5088 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5089 +  done
5090 + else
5091 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5092 + fi
5093 + fi
5094 +
5095 +          ;;
5096 +          # Ignore these flags.
5097 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5098 +          ;;
5099 +        -lkernel32)
5100 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5101 +          ;;
5102 +        -[LRuY])
5103 +          # These flags, when seen by themselves, take an argument.
5104 +          # We remove the space between option and argument and re-iterate
5105 +          # unless we find an empty arg or a new option (starting with -)
5106 +          case $2 in
5107 +             "" | -*);;
5108 +             *)
5109 +                ac_arg="$ac_arg$2"
5110 +                shift; shift
5111 +                set X $ac_arg "$@"
5112 +                ;;
5113 +          esac
5114 +          ;;
5115 +        -YP,*)
5116 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5117 +              ac_exists=false
5118 +  for ac_i in $ac_cv_fc_libs; do
5119 +    if test x"$ac_j" = x"$ac_i"; then
5120 +      ac_exists=true
5121 +      break
5122 +    fi
5123 +  done
5124 +
5125 +  if test x"$ac_exists" = xtrue; then
5126 +  :
5127 + else
5128 +  ac_arg="$ac_arg $ac_j"
5129 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5130 + fi
5131 +
5132 +          done
5133 +          ;;
5134 +        -[lLR]*)
5135 +            ac_exists=false
5136 +  for ac_i in $ac_cv_fc_libs; do
5137 +    if test x"$ac_arg" = x"$ac_i"; then
5138 +      ac_exists=true
5139 +      break
5140 +    fi
5141 +  done
5142 +
5143 +  if test x"$ac_exists" = xtrue; then
5144 +  :
5145 + else
5146 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5147 + fi
5148 +
5149 +          ;;
5150 +          # Ignore everything else.
5151 +  esac
5152 + done
5153 + # restore positional arguments
5154 + set X $ac_save_positional; shift
5155 +
5156 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5157 + # then we insist that the "run path" must be an absolute path (i.e. it
5158 + # must begin with a "/").
5159 + case `(uname -sr) 2>/dev/null` in
5160 +   "SunOS 5"*)
5161 +      ac_ld_run_path=`echo $ac_fc_v_output |
5162 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5163 +      test "x$ac_ld_run_path" != x &&
5164 +        if test "$ac_compiler_gnu" = yes; then
5165 +  for ac_link_opt in $ac_ld_run_path; do
5166 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5167 +  done
5168 + else
5169 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5170 + fi
5171 +      ;;
5172   esac
5173 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5174  
5175 + fi
5176 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5177 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5178 + FCLIBS="$ac_cv_fc_libs"
5179  
5180  
5181 + ac_ext=${FC_SRCEXT-f}
5182 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5183 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5184 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5185  
5186  
5187 +
5188   echo "$as_me:$LINENO: checking for module suffix" >&5
5189   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5190   rm -f conftest*
5191   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5192   rm -f work*
5193 < cat >conftest.f90 <<EOF
5193 > cat >conftest.$ac_ext <<EOF
5194          module conftest
5195          integer n
5196          parameter (n=1)
# Line 4366 | Line 5199 | modcase="lower"
5199   # SGI and absoft compilers generates module name in upper case!
5200   testname="conftest"
5201   modcase="lower"
5202 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5203 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5202 > if (eval $ac_compile) 2>/dev/null ; then
5203 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5204      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5205      if test -z "$MOD" ; then
5206          MOD=`ls CONFTEST* 2>/dev/null \
5207 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5207 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5208          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5209          if test -n "$MOD" ; then
5210              testname="CONFTEST"
# Line 4411 | Line 5244 | rm -f work*
5244   rm -f conftest*
5245   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5246   rm -f work*
5247 < cat >conftest.f90 <<EOF
5247 > cat >conftest.$ac_ext <<EOF
5248          module conftest
5249          integer n
5250          parameter (n=1)
# Line 4419 | Line 5252 | testname="conftest"
5252   EOF
5253   # SGI and absoft compilers generates module name in upper case!
5254   testname="conftest"
5255 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5256 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5255 > if (eval $ac_compile) 2>/dev/null ; then
5256 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5257     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5258     if test -n "$mod" ; then
5259        testname="CONFTEST"
# Line 4429 | Line 5262 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5262     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5263     cp $testname.$MOD conf
5264     rm -f conftest* CONFTEST*
5265 <   cat >conftest1.f90 <<EOF
5265 >   cat >conftest1.$ac_ext <<EOF
5266          program main
5267          use conftest
5268          print *, n
# Line 4437 | Line 5270 | EOF
5270   EOF
5271     F90_WORK_FILES_ARG=""
5272     F90MODINCSPEC=""
5273 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5273 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5274         MODDIRFLAG="-I"
5275         F90MODINCSPEC="-I<dir>"
5276         echo "$as_me:$LINENO: result: -I" >&5
5277   echo "${ECHO_T}-I" >&6
5278 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5278 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5279         MODDIRFLAG="-M"
5280         F90MODINCSPEC="-M<dir>"
5281         echo "$as_me:$LINENO: result: -M" >&5
5282   echo "${ECHO_T}-M" >&6
5283 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5283 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5284         MODDIRFLAG="-p"
5285         F90MODINCSPEC="-p<dir>"
5286         echo "$as_me:$LINENO: result: -p" >&5
# Line 4456 | Line 5289 | echo "${ECHO_T}-p" >&6
5289          cp work.pc conf/mpimod.pc
5290          echo "mpimod.pc" > conf/mpimod.pcl
5291          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5292 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5292 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5293              MODDIRFLAG='-cl,mpimod.pcl'
5294              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5295   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4486 | Line 5319 | else
5319   if test "${ac_cv_f90_module_names+set}" = set; then
5320    echo $ECHO_N "(cached) $ECHO_C" >&6
5321   else
5322 <  ac_ext=f90
5323 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5324 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5325 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5322 >  ac_ext=${FC_SRCEXT-f}
5323 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5324 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5325 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5326  
5327   # carry out the test in a new directory, so that we don't miss anything
5328   mkdir conftest
# Line 4507 | Line 5340 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5340    cat conftest.err >&5
5341    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5342    (exit $ac_status); } &&
5343 <         { ac_try='test -z "$ac_f90_werror_flag"
5343 >         { ac_try='test -z "$ac_fc_werror_flag"
5344                           || test ! -s conftest.err'
5345    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5346    (eval $ac_try) 2>&5
# Line 4623 | Line 5456 | rm -rf conftest
5456   cd ..
5457   # cleanup
5458   rm -rf conftest
5459 < ac_ext=f90
5460 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5461 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5462 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5459 > ac_ext=${FC_SRCEXT-f}
5460 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5461 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5462 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5463  
5464   fi
5465   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4715 | Line 5548 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5548   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5549  
5550  
5551 < ac_ext=cc
5552 < ac_cpp='$CXXCPP $CPPFLAGS'
5553 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5554 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5555 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5551 > ac_ext=c
5552 > ac_cpp='$CPP $CPPFLAGS'
5553 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5554 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5555 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5556  
5557  
5558  
# Line 4744 | Line 5577 | char asin ();
5577   /* We use char because int might match the return type of a gcc2
5578     builtin and then its argument prototype would still apply.  */
5579   char asin ();
5580 + #ifdef FC_DUMMY_MAIN
5581 + #ifndef FC_DUMMY_MAIN_EQ_F77
5582 + #  ifdef __cplusplus
5583 +     extern "C"
5584 + #  endif
5585 +   int FC_DUMMY_MAIN() { return 1; }
5586 + #endif
5587 + #endif
5588   int
5589   main ()
5590   {
# Line 4761 | Line 5602 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5602    cat conftest.err >&5
5603    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5604    (exit $ac_status); } &&
5605 <         { ac_try='test -z "$ac_cxx_werror_flag"
5605 >         { ac_try='test -z "$ac_c_werror_flag"
5606                           || test ! -s conftest.err'
5607    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5608    (eval $ac_try) 2>&5
# Line 4797 | Line 5638 | fi
5638   else
5639    exit
5640   fi
4800
4801
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
5641  
5642  
5643   echo "$as_me:$LINENO: checking for ANSI C header files" >&5
# Line 4822 | Line 5656 | cat >>conftest.$ac_ext <<_ACEOF
5656   #include <string.h>
5657   #include <float.h>
5658  
5659 + #ifdef FC_DUMMY_MAIN
5660 + #ifndef FC_DUMMY_MAIN_EQ_F77
5661 + #  ifdef __cplusplus
5662 +     extern "C"
5663 + #  endif
5664 +   int FC_DUMMY_MAIN() { return 1; }
5665 + #endif
5666 + #endif
5667   int
5668   main ()
5669   {
# Line 5047 | Line 5889 | done
5889   #
5890   # Handle user hints
5891   #
5050 echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5051 echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5892  
5893   # Check whether --with-zlib or --without-zlib was given.
5894   if test "${with_zlib+set}" = set; then
5895    withval="$with_zlib"
5896 <  if test "$withval" != no ; then
5057 <  echo "$as_me:$LINENO: result: yes" >&5
5058 < echo "${ECHO_T}yes" >&6
5059 <  if test -d "$withval"
5060 <  then
5061 <    ZLIB_HOME="$withval"
5062 <  else
5063 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5064 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5065 <  fi
5896 >  zlib_dir="$withval"
5897   else
5898 <  echo "$as_me:$LINENO: result: no" >&5
5068 < echo "${ECHO_T}no" >&6
5069 < fi
5898 >                zlib_dir="not_set"
5899   fi;
5900 + if test "$zlib_dir" != "no"; then
5901  
5902 < ZLIB_HOME=/usr/local
5903 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
5904 < then
5905 <        ZLIB_HOME=/usr
5902 > if test "$zlib_dir" != "not_set" ; then
5903 >  if test -d "$zlib_dir"
5904 >  then
5905 >    ZLIB_HOME="$zlib_dir"
5906 >  else
5907 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5908 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5909 >        ZLIB_HOME=/usr/local
5910 >        if test ! -f "${ZLIB_HOME}/include/zlib.h"
5911 >        then
5912 >                ZLIB_HOME=/usr
5913 >        fi
5914 >  fi
5915   fi
5077
5916   #
5917   # Locate zlib, if wanted
5918   #
5919   if test -n "${ZLIB_HOME}"
5920   then
5921          ZLIB_OLD_LDFLAGS=$LDFLAGS
5922 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5922 >        ZLIB_OLD_CFLAGS=$CFLAGS
5923          LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5924 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5924 >        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
5925  
5926  
5927          ac_ext=c
# Line 5113 | Line 5951 | char inflateEnd ();
5951   /* We use char because int might match the return type of a gcc2
5952     builtin and then its argument prototype would still apply.  */
5953   char inflateEnd ();
5954 + #ifdef FC_DUMMY_MAIN
5955 + #ifndef FC_DUMMY_MAIN_EQ_F77
5956 + #  ifdef __cplusplus
5957 +     extern "C"
5958 + #  endif
5959 +   int FC_DUMMY_MAIN() { return 1; }
5960 + #endif
5961 + #endif
5962   int
5963   main ()
5964   {
# Line 5312 | Line 6158 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
6158   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6159   ac_compiler_gnu=$ac_cv_c_compiler_gnu
6160  
6161 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6162 <        then
5317 <                #
5318 <                # If both library and header were found, use them
5319 <                #
6161 >
6162 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6163  
6164 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6165 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6166 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6164 > cat >>confdefs.h <<\_ACEOF
6165 > #define HAVE_ZLIB_H 1
6166 > _ACEOF
6167 >
6168 >
6169 > cat >>confdefs.h <<\_ACEOF
6170 > #define HAVE_LIBZ 1
6171 > _ACEOF
6172 >
6173 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6174 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6175 >                ZLIB="-lz"
6176 >        else
6177 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6178 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6179 >                ZLIB_INC_DIR=
6180 >                ZLIB_LIB_DIR=
6181 >                ZLIB=
6182 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6183 >                CFLAGS="$ZLIB_OLD_CFLAGS"
6184 >                echo "$as_me:$LINENO: result: failed" >&5
6185 > echo "${ECHO_T}failed" >&6
6186 >                echo ""
6187 >                echo "*********************************************************"
6188 >                echo "* WARNING: Could not find a working zlib installation   *"
6189 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6190 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6191 >                echo "* installation with --with-zlib=DIR                     *"
6192 >                echo "*                                                       *"
6193 >                echo "* OOPSE will still work without zlib installed.         *"
6194 >                echo "*********************************************************"
6195 >                echo ""
6196 >        fi
6197 >
6198 >
6199 >
6200 > fi
6201 > fi
6202 >
6203 > #
6204 > # Handle user hints
6205 > #
6206 >
6207 > # Check whether --with-fftw or --without-fftw was given.
6208 > if test "${with_fftw+set}" = set; then
6209 >  withval="$with_fftw"
6210 >  fftw_dir="$withval"
6211 > else
6212 >             fftw_dir="not_set"
6213 > fi;
6214 > if test "$fftw_dir" != "no"; then
6215 >  if test "$fftw_dir" != "not_set" ; then
6216 >    if test -d "$fftw_dir"; then
6217 >      FFTW_HOME="$fftw_dir"
6218 >    else
6219 >      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6220 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6221 >      FFTW_HOME=/usr/local
6222 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6223 >        FFTW_HOME=/usr
6224 >      fi
6225 >    fi
6226 >    #
6227 >    # Locate fftw, if wanted
6228 >    #
6229 >    if test -n "${FFTW_HOME}"; then
6230 >      FFTW_OLD_LDFLAGS=$LDFLAGS
6231 >      FFTW_OLD_CFLAGS=$CFLAGS
6232 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6233 >      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
6234 >
6235 >
6236 >      ac_ext=c
6237 > ac_cpp='$CPP $CPPFLAGS'
6238 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6239 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6240 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6241 >
6242 >      echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6243 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6244 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6245    echo $ECHO_N "(cached) $ECHO_C" >&6
6246   else
6247    ac_check_lib_save_LIBS=$LIBS
6248 < LIBS="-lz  $LIBS"
6248 > LIBS="-lfftw3  $LIBS"
6249   cat >conftest.$ac_ext <<_ACEOF
6250   /* confdefs.h.  */
6251   _ACEOF
# Line 5338 | Line 6259 | extern "C"
6259   #endif
6260   /* We use char because int might match the return type of a gcc2
6261     builtin and then its argument prototype would still apply.  */
6262 < char inflateEnd ();
6262 > char fftw_execute ();
6263 > #ifdef FC_DUMMY_MAIN
6264 > #ifndef FC_DUMMY_MAIN_EQ_F77
6265 > #  ifdef __cplusplus
6266 >     extern "C"
6267 > #  endif
6268 >   int FC_DUMMY_MAIN() { return 1; }
6269 > #endif
6270 > #endif
6271   int
6272   main ()
6273   {
6274 < inflateEnd ();
6274 > fftw_execute ();
6275    ;
6276    return 0;
6277   }
# Line 5369 | Line 6298 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6298    ac_status=$?
6299    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6300    (exit $ac_status); }; }; then
6301 <  ac_cv_lib_z_inflateEnd=yes
6301 >  ac_cv_lib_fftw3_fftw_execute=yes
6302   else
6303    echo "$as_me: failed program was:" >&5
6304   sed 's/^/| /' conftest.$ac_ext >&5
6305  
6306 < ac_cv_lib_z_inflateEnd=no
6306 > ac_cv_lib_fftw3_fftw_execute=no
6307   fi
6308   rm -f conftest.err conftest.$ac_objext \
6309        conftest$ac_exeext conftest.$ac_ext
6310   LIBS=$ac_check_lib_save_LIBS
6311   fi
6312 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6313 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6314 < if test $ac_cv_lib_z_inflateEnd = yes; then
6315 <  cat >>confdefs.h <<_ACEOF
6316 < #define HAVE_LIBZ 1
6317 < _ACEOF
5389 <
5390 <  LIBS="-lz $LIBS"
5391 <
6312 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6313 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6314 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6315 >  fftw_cv_libfftw3=yes
6316 > else
6317 >  fftw_cv_libfftw3=no
6318   fi
6319  
6320 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6321 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6322 <                echo "$as_me:$LINENO: result: ok" >&5
6323 < echo "${ECHO_T}ok" >&6
5398 <        else
5399 <                #
5400 <                # If either header or library was not found, revert and bomb
5401 <                #
5402 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5403 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5404 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5405 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5406 <                echo "$as_me:$LINENO: result: failed" >&5
5407 < echo "${ECHO_T}failed" >&6
5408 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5409 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5410 <   { (exit 1); exit 1; }; }
5411 <        fi
5412 < fi
5413 <
5414 <
5415 <
5416 <
5417 <
5418 <
5419 <
5420 <
5421 < for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
5422 < do
5423 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5424 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5425 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5426 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5427 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6320 >      if test "${ac_cv_header_fftw3_h+set}" = set; then
6321 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6322 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6323 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6324    echo $ECHO_N "(cached) $ECHO_C" >&6
6325   fi
6326 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6327 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6326 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6327 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6328   else
6329    # Is the header compilable?
6330 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6331 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6330 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6331 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6332   cat >conftest.$ac_ext <<_ACEOF
6333   /* confdefs.h.  */
6334   _ACEOF
# Line 5440 | Line 6336 | $ac_includes_default
6336   cat >>conftest.$ac_ext <<_ACEOF
6337   /* end confdefs.h.  */
6338   $ac_includes_default
6339 < #include <$ac_header>
6339 > #include <fftw3.h>
6340   _ACEOF
6341   rm -f conftest.$ac_objext
6342   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5476 | Line 6372 | echo "${ECHO_T}$ac_header_compiler" >&6
6372   echo "${ECHO_T}$ac_header_compiler" >&6
6373  
6374   # Is the header present?
6375 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6376 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6375 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6376 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6377   cat >conftest.$ac_ext <<_ACEOF
6378   /* confdefs.h.  */
6379   _ACEOF
6380   cat confdefs.h >>conftest.$ac_ext
6381   cat >>conftest.$ac_ext <<_ACEOF
6382   /* end confdefs.h.  */
6383 < #include <$ac_header>
6383 > #include <fftw3.h>
6384   _ACEOF
6385   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6386    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5518 | Line 6414 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
6414   # So?  What about this header?
6415   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6416    yes:no: )
6417 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6418 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6419 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6420 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6417 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6418 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6419 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6420 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6421      ac_header_preproc=yes
6422      ;;
6423    no:yes:* )
6424 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6425 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6426 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6427 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6428 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6429 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6430 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6431 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6432 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6433 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6434 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6435 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6424 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6425 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6426 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6427 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6428 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6429 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6430 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6431 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6432 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6433 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6434 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6435 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6436      (
6437        cat <<\_ASBOX
6438   ## ------------------------------ ##
# Line 5547 | Line 6443 | esac
6443        sed "s/^/$as_me: WARNING:     /" >&2
6444      ;;
6445   esac
6446 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6447 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6448 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6446 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6447 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6448 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6449    echo $ECHO_N "(cached) $ECHO_C" >&6
6450   else
6451 <  eval "$as_ac_Header=\$ac_header_preproc"
6451 >  ac_cv_header_fftw3_h=$ac_header_preproc
6452   fi
6453 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6454 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6453 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6454 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6455  
6456   fi
6457 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6458 <  cat >>confdefs.h <<_ACEOF
6459 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6460 < _ACEOF
5565 <
6457 > if test $ac_cv_header_fftw3_h = yes; then
6458 >  fftw_cv_fftw3_h=yes
6459 > else
6460 >  fftw_cv_fftw3_h=no
6461   fi
6462  
5568 done
6463  
6464 <
6465 <
6464 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6465 >        echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6466 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6467 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6468 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6469 > else
6470 >  ac_check_lib_save_LIBS=$LIBS
6471 > LIBS="-lfftw  $LIBS"
6472 > cat >conftest.$ac_ext <<_ACEOF
6473 > /* confdefs.h.  */
6474 > _ACEOF
6475 > cat confdefs.h >>conftest.$ac_ext
6476 > cat >>conftest.$ac_ext <<_ACEOF
6477 > /* end confdefs.h.  */
6478  
6479 + /* Override any gcc2 internal prototype to avoid an error.  */
6480 + #ifdef __cplusplus
6481 + extern "C"
6482 + #endif
6483 + /* We use char because int might match the return type of a gcc2
6484 +   builtin and then its argument prototype would still apply.  */
6485 + char fftwnd_one ();
6486 + #ifdef FC_DUMMY_MAIN
6487 + #ifndef FC_DUMMY_MAIN_EQ_F77
6488 + #  ifdef __cplusplus
6489 +     extern "C"
6490 + #  endif
6491 +   int FC_DUMMY_MAIN() { return 1; }
6492 + #endif
6493 + #endif
6494 + int
6495 + main ()
6496 + {
6497 + fftwnd_one ();
6498 +  ;
6499 +  return 0;
6500 + }
6501 + _ACEOF
6502 + rm -f conftest.$ac_objext conftest$ac_exeext
6503 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6504 +  (eval $ac_link) 2>conftest.er1
6505 +  ac_status=$?
6506 +  grep -v '^ *+' conftest.er1 >conftest.err
6507 +  rm -f conftest.er1
6508 +  cat conftest.err >&5
6509 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6510 +  (exit $ac_status); } &&
6511 +         { ac_try='test -z "$ac_c_werror_flag"
6512 +                         || test ! -s conftest.err'
6513 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6514 +  (eval $ac_try) 2>&5
6515 +  ac_status=$?
6516 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6517 +  (exit $ac_status); }; } &&
6518 +         { ac_try='test -s conftest$ac_exeext'
6519 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6520 +  (eval $ac_try) 2>&5
6521 +  ac_status=$?
6522 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6523 +  (exit $ac_status); }; }; then
6524 +  ac_cv_lib_fftw_fftwnd_one=yes
6525 + else
6526 +  echo "$as_me: failed program was:" >&5
6527 + sed 's/^/| /' conftest.$ac_ext >&5
6528  
6529 + ac_cv_lib_fftw_fftwnd_one=no
6530 + fi
6531 + rm -f conftest.err conftest.$ac_objext \
6532 +      conftest$ac_exeext conftest.$ac_ext
6533 + LIBS=$ac_check_lib_save_LIBS
6534 + fi
6535 + echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6536 + echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6537 + if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6538 +  fftw_cv_libfftw=yes
6539 + else
6540 +  fftw_cv_libfftw=no
6541 + fi
6542  
6543 < for ac_header in strstream.h iostream.h fstream.h math.h time.h
6544 < do
6545 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6546 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5579 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5580 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5581 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6543 >        if test "${ac_cv_header_fftw_h+set}" = set; then
6544 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6545 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6546 > if test "${ac_cv_header_fftw_h+set}" = set; then
6547    echo $ECHO_N "(cached) $ECHO_C" >&6
6548   fi
6549 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6550 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6549 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6550 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6551   else
6552    # Is the header compilable?
6553 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6554 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6553 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6554 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6555   cat >conftest.$ac_ext <<_ACEOF
6556   /* confdefs.h.  */
6557   _ACEOF
# Line 5594 | Line 6559 | $ac_includes_default
6559   cat >>conftest.$ac_ext <<_ACEOF
6560   /* end confdefs.h.  */
6561   $ac_includes_default
6562 < #include <$ac_header>
6562 > #include <fftw.h>
6563   _ACEOF
6564   rm -f conftest.$ac_objext
6565   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5630 | Line 6595 | echo "${ECHO_T}$ac_header_compiler" >&6
6595   echo "${ECHO_T}$ac_header_compiler" >&6
6596  
6597   # Is the header present?
6598 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6599 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6598 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6599 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6600   cat >conftest.$ac_ext <<_ACEOF
6601   /* confdefs.h.  */
6602   _ACEOF
6603   cat confdefs.h >>conftest.$ac_ext
6604   cat >>conftest.$ac_ext <<_ACEOF
6605   /* end confdefs.h.  */
6606 < #include <$ac_header>
6606 > #include <fftw.h>
6607   _ACEOF
6608   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6609    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5672 | Line 6637 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
6637   # So?  What about this header?
6638   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6639    yes:no: )
6640 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6641 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6642 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6643 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6640 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6641 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6642 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6643 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6644      ac_header_preproc=yes
6645      ;;
6646    no:yes:* )
6647 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6648 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6649 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6650 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6651 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6652 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6653 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6654 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6655 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6656 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6657 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6658 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6647 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6648 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6649 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6650 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6651 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6652 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6653 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6654 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6655 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6656 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6657 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6658 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6659      (
6660        cat <<\_ASBOX
6661   ## ------------------------------ ##
# Line 5701 | Line 6666 | esac
6666        sed "s/^/$as_me: WARNING:     /" >&2
6667      ;;
6668   esac
6669 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6670 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6671 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6669 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6670 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6671 > if test "${ac_cv_header_fftw_h+set}" = set; then
6672    echo $ECHO_N "(cached) $ECHO_C" >&6
6673   else
6674 <  eval "$as_ac_Header=\$ac_header_preproc"
6674 >  ac_cv_header_fftw_h=$ac_header_preproc
6675   fi
6676 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6677 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6676 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6677 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6678  
6679   fi
6680 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6681 <  cat >>confdefs.h <<_ACEOF
6682 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6683 < _ACEOF
5719 <
6680 > if test $ac_cv_header_fftw_h = yes; then
6681 >  fftw_cv_fftw_h=yes
6682 > else
6683 >  fftw_cv_fftw_h=no
6684   fi
6685  
5722 done
6686  
6687 < ac_ext=cc
6688 < ac_cpp='$CXXCPP $CPPFLAGS'
6689 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6690 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5728 < 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
5735 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
5736 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
5737 < if test -z "$CXXCPP"; then
5738 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
6687 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6688 >          echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6689 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6690 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6691    echo $ECHO_N "(cached) $ECHO_C" >&6
6692   else
6693 <      # Double quotes because CXXCPP needs to be expanded
6694 <    for CXXCPP in "$CXX -E" "/lib/cpp"
6695 <    do
5744 <      ac_preproc_ok=false
5745 < for ac_cxx_preproc_warn_flag in '' yes
5746 < do
5747 <  # Use a header file that comes with gcc, so configuring glibc
5748 <  # with a fresh cross-compiler works.
5749 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5750 <  # <limits.h> exists even on freestanding compilers.
5751 <  # On the NeXT, cc -E runs the code through the compiler's parser,
5752 <  # not just through cpp. "Syntax error" is here to catch this case.
5753 <  cat >conftest.$ac_ext <<_ACEOF
6693 >  ac_check_lib_save_LIBS=$LIBS
6694 > LIBS="-ldfftw  $LIBS"
6695 > cat >conftest.$ac_ext <<_ACEOF
6696   /* confdefs.h.  */
6697   _ACEOF
6698   cat confdefs.h >>conftest.$ac_ext
6699   cat >>conftest.$ac_ext <<_ACEOF
6700   /* end confdefs.h.  */
6701 < #ifdef __STDC__
6702 < # include <limits.h>
6703 < #else
6704 < # include <assert.h>
6701 >
6702 > /* Override any gcc2 internal prototype to avoid an error.  */
6703 > #ifdef __cplusplus
6704 > extern "C"
6705   #endif
6706 <                     Syntax error
6706 > /* We use char because int might match the return type of a gcc2
6707 >   builtin and then its argument prototype would still apply.  */
6708 > char fftwnd_one ();
6709 > #ifdef FC_DUMMY_MAIN
6710 > #ifndef FC_DUMMY_MAIN_EQ_F77
6711 > #  ifdef __cplusplus
6712 >     extern "C"
6713 > #  endif
6714 >   int FC_DUMMY_MAIN() { return 1; }
6715 > #endif
6716 > #endif
6717 > int
6718 > main ()
6719 > {
6720 > fftwnd_one ();
6721 >  ;
6722 >  return 0;
6723 > }
6724   _ACEOF
6725 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6726 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6725 > rm -f conftest.$ac_objext conftest$ac_exeext
6726 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6727 >  (eval $ac_link) 2>conftest.er1
6728    ac_status=$?
6729    grep -v '^ *+' conftest.er1 >conftest.err
6730    rm -f conftest.er1
6731    cat conftest.err >&5
6732    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733 <  (exit $ac_status); } >/dev/null; then
6734 <  if test -s conftest.err; then
6735 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6736 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6737 <  else
6738 <    ac_cpp_err=
5779 <  fi
5780 < else
5781 <  ac_cpp_err=yes
5782 < fi
5783 < if test -z "$ac_cpp_err"; then
5784 <  :
5785 < else
5786 <  echo "$as_me: failed program was:" >&5
5787 < sed 's/^/| /' conftest.$ac_ext >&5
5788 <
5789 <  # Broken: fails on valid input.
5790 < continue
5791 < fi
5792 < rm -f conftest.err conftest.$ac_ext
5793 <
5794 <  # OK, works on sane cases.  Now check whether non-existent headers
5795 <  # can be detected and how.
5796 <  cat >conftest.$ac_ext <<_ACEOF
5797 < /* confdefs.h.  */
5798 < _ACEOF
5799 < cat confdefs.h >>conftest.$ac_ext
5800 < cat >>conftest.$ac_ext <<_ACEOF
5801 < /* end confdefs.h.  */
5802 < #include <ac_nonexistent.h>
5803 < _ACEOF
5804 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5805 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5806 <  ac_status=$?
5807 <  grep -v '^ *+' conftest.er1 >conftest.err
5808 <  rm -f conftest.er1
5809 <  cat conftest.err >&5
6733 >  (exit $ac_status); } &&
6734 >         { ac_try='test -z "$ac_c_werror_flag"
6735 >                         || test ! -s conftest.err'
6736 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737 >  (eval $ac_try) 2>&5
6738 >  ac_status=$?
6739    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740 <  (exit $ac_status); } >/dev/null; then
6741 <  if test -s conftest.err; then
6742 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6743 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5815 <  else
5816 <    ac_cpp_err=
5817 <  fi
5818 < else
5819 <  ac_cpp_err=yes
5820 < fi
5821 < if test -z "$ac_cpp_err"; then
5822 <  # Broken: success on invalid input.
5823 < continue
5824 < else
5825 <  echo "$as_me: failed program was:" >&5
5826 < sed 's/^/| /' conftest.$ac_ext >&5
5827 <
5828 <  # Passes both tests.
5829 < ac_preproc_ok=:
5830 < break
5831 < fi
5832 < rm -f conftest.err conftest.$ac_ext
5833 <
5834 < done
5835 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5836 < rm -f conftest.err conftest.$ac_ext
5837 < if $ac_preproc_ok; then
5838 <  break
5839 < fi
5840 <
5841 <    done
5842 <    ac_cv_prog_CXXCPP=$CXXCPP
5843 <
5844 < fi
5845 <  CXXCPP=$ac_cv_prog_CXXCPP
5846 < else
5847 <  ac_cv_prog_CXXCPP=$CXXCPP
5848 < fi
5849 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
5850 < echo "${ECHO_T}$CXXCPP" >&6
5851 < ac_preproc_ok=false
5852 < for ac_cxx_preproc_warn_flag in '' yes
5853 < do
5854 <  # Use a header file that comes with gcc, so configuring glibc
5855 <  # with a fresh cross-compiler works.
5856 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5857 <  # <limits.h> exists even on freestanding compilers.
5858 <  # On the NeXT, cc -E runs the code through the compiler's parser,
5859 <  # not just through cpp. "Syntax error" is here to catch this case.
5860 <  cat >conftest.$ac_ext <<_ACEOF
5861 < /* confdefs.h.  */
5862 < _ACEOF
5863 < cat confdefs.h >>conftest.$ac_ext
5864 < cat >>conftest.$ac_ext <<_ACEOF
5865 < /* end confdefs.h.  */
5866 < #ifdef __STDC__
5867 < # include <limits.h>
5868 < #else
5869 < # include <assert.h>
5870 < #endif
5871 <                     Syntax error
5872 < _ACEOF
5873 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5874 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6740 >  (exit $ac_status); }; } &&
6741 >         { ac_try='test -s conftest$ac_exeext'
6742 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743 >  (eval $ac_try) 2>&5
6744    ac_status=$?
5876  grep -v '^ *+' conftest.er1 >conftest.err
5877  rm -f conftest.er1
5878  cat conftest.err >&5
6745    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746 <  (exit $ac_status); } >/dev/null; then
6747 <  if test -s conftest.err; then
5882 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5883 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5884 <  else
5885 <    ac_cpp_err=
5886 <  fi
6746 >  (exit $ac_status); }; }; then
6747 >  ac_cv_lib_dfftw_fftwnd_one=yes
6748   else
5888  ac_cpp_err=yes
5889 fi
5890 if test -z "$ac_cpp_err"; then
5891  :
5892 else
6749    echo "$as_me: failed program was:" >&5
6750   sed 's/^/| /' conftest.$ac_ext >&5
6751  
6752 <  # Broken: fails on valid input.
5897 < continue
6752 > ac_cv_lib_dfftw_fftwnd_one=no
6753   fi
6754 < rm -f conftest.err conftest.$ac_ext
6755 <
6756 <  # OK, works on sane cases.  Now check whether non-existent headers
5902 <  # can be detected and how.
5903 <  cat >conftest.$ac_ext <<_ACEOF
5904 < /* confdefs.h.  */
5905 < _ACEOF
5906 < cat confdefs.h >>conftest.$ac_ext
5907 < cat >>conftest.$ac_ext <<_ACEOF
5908 < /* end confdefs.h.  */
5909 < #include <ac_nonexistent.h>
5910 < _ACEOF
5911 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5912 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5913 <  ac_status=$?
5914 <  grep -v '^ *+' conftest.er1 >conftest.err
5915 <  rm -f conftest.er1
5916 <  cat conftest.err >&5
5917 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5918 <  (exit $ac_status); } >/dev/null; then
5919 <  if test -s conftest.err; then
5920 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5921 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5922 <  else
5923 <    ac_cpp_err=
5924 <  fi
5925 < else
5926 <  ac_cpp_err=yes
6754 > rm -f conftest.err conftest.$ac_objext \
6755 >      conftest$ac_exeext conftest.$ac_ext
6756 > LIBS=$ac_check_lib_save_LIBS
6757   fi
6758 < if test -z "$ac_cpp_err"; then
6759 <  # Broken: success on invalid input.
6760 < continue
6758 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6759 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6760 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6761 >  fftw_cv_libdfftw=yes
6762   else
6763 <  echo "$as_me: failed program was:" >&5
5933 < sed 's/^/| /' conftest.$ac_ext >&5
5934 <
5935 <  # Passes both tests.
5936 < ac_preproc_ok=:
5937 < break
6763 >  fftw_cv_libdfftw=no
6764   fi
5939 rm -f conftest.err conftest.$ac_ext
6765  
6766 < done
6767 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
6768 < rm -f conftest.err conftest.$ac_ext
6769 < if $ac_preproc_ok; then
5945 <  :
5946 < else
5947 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
5948 < See \`config.log' for more details." >&5
5949 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
5950 < See \`config.log' for more details." >&2;}
5951 <   { (exit 1); exit 1; }; }
5952 < fi
5953 <
5954 < ac_ext=cc
5955 < ac_cpp='$CXXCPP $CPPFLAGS'
5956 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5957 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5958 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5959 <
5960 <
5961 <
5962 <
5963 <
5964 <
5965 <
5966 < for ac_header in ctype.h iostream fstream sstream strstream
5967 < do
5968 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5969 < 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
6766 >          if test "${ac_cv_header_dfftw_h+set}" = set; then
6767 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6768 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6769 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6770    echo $ECHO_N "(cached) $ECHO_C" >&6
6771   fi
6772 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6773 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6772 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6773 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6774   else
6775    # Is the header compilable?
6776 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6777 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6776 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6777 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6778   cat >conftest.$ac_ext <<_ACEOF
6779   /* confdefs.h.  */
6780   _ACEOF
# Line 5985 | Line 6782 | $ac_includes_default
6782   cat >>conftest.$ac_ext <<_ACEOF
6783   /* end confdefs.h.  */
6784   $ac_includes_default
6785 < #include <$ac_header>
6785 > #include <dfftw.h>
6786   _ACEOF
6787   rm -f conftest.$ac_objext
6788   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5996 | Line 6793 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6793    cat conftest.err >&5
6794    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6795    (exit $ac_status); } &&
6796 <         { ac_try='test -z "$ac_cxx_werror_flag"
6796 >         { ac_try='test -z "$ac_c_werror_flag"
6797                           || test ! -s conftest.err'
6798    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6799    (eval $ac_try) 2>&5
# Line 6021 | Line 6818 | echo "${ECHO_T}$ac_header_compiler" >&6
6818   echo "${ECHO_T}$ac_header_compiler" >&6
6819  
6820   # Is the header present?
6821 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6822 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6821 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6822 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6823   cat >conftest.$ac_ext <<_ACEOF
6824   /* confdefs.h.  */
6825   _ACEOF
6826   cat confdefs.h >>conftest.$ac_ext
6827   cat >>conftest.$ac_ext <<_ACEOF
6828   /* end confdefs.h.  */
6829 < #include <$ac_header>
6829 > #include <dfftw.h>
6830   _ACEOF
6831   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6832    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6040 | Line 6837 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
6837    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6838    (exit $ac_status); } >/dev/null; then
6839    if test -s conftest.err; then
6840 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
6841 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6840 >    ac_cpp_err=$ac_c_preproc_warn_flag
6841 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6842    else
6843      ac_cpp_err=
6844    fi
# Line 6061 | Line 6858 | echo "${ECHO_T}$ac_header_preproc" >&6
6858   echo "${ECHO_T}$ac_header_preproc" >&6
6859  
6860   # So?  What about this header?
6861 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6861 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6862    yes:no: )
6863 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6864 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6865 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6866 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6863 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6864 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6865 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6866 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6867      ac_header_preproc=yes
6868      ;;
6869    no:yes:* )
6870 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6871 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6872 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6873 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6874 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6875 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6876 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6877 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6878 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6879 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6880 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6881 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6870 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6871 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6872 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6873 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6874 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6875 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6876 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6877 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6878 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6879 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6880 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6881 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6882      (
6883        cat <<\_ASBOX
6884   ## ------------------------------ ##
# Line 6092 | Line 6889 | esac
6889        sed "s/^/$as_me: WARNING:     /" >&2
6890      ;;
6891   esac
6892 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6893 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6894 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6892 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6893 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6894 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6895    echo $ECHO_N "(cached) $ECHO_C" >&6
6896   else
6897 <  eval "$as_ac_Header=\$ac_header_preproc"
6897 >  ac_cv_header_dfftw_h=$ac_header_preproc
6898   fi
6899 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6900 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6899 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6900 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6901  
6902   fi
6903 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6904 <  cat >>confdefs.h <<_ACEOF
6905 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6903 > if test $ac_cv_header_dfftw_h = yes; then
6904 >  fftw_cv_dfftw_h=yes
6905 > else
6906 >  fftw_cv_dfftw_h=no
6907 > fi
6908 >
6909 >
6910 >        fi
6911 >      fi
6912 >      ac_ext=c
6913 > ac_cpp='$CPP $CPPFLAGS'
6914 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6915 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6916 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6917 >
6918 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6919 >
6920 > cat >>confdefs.h <<\_ACEOF
6921 > #define HAVE_FFTW3_H 1
6922   _ACEOF
6923  
6924 +        FFTW_INC_DIR="${FFTW_HOME}/include"
6925 +        FFTW_LIB_DIR="${FFTW_HOME}/lib"
6926 +        FFTW_LIBS="-lfftw3"
6927 +      else
6928 +        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6929 +
6930 + cat >>confdefs.h <<\_ACEOF
6931 + #define HAVE_FFTW_H 1
6932 + _ACEOF
6933 +
6934 +          FFTW_INC_DIR="${FFTW_HOME}/include"
6935 +          FFTW_LIB_DIR="${FFTW_HOME}/lib"
6936 +          FFTW_LIBS="-lfftw"
6937 +        else
6938 +          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6939 +
6940 + cat >>confdefs.h <<\_ACEOF
6941 + #define HAVE_DFFTW_H 1
6942 + _ACEOF
6943 +
6944 +            FFTW_INC_DIR="${FFTW_HOME}/include"
6945 +            FFTW_LIB_DIR="${FFTW_HOME}/lib"
6946 +            FFTW_LIBS="-ldfftw"
6947 +          else
6948 +            echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6949 + echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6950 +            FFTW_INC_DIR=
6951 +            FFTW_LIB_DIR=
6952 +            FFTW_LIBS=
6953 +            LDFLAGS="$FFTW_OLD_LDFLAGS"
6954 +            CFLAGS="$FFTW_OLD_CFLAGS"
6955 +            echo "$as_me:$LINENO: result: failed" >&5
6956 + echo "${ECHO_T}failed" >&6
6957 +            echo ""
6958 +            echo "*********************************************************"
6959 +            echo "* WARNING: Could not find a working FFTW installation   *"
6960 +            echo "* If you need the staticProps program to be able to     *"
6961 +            echo "* compute undulation spectra, be sure to specify a      *"
6962 +            echo "* valid fftw installation with --with-fftw=DIR          *"
6963 +            echo "*                                                       *"
6964 +            echo "* OOPSE will still work without fftw installed.         *"
6965 +            echo "*********************************************************"
6966 +            echo ""
6967 +          fi
6968 +        fi
6969 +      fi
6970 +
6971 +
6972 +
6973 +    fi
6974 +  fi
6975   fi
6976  
6977 < done
6977 > #
6978 > # Handle user hints
6979 > #
6980  
6981 < ac_ext=c
6981 > # Check whether --with-qhull or --without-qhull was given.
6982 > if test "${with_qhull+set}" = set; then
6983 >  withval="$with_qhull"
6984 >  qhull_dir="$withval"
6985 > else
6986 >                qhull_dir="not_set"
6987 > fi;
6988 > if test "$qhull_dir" != "no"; then
6989 >
6990 > if test "$qhull_dir" != "not_set" ; then
6991 >  if test -d "$qhull_dir"
6992 >  then
6993 >    QHULL_HOME="$qhull_dir"
6994 >  else
6995 >    { echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
6996 > echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
6997 >        QHULL_HOME=/usr/local
6998 >        if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"
6999 >        then
7000 >                QHULL_HOME=/usr
7001 >        fi
7002 >  fi
7003 > fi
7004 > #
7005 > # Locate qhull, if wanted
7006 > #
7007 > if test -n "${QHULL_HOME}"
7008 > then
7009 >        QHULL_OLD_LDFLAGS=$LDFLAGS
7010 >        QHULL_OLD_CFLAGS=$CFLAGS
7011 >        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
7012 >        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
7013 >
7014 >
7015 >        ac_ext=c
7016   ac_cpp='$CPP $CPPFLAGS'
7017   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7018   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7019   ac_compiler_gnu=$ac_cv_c_compiler_gnu
7020  
7021 +        echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
7022 + echo $ECHO_N "checking for qh_qhull in -lqhull... $ECHO_C" >&6
7023 + if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
7024 +  echo $ECHO_N "(cached) $ECHO_C" >&6
7025 + else
7026 +  ac_check_lib_save_LIBS=$LIBS
7027 + LIBS="-lqhull  $LIBS"
7028 + cat >conftest.$ac_ext <<_ACEOF
7029 + /* confdefs.h.  */
7030 + _ACEOF
7031 + cat confdefs.h >>conftest.$ac_ext
7032 + cat >>conftest.$ac_ext <<_ACEOF
7033 + /* end confdefs.h.  */
7034  
7035 + /* Override any gcc2 internal prototype to avoid an error.  */
7036 + #ifdef __cplusplus
7037 + extern "C"
7038 + #endif
7039 + /* We use char because int might match the return type of a gcc2
7040 +   builtin and then its argument prototype would still apply.  */
7041 + char qh_qhull ();
7042 + #ifdef FC_DUMMY_MAIN
7043 + #ifndef FC_DUMMY_MAIN_EQ_F77
7044 + #  ifdef __cplusplus
7045 +     extern "C"
7046 + #  endif
7047 +   int FC_DUMMY_MAIN() { return 1; }
7048 + #endif
7049 + #endif
7050 + int
7051 + main ()
7052 + {
7053 + qh_qhull ();
7054 +  ;
7055 +  return 0;
7056 + }
7057 + _ACEOF
7058 + rm -f conftest.$ac_objext conftest$ac_exeext
7059 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7060 +  (eval $ac_link) 2>conftest.er1
7061 +  ac_status=$?
7062 +  grep -v '^ *+' conftest.er1 >conftest.err
7063 +  rm -f conftest.er1
7064 +  cat conftest.err >&5
7065 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7066 +  (exit $ac_status); } &&
7067 +         { ac_try='test -z "$ac_c_werror_flag"
7068 +                         || test ! -s conftest.err'
7069 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7070 +  (eval $ac_try) 2>&5
7071 +  ac_status=$?
7072 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7073 +  (exit $ac_status); }; } &&
7074 +         { ac_try='test -s conftest$ac_exeext'
7075 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7076 +  (eval $ac_try) 2>&5
7077 +  ac_status=$?
7078 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7079 +  (exit $ac_status); }; }; then
7080 +  ac_cv_lib_qhull_qh_qhull=yes
7081 + else
7082 +  echo "$as_me: failed program was:" >&5
7083 + sed 's/^/| /' conftest.$ac_ext >&5
7084  
7085 + ac_cv_lib_qhull_qh_qhull=no
7086 + fi
7087 + rm -f conftest.err conftest.$ac_objext \
7088 +      conftest$ac_exeext conftest.$ac_ext
7089 + LIBS=$ac_check_lib_save_LIBS
7090 + fi
7091 + echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
7092 + echo "${ECHO_T}$ac_cv_lib_qhull_qh_qhull" >&6
7093 + if test $ac_cv_lib_qhull_qh_qhull = yes; then
7094 +  qhull_cv_libqhull=yes
7095 + else
7096 +  qhull_cv_libqhull=no
7097 + fi
7098  
7099 < for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
7100 < do
7101 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7102 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6128 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6129 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6130 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
7099 >        if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
7100 >  echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
7101 > echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6
7102 > if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
7103    echo $ECHO_N "(cached) $ECHO_C" >&6
7104   fi
7105 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7106 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7105 > echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
7106 > echo "${ECHO_T}$ac_cv_header_qhull_qhull_h" >&6
7107   else
7108    # Is the header compilable?
7109 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
7110 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7109 > echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
7110 > echo $ECHO_N "checking qhull/qhull.h usability... $ECHO_C" >&6
7111   cat >conftest.$ac_ext <<_ACEOF
7112   /* confdefs.h.  */
7113   _ACEOF
# Line 6143 | Line 7115 | $ac_includes_default
7115   cat >>conftest.$ac_ext <<_ACEOF
7116   /* end confdefs.h.  */
7117   $ac_includes_default
7118 < #include <$ac_header>
7118 > #include <qhull/qhull.h>
7119   _ACEOF
7120   rm -f conftest.$ac_objext
7121   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6179 | Line 7151 | echo "${ECHO_T}$ac_header_compiler" >&6
7151   echo "${ECHO_T}$ac_header_compiler" >&6
7152  
7153   # Is the header present?
7154 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
7155 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7154 > echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
7155 > echo $ECHO_N "checking qhull/qhull.h presence... $ECHO_C" >&6
7156   cat >conftest.$ac_ext <<_ACEOF
7157   /* confdefs.h.  */
7158   _ACEOF
7159   cat confdefs.h >>conftest.$ac_ext
7160   cat >>conftest.$ac_ext <<_ACEOF
7161   /* end confdefs.h.  */
7162 < #include <$ac_header>
7162 > #include <qhull/qhull.h>
7163   _ACEOF
7164   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7165    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6221 | Line 7193 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
7193   # So?  What about this header?
7194   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7195    yes:no: )
7196 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7197 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7198 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7199 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7196 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
7197 > echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7198 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
7199 > echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
7200      ac_header_preproc=yes
7201      ;;
7202    no:yes:* )
7203 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7204 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7205 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7206 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7207 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7208 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7209 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7210 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7211 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7212 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7213 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7214 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7203 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
7204 > echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
7205 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&5
7206 > echo "$as_me: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&2;}
7207 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
7208 > echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
7209 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&5
7210 > echo "$as_me: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7211 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
7212 > echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
7213 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
7214 > echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
7215      (
7216        cat <<\_ASBOX
7217   ## ------------------------------ ##
# Line 6250 | Line 7222 | esac
7222        sed "s/^/$as_me: WARNING:     /" >&2
7223      ;;
7224   esac
7225 < echo "$as_me:$LINENO: checking for $ac_header" >&5
7226 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7227 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
7225 > echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
7226 > echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6
7227 > if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
7228    echo $ECHO_N "(cached) $ECHO_C" >&6
7229   else
7230 <  eval "$as_ac_Header=\$ac_header_preproc"
7230 >  ac_cv_header_qhull_qhull_h=$ac_header_preproc
7231   fi
7232 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7233 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7232 > echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
7233 > echo "${ECHO_T}$ac_cv_header_qhull_qhull_h" >&6
7234  
7235   fi
7236 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
7237 <  cat >>confdefs.h <<_ACEOF
7238 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7236 > if test $ac_cv_header_qhull_qhull_h = yes; then
7237 >  qhull_cv_qhull_h=yes
7238 > else
7239 >  qhull_cv_qhull_h=no
7240 > fi
7241 >
7242 >
7243 >        ac_ext=c
7244 > ac_cpp='$CPP $CPPFLAGS'
7245 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7246 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7247 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
7248 >
7249 >
7250 >        if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
7251 >
7252 > cat >>confdefs.h <<\_ACEOF
7253 > #define HAVE_QHULL_H 1
7254   _ACEOF
7255  
6269 fi
7256  
7257 < done
7257 > cat >>confdefs.h <<\_ACEOF
7258 > #define HAVE_QHULL 1
7259 > _ACEOF
7260  
7261 +                QHULL_INC_DIR="${QHULL_HOME}/include"
7262 +                QHULL_LIB_DIR="${QHULL_HOME}/lib"
7263 +                QHULL="-lqhull"
7264 +        else
7265 +                echo "$as_me:$LINENO: checking qhull in ${QHULL_HOME}" >&5
7266 + echo $ECHO_N "checking qhull in ${QHULL_HOME}... $ECHO_C" >&6
7267 +                QHULL_INC_DIR=
7268 +                QHULL_LIB_DIR=
7269 +                QHULL=
7270 +                LDFLAGS="$QHULL_OLD_LDFLAGS"
7271 +                CFLAGS="$QHULL_OLD_CFLAGS"
7272 +                echo "$as_me:$LINENO: result: failed" >&5
7273 + echo "${ECHO_T}failed" >&6
7274 +                echo ""
7275 +                echo "*********************************************************"
7276 +                echo "* WARNING: Could not find a working qhull installation  *"
7277 +                echo "* If you need OOPSE to be able to deal with convex      *"
7278 +                echo "* hulls be sure to specify a valid qhull installation   *"
7279 +                echo "* with --with-qhull=DIR                                 *"
7280 +                echo "*                                                       *"
7281 +                echo "* OOPSE will still work without qhull installed.        *"
7282 +                echo "*********************************************************"
7283 +                echo ""
7284 +        fi
7285  
7286  
7287  
7288 + fi
7289 + fi
7290  
7291 < for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
7292 < do
7293 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7294 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
7295 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6282 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6283 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
7291 >
7292 > # Checks for header files.
7293 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7294 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7295 > if test "${ac_cv_header_stdc+set}" = set; then
7296    echo $ECHO_N "(cached) $ECHO_C" >&6
6285 fi
6286 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6287 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7297   else
7298 <  # Is the header compilable?
6290 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6291 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6292 < cat >conftest.$ac_ext <<_ACEOF
7298 >  cat >conftest.$ac_ext <<_ACEOF
7299   /* confdefs.h.  */
7300   _ACEOF
7301   cat confdefs.h >>conftest.$ac_ext
7302   cat >>conftest.$ac_ext <<_ACEOF
7303   /* end confdefs.h.  */
7304 < $ac_includes_default
7305 < #include <$ac_header>
7304 > #include <stdlib.h>
7305 > #include <stdarg.h>
7306 > #include <string.h>
7307 > #include <float.h>
7308 >
7309 > #ifdef FC_DUMMY_MAIN
7310 > #ifndef FC_DUMMY_MAIN_EQ_F77
7311 > #  ifdef __cplusplus
7312 >     extern "C"
7313 > #  endif
7314 >   int FC_DUMMY_MAIN() { return 1; }
7315 > #endif
7316 > #endif
7317 > int
7318 > main ()
7319 > {
7320 >
7321 >  ;
7322 >  return 0;
7323 > }
7324   _ACEOF
7325   rm -f conftest.$ac_objext
7326   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6320 | Line 7344 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7344    ac_status=$?
7345    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7346    (exit $ac_status); }; }; then
7347 <  ac_header_compiler=yes
7347 >  ac_cv_header_stdc=yes
7348   else
7349    echo "$as_me: failed program was:" >&5
7350   sed 's/^/| /' conftest.$ac_ext >&5
7351  
7352 < ac_header_compiler=no
7352 > ac_cv_header_stdc=no
7353   fi
7354   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6331 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6332 echo "${ECHO_T}$ac_header_compiler" >&6
7355  
7356 < # Is the header present?
7357 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
7358 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6337 < cat >conftest.$ac_ext <<_ACEOF
7356 > if test $ac_cv_header_stdc = yes; then
7357 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7358 >  cat >conftest.$ac_ext <<_ACEOF
7359   /* confdefs.h.  */
7360   _ACEOF
7361   cat confdefs.h >>conftest.$ac_ext
7362   cat >>conftest.$ac_ext <<_ACEOF
7363   /* end confdefs.h.  */
7364 < #include <$ac_header>
7364 > #include <string.h>
7365 >
7366   _ACEOF
7367 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7368 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7369 <  ac_status=$?
6348 <  grep -v '^ *+' conftest.er1 >conftest.err
6349 <  rm -f conftest.er1
6350 <  cat conftest.err >&5
6351 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6352 <  (exit $ac_status); } >/dev/null; then
6353 <  if test -s conftest.err; then
6354 <    ac_cpp_err=$ac_c_preproc_warn_flag
6355 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6356 <  else
6357 <    ac_cpp_err=
6358 <  fi
7367 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7368 >  $EGREP "memchr" >/dev/null 2>&1; then
7369 >  :
7370   else
7371 <  ac_cpp_err=yes
7371 >  ac_cv_header_stdc=no
7372   fi
7373 < if test -z "$ac_cpp_err"; then
6363 <  ac_header_preproc=yes
6364 < else
6365 <  echo "$as_me: failed program was:" >&5
6366 < sed 's/^/| /' conftest.$ac_ext >&5
7373 > rm -f conftest*
7374  
6368  ac_header_preproc=no
7375   fi
6370 rm -f conftest.err conftest.$ac_ext
6371 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6372 echo "${ECHO_T}$ac_header_preproc" >&6
7376  
7377 < # So?  What about this header?
7378 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7379 <  yes:no: )
7380 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7381 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7382 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7383 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7384 <    ac_header_preproc=yes
7385 <    ;;
7386 <  no:yes:* )
7387 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7388 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7389 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7390 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6388 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6389 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6390 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6391 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6392 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6393 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6394 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6395 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6396 <    (
6397 <      cat <<\_ASBOX
6398 < ## ------------------------------ ##
6399 < ## Report this to gezelter@nd.edu ##
6400 < ## ------------------------------ ##
6401 < _ASBOX
6402 <    ) |
6403 <      sed "s/^/$as_me: WARNING:     /" >&2
6404 <    ;;
6405 < esac
6406 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6407 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6408 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6409 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7377 > if test $ac_cv_header_stdc = yes; then
7378 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7379 >  cat >conftest.$ac_ext <<_ACEOF
7380 > /* confdefs.h.  */
7381 > _ACEOF
7382 > cat confdefs.h >>conftest.$ac_ext
7383 > cat >>conftest.$ac_ext <<_ACEOF
7384 > /* end confdefs.h.  */
7385 > #include <stdlib.h>
7386 >
7387 > _ACEOF
7388 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7389 >  $EGREP "free" >/dev/null 2>&1; then
7390 >  :
7391   else
7392 <  eval "$as_ac_Header=\$ac_header_preproc"
7392 >  ac_cv_header_stdc=no
7393   fi
7394 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6414 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7394 > rm -f conftest*
7395  
7396   fi
7397 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
7398 <  cat >>confdefs.h <<_ACEOF
7399 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7397 >
7398 > if test $ac_cv_header_stdc = yes; then
7399 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7400 >  if test "$cross_compiling" = yes; then
7401 >  :
7402 > else
7403 >  cat >conftest.$ac_ext <<_ACEOF
7404 > /* confdefs.h.  */
7405   _ACEOF
7406 + cat confdefs.h >>conftest.$ac_ext
7407 + cat >>conftest.$ac_ext <<_ACEOF
7408 + /* end confdefs.h.  */
7409 + #include <ctype.h>
7410 + #if ((' ' & 0x0FF) == 0x020)
7411 + # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7412 + # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7413 + #else
7414 + # define ISLOWER(c) \
7415 +                   (('a' <= (c) && (c) <= 'i') \
7416 +                     || ('j' <= (c) && (c) <= 'r') \
7417 +                     || ('s' <= (c) && (c) <= 'z'))
7418 + # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7419 + #endif
7420  
7421 + #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7422 + int
7423 + main ()
7424 + {
7425 +  int i;
7426 +  for (i = 0; i < 256; i++)
7427 +    if (XOR (islower (i), ISLOWER (i))
7428 +        || toupper (i) != TOUPPER (i))
7429 +      exit(2);
7430 +  exit (0);
7431 + }
7432 + _ACEOF
7433 + rm -f conftest$ac_exeext
7434 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7435 +  (eval $ac_link) 2>&5
7436 +  ac_status=$?
7437 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7438 +  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7439 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7440 +  (eval $ac_try) 2>&5
7441 +  ac_status=$?
7442 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7443 +  (exit $ac_status); }; }; then
7444 +  :
7445 + else
7446 +  echo "$as_me: program exited with status $ac_status" >&5
7447 + echo "$as_me: failed program was:" >&5
7448 + sed 's/^/| /' conftest.$ac_ext >&5
7449 +
7450 + ( exit $ac_status )
7451 + ac_cv_header_stdc=no
7452   fi
7453 + rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7454 + fi
7455 + fi
7456 + fi
7457 + echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7458 + echo "${ECHO_T}$ac_cv_header_stdc" >&6
7459 + if test $ac_cv_header_stdc = yes; then
7460  
7461 < done
7461 > cat >>confdefs.h <<\_ACEOF
7462 > #define STDC_HEADERS 1
7463 > _ACEOF
7464  
7465 + fi
7466  
7467 < for ac_header in machine/hal_sysinfo.h
7467 >
7468 >
7469 >
7470 >
7471 >
7472 >
7473 >
7474 >
7475 >
7476 >
7477 >
7478 >
7479 >
7480 >
7481 >
7482 >
7483 >
7484 >
7485 >
7486 >
7487 >
7488 >
7489 >
7490 >
7491 >
7492 > 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
7493   do
7494   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7495   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6574 | Line 7639 | done
7639   done
7640  
7641  
7642 <
7643 <
7644 <
7645 < for ac_func in rint snprintf sranddev strncasecmp
6581 < 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
7642 > # Checks for typedefs, structures, and compiler characteristics.
7643 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7644 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7645 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7646    echo $ECHO_N "(cached) $ECHO_C" >&6
7647   else
7648    cat >conftest.$ac_ext <<_ACEOF
# Line 6591 | Line 7651 | cat >>conftest.$ac_ext <<_ACEOF
7651   cat confdefs.h >>conftest.$ac_ext
7652   cat >>conftest.$ac_ext <<_ACEOF
7653   /* 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
7654  
7655 < /* System header to define __stub macros and hopefully few prototypes,
7656 <    which can conflict with char $ac_func (); below.
7657 <    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>
6605 < #else
6606 < # include <assert.h>
7655 > #include <stdbool.h>
7656 > #ifndef bool
7657 > # error bool is not defined
7658   #endif
7659 + #ifndef false
7660 + # error false is not defined
7661 + #endif
7662 + #if false
7663 + # error false is not 0
7664 + #endif
7665 + #ifndef true
7666 + # error true is not defined
7667 + #endif
7668 + #if true != 1
7669 + # error true is not 1
7670 + #endif
7671 + #ifndef __bool_true_false_are_defined
7672 + # error __bool_true_false_are_defined is not defined
7673 + #endif
7674  
7675 < #undef $ac_func
7675 >        struct s { _Bool s: 1; _Bool t; } s;
7676  
7677 < /* Override any gcc2 internal prototype to avoid an error.  */
7678 < #ifdef __cplusplus
7679 < extern "C"
7680 < {
7677 >        char a[true == 1 ? 1 : -1];
7678 >        char b[false == 0 ? 1 : -1];
7679 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7680 >        char d[(bool) -0.5 == true ? 1 : -1];
7681 >        bool e = &s;
7682 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7683 >        char g[true];
7684 >        char h[sizeof (_Bool)];
7685 >        char i[sizeof s.t];
7686 >
7687 > #ifdef FC_DUMMY_MAIN
7688 > #ifndef FC_DUMMY_MAIN_EQ_F77
7689 > #  ifdef __cplusplus
7690 >     extern "C"
7691 > #  endif
7692 >   int FC_DUMMY_MAIN() { return 1; }
7693   #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;
7694   #endif
6627 #ifdef __cplusplus
6628 }
6629 #endif
6630
7695   int
7696   main ()
7697   {
7698 < return f != $ac_func;
7698 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7699    ;
7700    return 0;
7701   }
7702   _ACEOF
7703 < rm -f conftest.$ac_objext conftest$ac_exeext
7704 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7705 <  (eval $ac_link) 2>conftest.er1
7703 > rm -f conftest.$ac_objext
7704 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7705 >  (eval $ac_compile) 2>conftest.er1
7706    ac_status=$?
7707    grep -v '^ *+' conftest.er1 >conftest.err
7708    rm -f conftest.er1
# Line 6652 | Line 7716 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7716    ac_status=$?
7717    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7718    (exit $ac_status); }; } &&
7719 <         { ac_try='test -s conftest$ac_exeext'
7719 >         { ac_try='test -s conftest.$ac_objext'
7720    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7721    (eval $ac_try) 2>&5
7722    ac_status=$?
7723    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7724    (exit $ac_status); }; }; then
7725 <  eval "$as_ac_var=yes"
7725 >  ac_cv_header_stdbool_h=yes
7726   else
7727    echo "$as_me: failed program was:" >&5
7728   sed 's/^/| /' conftest.$ac_ext >&5
7729  
7730 < eval "$as_ac_var=no"
7730 > ac_cv_header_stdbool_h=no
7731   fi
7732 < rm -f conftest.err conftest.$ac_objext \
6669 <      conftest$ac_exeext conftest.$ac_ext
7732 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7733   fi
7734 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7735 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7736 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7737 <  cat >>confdefs.h <<_ACEOF
7738 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7734 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7735 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7736 > echo "$as_me:$LINENO: checking for _Bool" >&5
7737 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7738 > if test "${ac_cv_type__Bool+set}" = set; then
7739 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7740 > else
7741 >  cat >conftest.$ac_ext <<_ACEOF
7742 > /* confdefs.h.  */
7743 > _ACEOF
7744 > cat confdefs.h >>conftest.$ac_ext
7745 > cat >>conftest.$ac_ext <<_ACEOF
7746 > /* end confdefs.h.  */
7747 > $ac_includes_default
7748 > #ifdef FC_DUMMY_MAIN
7749 > #ifndef FC_DUMMY_MAIN_EQ_F77
7750 > #  ifdef __cplusplus
7751 >     extern "C"
7752 > #  endif
7753 >   int FC_DUMMY_MAIN() { return 1; }
7754 > #endif
7755 > #endif
7756 > int
7757 > main ()
7758 > {
7759 > if ((_Bool *) 0)
7760 >  return 0;
7761 > if (sizeof (_Bool))
7762 >  return 0;
7763 >  ;
7764 >  return 0;
7765 > }
7766   _ACEOF
7767 + rm -f conftest.$ac_objext
7768 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7769 +  (eval $ac_compile) 2>conftest.er1
7770 +  ac_status=$?
7771 +  grep -v '^ *+' conftest.er1 >conftest.err
7772 +  rm -f conftest.er1
7773 +  cat conftest.err >&5
7774 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7775 +  (exit $ac_status); } &&
7776 +         { ac_try='test -z "$ac_c_werror_flag"
7777 +                         || test ! -s conftest.err'
7778 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7779 +  (eval $ac_try) 2>&5
7780 +  ac_status=$?
7781 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7782 +  (exit $ac_status); }; } &&
7783 +         { ac_try='test -s conftest.$ac_objext'
7784 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7785 +  (eval $ac_try) 2>&5
7786 +  ac_status=$?
7787 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7788 +  (exit $ac_status); }; }; then
7789 +  ac_cv_type__Bool=yes
7790 + else
7791 +  echo "$as_me: failed program was:" >&5
7792 + sed 's/^/| /' conftest.$ac_ext >&5
7793  
7794 + ac_cv_type__Bool=no
7795   fi
7796 < done
7796 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7797 > fi
7798 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7799 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7800 > if test $ac_cv_type__Bool = yes; then
7801  
7802 + cat >>confdefs.h <<_ACEOF
7803 + #define HAVE__BOOL 1
7804 + _ACEOF
7805  
7806  
7807 + fi
7808  
7809 + if test $ac_cv_header_stdbool_h = yes; then
7810  
7811 + cat >>confdefs.h <<\_ACEOF
7812 + #define HAVE_STDBOOL_H 1
7813 + _ACEOF
7814  
7815 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
7816 < do
7817 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7818 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7819 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6691 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7815 > fi
7816 >
7817 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7818 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7819 > if test "${ac_cv_c_const+set}" = set; then
7820    echo $ECHO_N "(cached) $ECHO_C" >&6
7821   else
7822    cat >conftest.$ac_ext <<_ACEOF
# Line 6697 | Line 7825 | cat >>conftest.$ac_ext <<_ACEOF
7825   cat confdefs.h >>conftest.$ac_ext
7826   cat >>conftest.$ac_ext <<_ACEOF
7827   /* 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
7828  
7829 < /* System header to define __stub macros and hopefully few prototypes,
7830 <    which can conflict with char $ac_func (); below.
7831 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7832 <    <limits.h> exists even on freestanding compilers.  */
7833 <
7834 < #ifdef __STDC__
6710 < # include <limits.h>
6711 < #else
6712 < # include <assert.h>
7829 > #ifdef FC_DUMMY_MAIN
7830 > #ifndef FC_DUMMY_MAIN_EQ_F77
7831 > #  ifdef __cplusplus
7832 >     extern "C"
7833 > #  endif
7834 >   int FC_DUMMY_MAIN() { return 1; }
7835   #endif
6714
6715 #undef $ac_func
6716
6717 /* Override any gcc2 internal prototype to avoid an error.  */
6718 #ifdef __cplusplus
6719 extern "C"
6720 {
7836   #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;
6732 #endif
6733 #ifdef __cplusplus
6734 }
6735 #endif
6736
7837   int
7838   main ()
7839   {
7840 < return f != $ac_func;
7840 > /* FIXME: Include the comments suggested by Paul. */
7841 > #ifndef __cplusplus
7842 >  /* Ultrix mips cc rejects this.  */
7843 >  typedef int charset[2];
7844 >  const charset x;
7845 >  /* SunOS 4.1.1 cc rejects this.  */
7846 >  char const *const *ccp;
7847 >  char **p;
7848 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7849 >  struct point {int x, y;};
7850 >  static struct point const zero = {0,0};
7851 >  /* AIX XL C 1.02.0.0 rejects this.
7852 >     It does not let you subtract one const X* pointer from another in
7853 >     an arm of an if-expression whose if-part is not a constant
7854 >     expression */
7855 >  const char *g = "string";
7856 >  ccp = &g + (g ? g-g : 0);
7857 >  /* HPUX 7.0 cc rejects these. */
7858 >  ++ccp;
7859 >  p = (char**) ccp;
7860 >  ccp = (char const *const *) p;
7861 >  { /* SCO 3.2v4 cc rejects this.  */
7862 >    char *t;
7863 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7864 >
7865 >    *t++ = 0;
7866 >  }
7867 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7868 >    int x[] = {25, 17};
7869 >    const int *foo = &x[0];
7870 >    ++foo;
7871 >  }
7872 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7873 >    typedef const int *iptr;
7874 >    iptr p = 0;
7875 >    ++p;
7876 >  }
7877 >  { /* AIX XL C 1.02.0.0 rejects this saying
7878 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7879 >    struct s { int j; const int *ap[3]; };
7880 >    struct s *b; b->j = 5;
7881 >  }
7882 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7883 >    const int foo = 10;
7884 >  }
7885 > #endif
7886 >
7887    ;
7888    return 0;
7889   }
7890   _ACEOF
7891 < rm -f conftest.$ac_objext conftest$ac_exeext
7892 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7893 <  (eval $ac_link) 2>conftest.er1
7891 > rm -f conftest.$ac_objext
7892 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7893 >  (eval $ac_compile) 2>conftest.er1
7894    ac_status=$?
7895    grep -v '^ *+' conftest.er1 >conftest.err
7896    rm -f conftest.er1
# Line 6758 | Line 7904 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7904    ac_status=$?
7905    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906    (exit $ac_status); }; } &&
7907 <         { ac_try='test -s conftest$ac_exeext'
7907 >         { ac_try='test -s conftest.$ac_objext'
7908    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7909    (eval $ac_try) 2>&5
7910    ac_status=$?
7911    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7912    (exit $ac_status); }; }; then
7913 <  eval "$as_ac_var=yes"
7913 >  ac_cv_c_const=yes
7914   else
7915    echo "$as_me: failed program was:" >&5
7916   sed 's/^/| /' conftest.$ac_ext >&5
7917  
7918 < eval "$as_ac_var=no"
7918 > ac_cv_c_const=no
7919   fi
7920 < rm -f conftest.err conftest.$ac_objext \
6775 <      conftest$ac_exeext conftest.$ac_ext
7920 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7921   fi
7922 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7923 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7924 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7925 <  cat >>confdefs.h <<_ACEOF
7926 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7922 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7923 > echo "${ECHO_T}$ac_cv_c_const" >&6
7924 > if test $ac_cv_c_const = no; then
7925 >
7926 > cat >>confdefs.h <<\_ACEOF
7927 > #define const
7928   _ACEOF
7929  
7930   fi
7931 +
7932 + echo "$as_me:$LINENO: checking for inline" >&5
7933 + echo $ECHO_N "checking for inline... $ECHO_C" >&6
7934 + if test "${ac_cv_c_inline+set}" = set; then
7935 +  echo $ECHO_N "(cached) $ECHO_C" >&6
7936 + else
7937 +  ac_cv_c_inline=no
7938 + for ac_kw in inline __inline__ __inline; do
7939 +  cat >conftest.$ac_ext <<_ACEOF
7940 + /* confdefs.h.  */
7941 + _ACEOF
7942 + cat confdefs.h >>conftest.$ac_ext
7943 + cat >>conftest.$ac_ext <<_ACEOF
7944 + /* end confdefs.h.  */
7945 + #ifndef __cplusplus
7946 + typedef int foo_t;
7947 + static $ac_kw foo_t static_foo () {return 0; }
7948 + $ac_kw foo_t foo () {return 0; }
7949 + #endif
7950 +
7951 + _ACEOF
7952 + rm -f conftest.$ac_objext
7953 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7954 +  (eval $ac_compile) 2>conftest.er1
7955 +  ac_status=$?
7956 +  grep -v '^ *+' conftest.er1 >conftest.err
7957 +  rm -f conftest.er1
7958 +  cat conftest.err >&5
7959 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7960 +  (exit $ac_status); } &&
7961 +         { ac_try='test -z "$ac_c_werror_flag"
7962 +                         || test ! -s conftest.err'
7963 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7964 +  (eval $ac_try) 2>&5
7965 +  ac_status=$?
7966 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7967 +  (exit $ac_status); }; } &&
7968 +         { ac_try='test -s conftest.$ac_objext'
7969 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7970 +  (eval $ac_try) 2>&5
7971 +  ac_status=$?
7972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7973 +  (exit $ac_status); }; }; then
7974 +  ac_cv_c_inline=$ac_kw; break
7975 + else
7976 +  echo "$as_me: failed program was:" >&5
7977 + sed 's/^/| /' conftest.$ac_ext >&5
7978 +
7979 + fi
7980 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7981   done
7982  
7983 < # special check for _system_configuration because AIX <4.3.2 do not
7984 < # contain the `physmem' member.
7985 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
7986 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
7987 < cat >conftest.$ac_ext <<_ACEOF
7983 > fi
7984 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7985 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7986 >
7987 >
7988 > case $ac_cv_c_inline in
7989 >  inline | yes) ;;
7990 >  *)
7991 >    case $ac_cv_c_inline in
7992 >      no) ac_val=;;
7993 >      *) ac_val=$ac_cv_c_inline;;
7994 >    esac
7995 >    cat >>confdefs.h <<_ACEOF
7996 > #ifndef __cplusplus
7997 > #define inline $ac_val
7998 > #endif
7999 > _ACEOF
8000 >    ;;
8001 > esac
8002 >
8003 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
8004 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
8005 > if test "${ac_cv_c_restrict+set}" = set; then
8006 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8007 > else
8008 >  ac_cv_c_restrict=no
8009 >   # Try the official restrict keyword, then gcc's __restrict, and
8010 >   # the less common variants.
8011 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
8012 >     cat >conftest.$ac_ext <<_ACEOF
8013   /* confdefs.h.  */
8014   _ACEOF
8015   cat confdefs.h >>conftest.$ac_ext
8016   cat >>conftest.$ac_ext <<_ACEOF
8017   /* end confdefs.h.  */
8018 < #include <sys/systemcfg.h>
8018 > float * $ac_kw x;
8019 > _ACEOF
8020 > rm -f conftest.$ac_objext
8021 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8022 >  (eval $ac_compile) 2>conftest.er1
8023 >  ac_status=$?
8024 >  grep -v '^ *+' conftest.er1 >conftest.err
8025 >  rm -f conftest.er1
8026 >  cat conftest.err >&5
8027 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8028 >  (exit $ac_status); } &&
8029 >         { ac_try='test -z "$ac_c_werror_flag"
8030 >                         || test ! -s conftest.err'
8031 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8032 >  (eval $ac_try) 2>&5
8033 >  ac_status=$?
8034 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8035 >  (exit $ac_status); }; } &&
8036 >         { ac_try='test -s conftest.$ac_objext'
8037 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8038 >  (eval $ac_try) 2>&5
8039 >  ac_status=$?
8040 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8041 >  (exit $ac_status); }; }; then
8042 >  ac_cv_c_restrict=$ac_kw; break
8043 > else
8044 >  echo "$as_me: failed program was:" >&5
8045 > sed 's/^/| /' conftest.$ac_ext >&5
8046 >
8047 > fi
8048 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8049 >   done
8050 >
8051 > fi
8052 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
8053 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
8054 > case $ac_cv_c_restrict in
8055 >   restrict) ;;
8056 >   no)
8057 > cat >>confdefs.h <<\_ACEOF
8058 > #define restrict
8059 > _ACEOF
8060 > ;;
8061 >   *)  cat >>confdefs.h <<_ACEOF
8062 > #define restrict $ac_cv_c_restrict
8063 > _ACEOF
8064 > ;;
8065 > esac
8066 >
8067 > echo "$as_me:$LINENO: checking for size_t" >&5
8068 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8069 > if test "${ac_cv_type_size_t+set}" = set; then
8070 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8071 > else
8072 >  cat >conftest.$ac_ext <<_ACEOF
8073 > /* confdefs.h.  */
8074 > _ACEOF
8075 > cat confdefs.h >>conftest.$ac_ext
8076 > cat >>conftest.$ac_ext <<_ACEOF
8077 > /* end confdefs.h.  */
8078 > $ac_includes_default
8079 > #ifdef FC_DUMMY_MAIN
8080 > #ifndef FC_DUMMY_MAIN_EQ_F77
8081 > #  ifdef __cplusplus
8082 >     extern "C"
8083 > #  endif
8084 >   int FC_DUMMY_MAIN() { return 1; }
8085 > #endif
8086 > #endif
8087   int
8088   main ()
8089   {
8090 < double x = _system_configuration.physmem;
8090 > if ((size_t *) 0)
8091 >  return 0;
8092 > if (sizeof (size_t))
8093 >  return 0;
8094    ;
8095    return 0;
8096   }
# Line 6825 | Line 8117 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8117    ac_status=$?
8118    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8119    (exit $ac_status); }; }; then
8120 <  echo "$as_me:$LINENO: result: yes" >&5
6829 < echo "${ECHO_T}yes" >&6
6830 <
6831 < cat >>confdefs.h <<\_ACEOF
6832 < #define HAVE__SYSTEM_CONFIGURATION 1
6833 < _ACEOF
6834 <
8120 >  ac_cv_type_size_t=yes
8121   else
8122    echo "$as_me: failed program was:" >&5
8123   sed 's/^/| /' conftest.$ac_ext >&5
8124  
8125 < echo "$as_me:$LINENO: result: no" >&5
6840 < echo "${ECHO_T}no" >&6
8125 > ac_cv_type_size_t=no
8126   fi
8127   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8128 + fi
8129 + echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8130 + echo "${ECHO_T}$ac_cv_type_size_t" >&6
8131 + if test $ac_cv_type_size_t = yes; then
8132 +  :
8133 + else
8134 +
8135 + cat >>confdefs.h <<_ACEOF
8136 + #define size_t unsigned
8137 + _ACEOF
8138 +
8139 + fi
8140 +
8141   echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8142   echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8143   if test "${ac_cv_header_time+set}" = set; then
# Line 6855 | Line 8153 | cat >>conftest.$ac_ext <<_ACEOF
8153   #include <sys/time.h>
8154   #include <time.h>
8155  
8156 + #ifdef FC_DUMMY_MAIN
8157 + #ifndef FC_DUMMY_MAIN_EQ_F77
8158 + #  ifdef __cplusplus
8159 +     extern "C"
8160 + #  endif
8161 +   int FC_DUMMY_MAIN() { return 1; }
8162 + #endif
8163 + #endif
8164   int
8165   main ()
8166   {
# Line 6905 | Line 8211 | fi
8211  
8212   fi
8213  
6908
8214   echo "$as_me:$LINENO: checking for clock_t" >&5
8215   echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8216   if test "${ac_cv_type_clock_t+set}" = set; then
# Line 6918 | Line 8223 | $ac_includes_default
8223   cat >>conftest.$ac_ext <<_ACEOF
8224   /* end confdefs.h.  */
8225   $ac_includes_default
8226 + #ifdef FC_DUMMY_MAIN
8227 + #ifndef FC_DUMMY_MAIN_EQ_F77
8228 + #  ifdef __cplusplus
8229 +     extern "C"
8230 + #  endif
8231 +   int FC_DUMMY_MAIN() { return 1; }
8232 + #endif
8233 + #endif
8234   int
8235   main ()
8236   {
# Line 6983 | Line 8296 | cat >>conftest.$ac_ext <<_ACEOF
8296   cat >>conftest.$ac_ext <<_ACEOF
8297   /* end confdefs.h.  */
8298  
8299 + #ifdef FC_DUMMY_MAIN
8300 + #ifndef FC_DUMMY_MAIN_EQ_F77
8301 + #  ifdef __cplusplus
8302 +     extern "C"
8303 + #  endif
8304 +   int FC_DUMMY_MAIN() { return 1; }
8305 + #endif
8306 + #endif
8307   int
8308   main ()
8309   {
# Line 7150 | Line 8471 | esac
8471   esac
8472  
8473  
8474 <
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
7164 < /* confdefs.h.  */
7165 < _ACEOF
7166 < cat confdefs.h >>conftest.$ac_ext
7167 < cat >>conftest.$ac_ext <<_ACEOF
7168 < /* 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
8474 > # Checks for library functions.
8475  
8476 < /* System header to define __stub macros and hopefully few prototypes,
7174 <    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>
7180 < #else
7181 < # include <assert.h>
7182 < #endif
7183 <
7184 < #undef $ac_func
7185 <
7186 < /* Override any gcc2 internal prototype to avoid an error.  */
7187 < #ifdef __cplusplus
7188 < extern "C"
7189 < {
7190 < #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;
7201 < #endif
7202 < #ifdef __cplusplus
7203 < }
7204 < #endif
7205 <
7206 < int
7207 < main ()
7208 < {
7209 < return f != $ac_func;
7210 <  ;
7211 <  return 0;
7212 < }
7213 < _ACEOF
7214 < rm -f conftest.$ac_objext conftest$ac_exeext
7215 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7216 <  (eval $ac_link) 2>conftest.er1
7217 <  ac_status=$?
7218 <  grep -v '^ *+' conftest.er1 >conftest.err
7219 <  rm -f conftest.er1
7220 <  cat conftest.err >&5
7221 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7222 <  (exit $ac_status); } &&
7223 <         { ac_try='test -z "$ac_c_werror_flag"
7224 <                         || test ! -s conftest.err'
7225 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7226 <  (eval $ac_try) 2>&5
7227 <  ac_status=$?
7228 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7229 <  (exit $ac_status); }; } &&
7230 <         { ac_try='test -s conftest$ac_exeext'
7231 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7232 <  (eval $ac_try) 2>&5
7233 <  ac_status=$?
7234 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7235 <  (exit $ac_status); }; }; then
7236 <  eval "$as_ac_var=yes"
7237 < else
7238 <  echo "$as_me: failed program was:" >&5
7239 < sed 's/^/| /' conftest.$ac_ext >&5
7240 <
7241 < eval "$as_ac_var=no"
7242 < fi
7243 < rm -f conftest.err conftest.$ac_objext \
7244 <      conftest$ac_exeext conftest.$ac_ext
7245 < fi
7246 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7247 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7248 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7249 <  cat >>confdefs.h <<_ACEOF
7250 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7251 < _ACEOF
7252 <
7253 < fi
7254 < done
7255 <
7256 <
7257 <  # clean out junk possibly left behind by a previous configuration
7258 <  rm -f src/getopt.h
7259 <  # Check for getopt_long support
7260 <
7261 < for ac_header in getopt.h
8476 > for ac_header in stdlib.h
8477   do
8478   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8479   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7407 | Line 8622 | done
8622  
8623   done
8624  
8625 <
8626 < for ac_func in getopt_long
8627 < do
7413 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7414 < 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
8625 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8626 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8627 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8628    echo $ECHO_N "(cached) $ECHO_C" >&6
8629   else
8630 +  if test "$cross_compiling" = yes; then
8631 +  ac_cv_func_malloc_0_nonnull=no
8632 + else
8633    cat >conftest.$ac_ext <<_ACEOF
8634   /* confdefs.h.  */
8635   _ACEOF
8636   cat confdefs.h >>conftest.$ac_ext
8637   cat >>conftest.$ac_ext <<_ACEOF
8638   /* end confdefs.h.  */
8639 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8640 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7427 < #define $ac_func innocuous_$ac_func
7428 <
7429 < /* System header to define __stub macros and hopefully few prototypes,
7430 <    which can conflict with char $ac_func (); below.
7431 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7432 <    <limits.h> exists even on freestanding compilers.  */
7433 <
7434 < #ifdef __STDC__
7435 < # include <limits.h>
8639 > #if STDC_HEADERS || HAVE_STDLIB_H
8640 > # include <stdlib.h>
8641   #else
8642 < # include <assert.h>
8642 > char *malloc ();
8643   #endif
8644  
8645 < #undef $ac_func
8646 <
8647 < /* Override any gcc2 internal prototype to avoid an error.  */
8648 < #ifdef __cplusplus
8649 < extern "C"
8650 < {
8645 > #ifdef FC_DUMMY_MAIN
8646 > #ifndef FC_DUMMY_MAIN_EQ_F77
8647 > #  ifdef __cplusplus
8648 >     extern "C"
8649 > #  endif
8650 >   int FC_DUMMY_MAIN() { return 1; }
8651   #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;
8652   #endif
7458 #ifdef __cplusplus
7459 }
7460 #endif
7461
8653   int
8654   main ()
8655   {
8656 < return f != $ac_func;
8656 > exit (malloc (0) ? 0 : 1);
8657    ;
8658    return 0;
8659   }
8660   _ACEOF
8661 < rm -f conftest.$ac_objext conftest$ac_exeext
8661 > rm -f conftest$ac_exeext
8662   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8663 <  (eval $ac_link) 2>conftest.er1
8663 >  (eval $ac_link) 2>&5
8664    ac_status=$?
7474  grep -v '^ *+' conftest.er1 >conftest.err
7475  rm -f conftest.er1
7476  cat conftest.err >&5
8665    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8666 <  (exit $ac_status); } &&
7479 <         { ac_try='test -z "$ac_c_werror_flag"
7480 <                         || test ! -s conftest.err'
8666 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8667    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8668    (eval $ac_try) 2>&5
8669    ac_status=$?
8670    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7485  (exit $ac_status); }; } &&
7486         { ac_try='test -s conftest$ac_exeext'
7487  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7488  (eval $ac_try) 2>&5
7489  ac_status=$?
7490  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8671    (exit $ac_status); }; }; then
8672 <  eval "$as_ac_var=yes"
8672 >  ac_cv_func_malloc_0_nonnull=yes
8673   else
8674 <  echo "$as_me: failed program was:" >&5
8674 >  echo "$as_me: program exited with status $ac_status" >&5
8675 > echo "$as_me: failed program was:" >&5
8676   sed 's/^/| /' conftest.$ac_ext >&5
8677  
8678 < eval "$as_ac_var=no"
8678 > ( exit $ac_status )
8679 > ac_cv_func_malloc_0_nonnull=no
8680   fi
8681 < rm -f conftest.err conftest.$ac_objext \
7500 <      conftest$ac_exeext conftest.$ac_ext
8681 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8682   fi
8683 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8684 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8685 < if test `eval echo '${'$as_ac_var'}'` = yes; then
8686 <  cat >>confdefs.h <<_ACEOF
8687 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8683 > fi
8684 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8685 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8686 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8687 >
8688 > cat >>confdefs.h <<\_ACEOF
8689 > #define HAVE_MALLOC 1
8690   _ACEOF
8691  
8692   else
8693 <  # FreeBSD has a gnugetopt library for this
8694 <    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"
7518 < cat >conftest.$ac_ext <<_ACEOF
7519 < /* confdefs.h.  */
8693 >  cat >>confdefs.h <<\_ACEOF
8694 > #define HAVE_MALLOC 0
8695   _ACEOF
7521 cat confdefs.h >>conftest.$ac_ext
7522 cat >>conftest.$ac_ext <<_ACEOF
7523 /* end confdefs.h.  */
8696  
8697 < /* Override any gcc2 internal prototype to avoid an error.  */
8698 < #ifdef __cplusplus
8699 < extern "C"
8700 < #endif
8701 < /* We use char because int might match the return type of a gcc2
8702 <   builtin and then its argument prototype would still apply.  */
8703 < char getopt_long ();
8704 < int
8705 < main ()
8706 < {
8707 < getopt_long ();
8708 <  ;
8709 <  return 0;
8710 < }
8711 < _ACEOF
8712 < rm -f conftest.$ac_objext conftest$ac_exeext
8713 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8714 <  (eval $ac_link) 2>conftest.er1
8715 <  ac_status=$?
8716 <  grep -v '^ *+' conftest.er1 >conftest.err
8717 <  rm -f conftest.er1
8718 <  cat conftest.err >&5
8719 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8720 <  (exit $ac_status); } &&
8721 <         { ac_try='test -z "$ac_c_werror_flag"
8722 <                         || test ! -s conftest.err'
8723 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8724 <  (eval $ac_try) 2>&5
8725 <  ac_status=$?
8726 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8727 <  (exit $ac_status); }; } &&
8728 <         { ac_try='test -s conftest$ac_exeext'
8729 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8730 <  (eval $ac_try) 2>&5
8731 <  ac_status=$?
8732 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8733 <  (exit $ac_status); }; }; then
8734 <  ac_cv_lib_gnugetopt_getopt_long=yes
8735 < else
8736 <  echo "$as_me: failed program was:" >&5
8737 < sed 's/^/| /' conftest.$ac_ext >&5
8738 <
8739 < ac_cv_lib_gnugetopt_getopt_long=no
8740 < fi
8741 < rm -f conftest.err conftest.$ac_objext \
8742 <      conftest$ac_exeext conftest.$ac_ext
8743 < LIBS=$ac_check_lib_save_LIBS
8744 < fi
8745 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
8746 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
8747 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
8748 <  cat >>confdefs.h <<\_ACEOF
8749 < #define HAVE_GETOPT_LONG 1
8750 < _ACEOF
8751 <
8752 < else
8753 <  # use the GNU replacement
8754 <      case $LIBOBJS in
8755 <    "getopt.$ac_objext"   | \
8756 <  *" getopt.$ac_objext"   | \
8757 <    "getopt.$ac_objext "* | \
8758 <  *" getopt.$ac_objext "* ) ;;
8759 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
8760 < esac
8761 <
8762 <      case $LIBOBJS in
8763 <    "getopt1.$ac_objext"   | \
8764 <  *" getopt1.$ac_objext"   | \
8765 <    "getopt1.$ac_objext "* | \
8766 <  *" getopt1.$ac_objext "* ) ;;
8767 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
8768 < esac
8769 <
8770 <                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
8771 <
8772 < fi
8773 <
8774 < fi
8775 < done
8776 <
8777 <
8778 <
8779 < case $debug in
8780 <  1)
8781 <     ;;
8782 <  *)
8783 <
8784 <
8785 <
8786 <
8787 <
8788 <
8789 < echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
8790 < echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
8791 < if test "${ac_cv_prog_really_gcc+set}" = set; then
8792 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8793 < else
8794 <
8795 < cat > conftest.c <<EOF
8796 < #ifdef __GNUC__
8797 <  #ifndef __INTEL_COMPILER
8798 <     yes;
8799 <  #endif
8800 < #endif
8801 < EOF
8802 < if { ac_try='${CC-cc} -E conftest.c'
8803 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8804 <  (eval $ac_try) 2>&5
8805 <  ac_status=$?
8806 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8807 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
8808 <  ac_cv_prog_really_gcc=yes
8809 < else
8810 <  ac_cv_prog_really_gcc=no
8811 < fi
8812 <
8813 < fi
8814 < echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
8815 < echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6
8816 < if test "$ac_cv_prog_really_gcc" = yes; then
8817 <        :
8818 <
8819 < else
8820 <        :
8821 <
8822 < fi
8823 <
8824 <
8825 < # Try to determine "good" native compiler flags if none specified on command
8826 < # line
8827 < if test "$ac_test_CFLAGS" != "set"; then
8828 <  CFLAGS=""
8829 <  case "${host_cpu}-${host_os}" in
8830 <
8831 <  *linux*) if test "$CC" = icc; then
8832 <                    CFLAGS="-O"
8833 <                fi;;
8834 <  sparc-solaris2*) if test "$CC" = cc; then
8835 <                    CFLAGS="-native -fast -xO5 -dalign"
8836 <                 fi;;
8837 <
8838 <  alpha*-osf*)  if test "$CC" = cc; then
8839 <                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
8840 <                fi;;
8841 <
8842 <  hppa*-hpux*)  if test "$CC" = cc; then
8843 <                    CFLAGS="-Ae +O3 +Oall"
8844 <                fi;;
8845 <
8846 <   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
8847 <                    CFLAGS="-O3 -qtune=auto -qansialias -w"
8848 <                fi;;
8849 <   powerpc*-aix*)
8850 <        if test "$CC" = cc -o "$CC" = xlc; then
8851 <                CFLAGS="-O3 -qtune=auto -qansialias -w"
8852 <                echo "*******************************************************"
8853 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8854 <                echo "*  recommended that you use                           *"
8855 <                echo "*                                                     *"
8856 <                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8857 <                echo "*                                 ^^^                 *"
8858 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8859 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
8860 <                echo "*******************************************************"
8861 <        fi;;
8862 <   *darwin*)
8863 <        if test "$CC" = xlc -o "$CC" = cc; then
8864 <                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
8865 <        fi;;
8866 <  esac
8867 <
8868 <  # use default flags for gcc on all systems
8869 <  if test $ac_cv_prog_really_gcc = yes; then
8870 <     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
8871 <  fi
8872 <
8873 <  # test for gcc-specific flags:
8874 <  if test $ac_cv_prog_really_gcc = yes; then
8875 <    # -malign-double for x86 systems
8876 <
8877 <
8878 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
8879 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
8880 < if test "${ac_align_double+set}" = set; then
8881 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8882 < else
8883 <  echo 'void f(){}' > conftest.c
8884 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
8885 <        ac_align_double=yes
8886 < else
8887 <        ac_align_double=no
8888 < fi
8889 < rm -f conftest*
8890 <
8891 < fi
8892 < echo "$as_me:$LINENO: result: $ac_align_double" >&5
8893 < echo "${ECHO_T}$ac_align_double" >&6
8894 < if test "$ac_align_double" = yes; then
8895 <        :
8896 <        CFLAGS="$CFLAGS -malign-double"
8897 < else
8898 <        :
8899 <
8900 < fi
8901 <
8902 <    # -fstrict-aliasing for gcc-2.95+
8903 <
8904 <
8905 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
8906 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
8907 < if test "${ac_fstrict_aliasing+set}" = set; then
8908 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8909 < else
8910 <  echo 'void f(){}' > conftest.c
8911 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
8912 <        ac_fstrict_aliasing=yes
8913 < else
8914 <        ac_fstrict_aliasing=no
8915 < fi
8916 < rm -f conftest*
8917 <
8918 < fi
8919 < echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
8920 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6
8921 < if test "$ac_fstrict_aliasing" = yes; then
8922 <        :
8923 <        CFLAGS="$CFLAGS -fstrict-aliasing"
8924 < else
8925 <        :
8926 <
8927 < fi
8928 <
8929 <  fi
8930 <
8931 <  CPU_FLAGS=""
8932 <  if test $ac_cv_prog_really_gcc = yes; then
8933 <                  case "${host_cpu}" in
8934 <          i586*)
8935 <
8936 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
8937 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
8938 < if test "${ac_cpu_pentium+set}" = set; then
8939 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8940 < else
8941 <  echo 'void f(){}' > conftest.c
8942 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
8943 <        ac_cpu_pentium=yes
8944 < else
8945 <        ac_cpu_pentium=no
8946 < fi
8947 < rm -f conftest*
8948 <
8949 < fi
8950 < echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
8951 < echo "${ECHO_T}$ac_cpu_pentium" >&6
8952 < if test "$ac_cpu_pentium" = yes; then
8953 <        :
8954 <        CPU_FLAGS=-mcpu=pentium
8955 < else
8956 <        :
8957 <
8958 <
8959 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
8960 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
8961 < if test "${ac_pentium+set}" = set; then
8962 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8963 < else
8964 <  echo 'void f(){}' > conftest.c
8965 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
8966 <        ac_pentium=yes
8967 < else
8968 <        ac_pentium=no
8969 < fi
8970 < rm -f conftest*
8971 <
8972 < fi
8973 < echo "$as_me:$LINENO: result: $ac_pentium" >&5
8974 < echo "${ECHO_T}$ac_pentium" >&6
8975 < if test "$ac_pentium" = yes; then
8976 <        :
8977 <        CPU_FLAGS=-mpentium
8978 < else
8979 <        :
8980 <
8981 < fi
8982 <
8983 < fi
8984 <
8985 <                  ;;
8986 <          i686*)
8987 <
8988 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
8989 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
8990 < if test "${ac_cpu_pentiumpro+set}" = set; then
8991 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8992 < else
8993 <  echo 'void f(){}' > conftest.c
8994 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
8995 <        ac_cpu_pentiumpro=yes
8996 < else
8997 <        ac_cpu_pentiumpro=no
8998 < fi
8999 < rm -f conftest*
9000 <
9001 < fi
9002 < echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
9003 < echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
9004 < if test "$ac_cpu_pentiumpro" = yes; then
9005 <        :
9006 <        CPU_FLAGS=-mcpu=pentiumpro
9007 < else
9008 <        :
9009 <
9010 <
9011 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
9012 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
9013 < if test "${ac_pentiumpro+set}" = set; then
9014 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9015 < else
9016 <  echo 'void f(){}' > conftest.c
9017 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
9018 <        ac_pentiumpro=yes
9019 < else
9020 <        ac_pentiumpro=no
9021 < fi
9022 < rm -f conftest*
9023 <
9024 < fi
9025 < echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
9026 < echo "${ECHO_T}$ac_pentiumpro" >&6
9027 < if test "$ac_pentiumpro" = yes; then
9028 <        :
9029 <        CPU_FLAGS=-mpentiumpro
9030 < else
9031 <        :
9032 <
9033 < fi
9034 <
9035 < fi
9036 <
9037 <                  ;;
9038 <          powerpc*)
9039 <                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
9040 <                is60x=`echo $cputype | egrep "^600-9e?$"`
9041 <                if test -n "$is60x"; then
9042 <
9043 <
9044 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
9045 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
9046 < if test "${ac_m_cpu_60x+set}" = set; then
9047 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9048 < else
9049 <  echo 'void f(){}' > conftest.c
9050 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
9051 <        ac_m_cpu_60x=yes
9052 < else
9053 <        ac_m_cpu_60x=no
9054 < fi
9055 < rm -f conftest*
9056 <
9057 < fi
9058 < echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
9059 < echo "${ECHO_T}$ac_m_cpu_60x" >&6
9060 < if test "$ac_m_cpu_60x" = yes; then
9061 <        :
9062 <        CPU_FLAGS=-mcpu=$cputype
9063 < else
9064 <        :
9065 <
9066 < fi
9067 <
9068 <                elif test "$cputype" = 750; then
9069 <
9070 <
9071 < echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
9072 < echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6
9073 < if test "${ac_cv_prog_gcc_2_95+set}" = set; then
9074 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9075 < else
9076 <
9077 < cat > conftest.c <<EOF
9078 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
9079 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
9080 <     yes;
9081 < #  endif
9082 < #endif
9083 < EOF
9084 < if { ac_try='${CC-cc} -E conftest.c'
9085 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9086 <  (eval $ac_try) 2>&5
9087 <  ac_status=$?
9088 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9089 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
9090 <  ac_cv_prog_gcc_2_95=yes
9091 < else
9092 <  ac_cv_prog_gcc_2_95=no
9093 < fi
9094 <
9095 < fi
9096 < echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
9097 < echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6
9098 < if test "$ac_cv_prog_gcc_2_95" = yes; then
9099 <        :
9100 <
9101 <
9102 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
9103 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
9104 < if test "${ac_m_cpu_750+set}" = set; then
9105 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9106 < else
9107 <  echo 'void f(){}' > conftest.c
9108 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
9109 <        ac_m_cpu_750=yes
9110 < else
9111 <        ac_m_cpu_750=no
9112 < fi
9113 < rm -f conftest*
9114 <
9115 < fi
9116 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
9117 < echo "${ECHO_T}$ac_m_cpu_750" >&6
9118 < if test "$ac_m_cpu_750" = yes; then
9119 <        :
9120 <        CPU_FLAGS=-mcpu=750
9121 < else
9122 <        :
9123 <
9124 < fi
9125 <
9126 < else
9127 <        :
9128 <
9129 < fi
9130 <
9131 <                fi
9132 <                if test -z "$CPU_FLAGS"; then
9133 <
9134 <
9135 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
9136 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
9137 < if test "${ac_m_cpu_powerpc+set}" = set; then
9138 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9139 < else
9140 <  echo 'void f(){}' > conftest.c
9141 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
9142 <        ac_m_cpu_powerpc=yes
9143 < else
9144 <        ac_m_cpu_powerpc=no
9145 < fi
9146 < rm -f conftest*
9147 <
9148 < fi
9149 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
9150 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
9151 < if test "$ac_m_cpu_powerpc" = yes; then
9152 <        :
9153 <        CPU_FLAGS=-mcpu=powerpc
9154 < else
9155 <        :
9156 <
9157 < fi
9158 <
9159 <                fi
9160 <                if test -z "$CPU_FLAGS"; then
9161 <
9162 <
9163 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
9164 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
9165 < if test "${ac_m_powerpc+set}" = set; then
9166 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9167 < else
9168 <  echo 'void f(){}' > conftest.c
9169 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
9170 <        ac_m_powerpc=yes
9171 < else
9172 <        ac_m_powerpc=no
9173 < fi
9174 < rm -f conftest*
9175 <
9176 < fi
9177 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
9178 < echo "${ECHO_T}$ac_m_powerpc" >&6
9179 < if test "$ac_m_powerpc" = yes; then
9180 <        :
9181 <        CPU_FLAGS=-mpowerpc
9182 < else
9183 <        :
9184 <
9185 < fi
9186 <
9187 <                fi
9188 <          esac
9189 <  fi
9190 <
9191 <  if test -n "$CPU_FLAGS"; then
9192 <        CFLAGS="$CFLAGS $CPU_FLAGS"
9193 <  fi
9194 <
9195 <  if test -z "$CFLAGS"; then
9196 <        echo ""
9197 <        echo "********************************************************"
9198 <        echo "* WARNING: Don't know the best CFLAGS for this system  *"
9199 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
9200 <        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
9201 <        echo "********************************************************"
9202 <        echo ""
9203 <        CFLAGS="-O3"
9204 <  fi
9205 <
9206 <
9207 <
9208 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
9209 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
9210 < if test "${ac_guessed_cflags+set}" = set; then
9211 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9212 < else
9213 <  echo 'void f(){}' > conftest.c
9214 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
9215 <        ac_guessed_cflags=yes
9216 < else
9217 <        ac_guessed_cflags=no
9218 < fi
9219 < rm -f conftest*
9220 <
9221 < fi
9222 < echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
9223 < echo "${ECHO_T}$ac_guessed_cflags" >&6
9224 < if test "$ac_guessed_cflags" = yes; then
9225 <        :
9226 <
9227 < else
9228 <        :
9229 <
9230 <        echo ""
9231 <        echo "********************************************************"
9232 <        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
9233 <        echo "* your compiler.                                       *"
9234 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
9235 <        echo "********************************************************"
9236 <        echo ""
9237 <        CFLAGS=""
9238 <
9239 < fi
9240 <
9241 <
9242 < fi
9243 <
9244 <
9245 <
9246 <
9247 <
9248 <
9249 <
9250 < echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
9251 < echo $ECHO_N "checking whether we are *really* using GNU c++... $ECHO_C" >&6
9252 < if test "${ac_cv_prog_really_gxx+set}" = set; then
9253 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9254 < else
9255 <
9256 < cat > conftest.cpp <<EOF
9257 < #ifdef __GNUC__
9258 <  #ifndef __INTEL_COMPILER
9259 <     yes;
9260 <  #endif
9261 < #endif
9262 < EOF
9263 < if { ac_try='${CXX-c++} -E conftest.cpp'
9264 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9265 <  (eval $ac_try) 2>&5
9266 <  ac_status=$?
9267 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9268 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
9269 <  ac_cv_prog_really_gxx=yes
9270 < else
9271 <  ac_cv_prog_really_gxx=no
9272 < fi
9273 <
9274 < fi
9275 < echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
9276 < echo "${ECHO_T}$ac_cv_prog_really_gxx" >&6
9277 < if test "$ac_cv_prog_really_gxx" = yes; then
9278 <        :
9279 <
9280 < else
9281 <        :
9282 <
9283 < fi
9284 <
9285 <
9286 < # Try to determine "good" native compiler flags if none specified on command
9287 < # line
9288 < if test "$ac_test_CXXFLAGS" != "set"; then
9289 <  CXXFLAGS=""
9290 <  case "${host_cpu}-${host_os}" in
9291 <
9292 <  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
9293 <                    CXXFLAGS="-O"
9294 <                fi;;
9295 <  sparc-solaris2*) if test "$CXX" = CC; then
9296 <                    CXXFLAGS="-native -fast -xO5 -dalign"
9297 <                 fi;;
9298 <   rs6000*-aix*)  if test "$CXX" = xlC; then
9299 <                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
9300 <                fi;;
9301 <   powerpc*-aix*)
9302 <        if test "$CXX" = xlC; then
9303 <                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
9304 <                echo "*******************************************************"
9305 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
9306 <                echo "*  recommended that you use                           *"
9307 <                echo "*                                                     *"
9308 <                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
9309 <                echo "*                                 ^^^                 *"
9310 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
9311 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
9312 <                echo "*******************************************************"
9313 <        fi;;
9314 <   *darwin*)
9315 <        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
9316 <                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
9317 <        fi;;
9318 <  esac
9319 <
9320 <  # use default flags for gcc on all systems
9321 <  if test $ac_cv_prog_really_gxx = yes; then
9322 <     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
9323 <  fi
9324 <
9325 <  # test for gcc-specific flags:
9326 <  if test $ac_cv_prog_really_gxx = yes; then
9327 <    # -malign-double for x86 systems
9328 <
9329 <
9330 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
9331 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
9332 < if test "${ac_align_double+set}" = set; then
9333 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9334 < else
9335 <  echo 'void f(){}' > conftest.cpp
9336 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
9337 <        ac_align_double=yes
9338 < else
9339 <        ac_align_double=no
9340 < fi
9341 < rm -f conftest*
9342 <
9343 < fi
9344 < echo "$as_me:$LINENO: result: $ac_align_double" >&5
9345 < echo "${ECHO_T}$ac_align_double" >&6
9346 < if test "$ac_align_double" = yes; then
9347 <        :
9348 <        CXXFLAGS="$CXXFLAGS -malign-double"
9349 < else
9350 <        :
9351 <
9352 < fi
9353 <
9354 <    # -fstrict-aliasing for gcc-2.95+
9355 <
9356 <
9357 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
9358 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
9359 < if test "${ac_fstrict_aliasing+set}" = set; then
9360 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9361 < else
9362 <  echo 'void f(){}' > conftest.cpp
9363 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
9364 <        ac_fstrict_aliasing=yes
9365 < else
9366 <        ac_fstrict_aliasing=no
9367 < fi
9368 < rm -f conftest*
9369 <
9370 < fi
9371 < echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
9372 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6
9373 < if test "$ac_fstrict_aliasing" = yes; then
9374 <        :
9375 <        CXXFLAGS="$CXXFLAGS -fstrict-aliasing"
9376 < else
9377 <        :
9378 <
9379 < fi
9380 <
9381 <  fi
9382 <
9383 <  CPU_FLAGS=""
9384 <  if test $ac_cv_prog_really_gxx = yes; then
9385 <                  case "${host_cpu}" in
9386 <          i586*)
9387 <
9388 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
9389 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
9390 < if test "${ac_cpu_pentium+set}" = set; then
9391 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9392 < else
9393 <  echo 'void f(){}' > conftest.cpp
9394 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
9395 <        ac_cpu_pentium=yes
9396 < else
9397 <        ac_cpu_pentium=no
9398 < fi
9399 < rm -f conftest*
9400 <
9401 < fi
9402 < echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
9403 < echo "${ECHO_T}$ac_cpu_pentium" >&6
9404 < if test "$ac_cpu_pentium" = yes; then
9405 <        :
9406 <        CPU_FLAGS=-mcpu=pentium
9407 < else
9408 <        :
9409 <
9410 <
9411 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
9412 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
8697 >   case $LIBOBJS in
8698 >    "malloc.$ac_objext"   | \
8699 >  *" malloc.$ac_objext"   | \
8700 >    "malloc.$ac_objext "* | \
8701 >  *" malloc.$ac_objext "* ) ;;
8702 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8703 > esac
8704 >
8705 >
8706 > cat >>confdefs.h <<\_ACEOF
8707 > #define malloc rpl_malloc
8708 > _ACEOF
8709 >
8710 > fi
8711 >
8712 >
8713 >
8714 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8715 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8716 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8717 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8718 > else
8719 >  if test "$cross_compiling" = yes; then
8720 >  ac_cv_func_memcmp_working=no
8721 > else
8722 >  cat >conftest.$ac_ext <<_ACEOF
8723 > /* confdefs.h.  */
8724 > _ACEOF
8725 > cat confdefs.h >>conftest.$ac_ext
8726 > cat >>conftest.$ac_ext <<_ACEOF
8727 > /* end confdefs.h.  */
8728 > $ac_includes_default
8729 > #ifdef FC_DUMMY_MAIN
8730 > #ifndef FC_DUMMY_MAIN_EQ_F77
8731 > #  ifdef __cplusplus
8732 >     extern "C"
8733 > #  endif
8734 >   int FC_DUMMY_MAIN() { return 1; }
8735 > #endif
8736 > #endif
8737 > int
8738 > main ()
8739 > {
8740 >
8741 >  /* Some versions of memcmp are not 8-bit clean.  */
8742 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8743 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8744 >    exit (1);
8745 >
8746 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8747 >     or more and with at least one buffer not starting on a 4-byte boundary.
8748 >     William Lewis provided this test program.   */
8749 >  {
8750 >    char foo[21];
8751 >    char bar[21];
8752 >    int i;
8753 >    for (i = 0; i < 4; i++)
8754 >      {
8755 >        char *a = foo + i;
8756 >        char *b = bar + i;
8757 >        strcpy (a, "--------01111111");
8758 >        strcpy (b, "--------10000000");
8759 >        if (memcmp (a, b, 16) >= 0)
8760 >          exit (1);
8761 >      }
8762 >    exit (0);
8763 >  }
8764 >
8765 >  ;
8766 >  return 0;
8767 > }
8768 > _ACEOF
8769 > rm -f conftest$ac_exeext
8770 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8771 >  (eval $ac_link) 2>&5
8772 >  ac_status=$?
8773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8774 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8775 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8776 >  (eval $ac_try) 2>&5
8777 >  ac_status=$?
8778 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8779 >  (exit $ac_status); }; }; then
8780 >  ac_cv_func_memcmp_working=yes
8781 > else
8782 >  echo "$as_me: program exited with status $ac_status" >&5
8783 > echo "$as_me: failed program was:" >&5
8784 > sed 's/^/| /' conftest.$ac_ext >&5
8785 >
8786 > ( exit $ac_status )
8787 > ac_cv_func_memcmp_working=no
8788 > fi
8789 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8790 > fi
8791 > fi
8792 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8793 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8794 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8795 >    "memcmp.$ac_objext"   | \
8796 >  *" memcmp.$ac_objext"   | \
8797 >    "memcmp.$ac_objext "* | \
8798 >  *" memcmp.$ac_objext "* ) ;;
8799 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8800 > esac
8801 >
8802 >
8803 >
8804 > for ac_header in stdlib.h
8805 > do
8806 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8807 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8808 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8809 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8810 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8811 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8812 > fi
8813 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8814 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8815 > else
8816 >  # Is the header compilable?
8817 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8818 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8819 > cat >conftest.$ac_ext <<_ACEOF
8820 > /* confdefs.h.  */
8821 > _ACEOF
8822 > cat confdefs.h >>conftest.$ac_ext
8823 > cat >>conftest.$ac_ext <<_ACEOF
8824 > /* end confdefs.h.  */
8825 > $ac_includes_default
8826 > #include <$ac_header>
8827 > _ACEOF
8828 > rm -f conftest.$ac_objext
8829 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8830 >  (eval $ac_compile) 2>conftest.er1
8831 >  ac_status=$?
8832 >  grep -v '^ *+' conftest.er1 >conftest.err
8833 >  rm -f conftest.er1
8834 >  cat conftest.err >&5
8835 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8836 >  (exit $ac_status); } &&
8837 >         { ac_try='test -z "$ac_c_werror_flag"
8838 >                         || test ! -s conftest.err'
8839 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8840 >  (eval $ac_try) 2>&5
8841 >  ac_status=$?
8842 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8843 >  (exit $ac_status); }; } &&
8844 >         { ac_try='test -s conftest.$ac_objext'
8845 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8846 >  (eval $ac_try) 2>&5
8847 >  ac_status=$?
8848 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8849 >  (exit $ac_status); }; }; then
8850 >  ac_header_compiler=yes
8851 > else
8852 >  echo "$as_me: failed program was:" >&5
8853 > sed 's/^/| /' conftest.$ac_ext >&5
8854 >
8855 > ac_header_compiler=no
8856 > fi
8857 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8858 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8859 > echo "${ECHO_T}$ac_header_compiler" >&6
8860 >
8861 > # Is the header present?
8862 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8863 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8864 > cat >conftest.$ac_ext <<_ACEOF
8865 > /* confdefs.h.  */
8866 > _ACEOF
8867 > cat confdefs.h >>conftest.$ac_ext
8868 > cat >>conftest.$ac_ext <<_ACEOF
8869 > /* end confdefs.h.  */
8870 > #include <$ac_header>
8871 > _ACEOF
8872 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8873 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8874 >  ac_status=$?
8875 >  grep -v '^ *+' conftest.er1 >conftest.err
8876 >  rm -f conftest.er1
8877 >  cat conftest.err >&5
8878 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8879 >  (exit $ac_status); } >/dev/null; then
8880 >  if test -s conftest.err; then
8881 >    ac_cpp_err=$ac_c_preproc_warn_flag
8882 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8883 >  else
8884 >    ac_cpp_err=
8885 >  fi
8886 > else
8887 >  ac_cpp_err=yes
8888 > fi
8889 > if test -z "$ac_cpp_err"; then
8890 >  ac_header_preproc=yes
8891 > else
8892 >  echo "$as_me: failed program was:" >&5
8893 > sed 's/^/| /' conftest.$ac_ext >&5
8894 >
8895 >  ac_header_preproc=no
8896 > fi
8897 > rm -f conftest.err conftest.$ac_ext
8898 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8899 > echo "${ECHO_T}$ac_header_preproc" >&6
8900 >
8901 > # So?  What about this header?
8902 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8903 >  yes:no: )
8904 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8905 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8906 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8907 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8908 >    ac_header_preproc=yes
8909 >    ;;
8910 >  no:yes:* )
8911 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8912 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8913 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8914 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8915 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8916 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8917 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8918 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8919 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8920 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8921 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8922 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8923 >    (
8924 >      cat <<\_ASBOX
8925 > ## ------------------------------ ##
8926 > ## Report this to gezelter@nd.edu ##
8927 > ## ------------------------------ ##
8928 > _ASBOX
8929 >    ) |
8930 >      sed "s/^/$as_me: WARNING:     /" >&2
8931 >    ;;
8932 > esac
8933 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8934 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8935 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8936 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8937 > else
8938 >  eval "$as_ac_Header=\$ac_header_preproc"
8939 > fi
8940 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8941 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8942 >
8943 > fi
8944 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8945 >  cat >>confdefs.h <<_ACEOF
8946 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8947 > _ACEOF
8948 >
8949 > fi
8950 >
8951 > done
8952 >
8953 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8954 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8955 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8956 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8957 > else
8958 >  if test "$cross_compiling" = yes; then
8959 >  ac_cv_func_realloc_0_nonnull=no
8960 > else
8961 >  cat >conftest.$ac_ext <<_ACEOF
8962 > /* confdefs.h.  */
8963 > _ACEOF
8964 > cat confdefs.h >>conftest.$ac_ext
8965 > cat >>conftest.$ac_ext <<_ACEOF
8966 > /* end confdefs.h.  */
8967 > #if STDC_HEADERS || HAVE_STDLIB_H
8968 > # include <stdlib.h>
8969 > #else
8970 > char *realloc ();
8971 > #endif
8972 >
8973 > #ifdef FC_DUMMY_MAIN
8974 > #ifndef FC_DUMMY_MAIN_EQ_F77
8975 > #  ifdef __cplusplus
8976 >     extern "C"
8977 > #  endif
8978 >   int FC_DUMMY_MAIN() { return 1; }
8979 > #endif
8980 > #endif
8981 > int
8982 > main ()
8983 > {
8984 > exit (realloc (0, 0) ? 0 : 1);
8985 >  ;
8986 >  return 0;
8987 > }
8988 > _ACEOF
8989 > rm -f conftest$ac_exeext
8990 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8991 >  (eval $ac_link) 2>&5
8992 >  ac_status=$?
8993 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8994 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8995 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8996 >  (eval $ac_try) 2>&5
8997 >  ac_status=$?
8998 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8999 >  (exit $ac_status); }; }; then
9000 >  ac_cv_func_realloc_0_nonnull=yes
9001 > else
9002 >  echo "$as_me: program exited with status $ac_status" >&5
9003 > echo "$as_me: failed program was:" >&5
9004 > sed 's/^/| /' conftest.$ac_ext >&5
9005 >
9006 > ( exit $ac_status )
9007 > ac_cv_func_realloc_0_nonnull=no
9008 > fi
9009 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9010 > fi
9011 > fi
9012 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
9013 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
9014 > if test $ac_cv_func_realloc_0_nonnull = yes; then
9015 >
9016 > cat >>confdefs.h <<\_ACEOF
9017 > #define HAVE_REALLOC 1
9018 > _ACEOF
9019 >
9020 > else
9021 >  cat >>confdefs.h <<\_ACEOF
9022 > #define HAVE_REALLOC 0
9023 > _ACEOF
9024 >
9025 >   case $LIBOBJS in
9026 >    "realloc.$ac_objext"   | \
9027 >  *" realloc.$ac_objext"   | \
9028 >    "realloc.$ac_objext "* | \
9029 >  *" realloc.$ac_objext "* ) ;;
9030 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
9031 > esac
9032 >
9033 >
9034 > cat >>confdefs.h <<\_ACEOF
9035 > #define realloc rpl_realloc
9036 > _ACEOF
9037 >
9038 > fi
9039 >
9040 >
9041 >
9042 >
9043 >
9044 > for ac_header in sys/select.h sys/socket.h
9045 > do
9046 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9047 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9048 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9049 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9050 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9051 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9052 > fi
9053 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9054 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9055 > else
9056 >  # Is the header compilable?
9057 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9058 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9059 > cat >conftest.$ac_ext <<_ACEOF
9060 > /* confdefs.h.  */
9061 > _ACEOF
9062 > cat confdefs.h >>conftest.$ac_ext
9063 > cat >>conftest.$ac_ext <<_ACEOF
9064 > /* end confdefs.h.  */
9065 > $ac_includes_default
9066 > #include <$ac_header>
9067 > _ACEOF
9068 > rm -f conftest.$ac_objext
9069 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9070 >  (eval $ac_compile) 2>conftest.er1
9071 >  ac_status=$?
9072 >  grep -v '^ *+' conftest.er1 >conftest.err
9073 >  rm -f conftest.er1
9074 >  cat conftest.err >&5
9075 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9076 >  (exit $ac_status); } &&
9077 >         { ac_try='test -z "$ac_c_werror_flag"
9078 >                         || test ! -s conftest.err'
9079 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9080 >  (eval $ac_try) 2>&5
9081 >  ac_status=$?
9082 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9083 >  (exit $ac_status); }; } &&
9084 >         { ac_try='test -s conftest.$ac_objext'
9085 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9086 >  (eval $ac_try) 2>&5
9087 >  ac_status=$?
9088 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9089 >  (exit $ac_status); }; }; then
9090 >  ac_header_compiler=yes
9091 > else
9092 >  echo "$as_me: failed program was:" >&5
9093 > sed 's/^/| /' conftest.$ac_ext >&5
9094 >
9095 > ac_header_compiler=no
9096 > fi
9097 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9098 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9099 > echo "${ECHO_T}$ac_header_compiler" >&6
9100 >
9101 > # Is the header present?
9102 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9103 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9104 > cat >conftest.$ac_ext <<_ACEOF
9105 > /* confdefs.h.  */
9106 > _ACEOF
9107 > cat confdefs.h >>conftest.$ac_ext
9108 > cat >>conftest.$ac_ext <<_ACEOF
9109 > /* end confdefs.h.  */
9110 > #include <$ac_header>
9111 > _ACEOF
9112 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9113 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9114 >  ac_status=$?
9115 >  grep -v '^ *+' conftest.er1 >conftest.err
9116 >  rm -f conftest.er1
9117 >  cat conftest.err >&5
9118 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9119 >  (exit $ac_status); } >/dev/null; then
9120 >  if test -s conftest.err; then
9121 >    ac_cpp_err=$ac_c_preproc_warn_flag
9122 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9123 >  else
9124 >    ac_cpp_err=
9125 >  fi
9126 > else
9127 >  ac_cpp_err=yes
9128 > fi
9129 > if test -z "$ac_cpp_err"; then
9130 >  ac_header_preproc=yes
9131 > else
9132 >  echo "$as_me: failed program was:" >&5
9133 > sed 's/^/| /' conftest.$ac_ext >&5
9134 >
9135 >  ac_header_preproc=no
9136 > fi
9137 > rm -f conftest.err conftest.$ac_ext
9138 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9139 > echo "${ECHO_T}$ac_header_preproc" >&6
9140 >
9141 > # So?  What about this header?
9142 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9143 >  yes:no: )
9144 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9145 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9146 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9147 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9148 >    ac_header_preproc=yes
9149 >    ;;
9150 >  no:yes:* )
9151 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9152 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9153 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9154 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9155 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9156 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9157 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9158 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9159 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9160 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9161 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9162 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9163 >    (
9164 >      cat <<\_ASBOX
9165 > ## ------------------------------ ##
9166 > ## Report this to gezelter@nd.edu ##
9167 > ## ------------------------------ ##
9168 > _ASBOX
9169 >    ) |
9170 >      sed "s/^/$as_me: WARNING:     /" >&2
9171 >    ;;
9172 > esac
9173 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9174 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9175 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9176 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9177 > else
9178 >  eval "$as_ac_Header=\$ac_header_preproc"
9179 > fi
9180 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9181 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9182 >
9183 > fi
9184 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9185 >  cat >>confdefs.h <<_ACEOF
9186 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9187 > _ACEOF
9188 >
9189 > fi
9190 >
9191 > done
9192 >
9193 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
9194 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9195 > if test "${ac_cv_func_select_args+set}" = set; then
9196 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9197 > else
9198 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9199 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9200 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9201 >   cat >conftest.$ac_ext <<_ACEOF
9202 > /* confdefs.h.  */
9203 > _ACEOF
9204 > cat confdefs.h >>conftest.$ac_ext
9205 > cat >>conftest.$ac_ext <<_ACEOF
9206 > /* end confdefs.h.  */
9207 > $ac_includes_default
9208 > #if HAVE_SYS_SELECT_H
9209 > # include <sys/select.h>
9210 > #endif
9211 > #if HAVE_SYS_SOCKET_H
9212 > # include <sys/socket.h>
9213 > #endif
9214 >
9215 > #ifdef FC_DUMMY_MAIN
9216 > #ifndef FC_DUMMY_MAIN_EQ_F77
9217 > #  ifdef __cplusplus
9218 >     extern "C"
9219 > #  endif
9220 >   int FC_DUMMY_MAIN() { return 1; }
9221 > #endif
9222 > #endif
9223 > int
9224 > main ()
9225 > {
9226 > extern int select ($ac_arg1,
9227 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
9228 >                                            $ac_arg5);
9229 >  ;
9230 >  return 0;
9231 > }
9232 > _ACEOF
9233 > rm -f conftest.$ac_objext
9234 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9235 >  (eval $ac_compile) 2>conftest.er1
9236 >  ac_status=$?
9237 >  grep -v '^ *+' conftest.er1 >conftest.err
9238 >  rm -f conftest.er1
9239 >  cat conftest.err >&5
9240 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9241 >  (exit $ac_status); } &&
9242 >         { ac_try='test -z "$ac_c_werror_flag"
9243 >                         || test ! -s conftest.err'
9244 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9245 >  (eval $ac_try) 2>&5
9246 >  ac_status=$?
9247 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9248 >  (exit $ac_status); }; } &&
9249 >         { ac_try='test -s conftest.$ac_objext'
9250 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9251 >  (eval $ac_try) 2>&5
9252 >  ac_status=$?
9253 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9254 >  (exit $ac_status); }; }; then
9255 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9256 > else
9257 >  echo "$as_me: failed program was:" >&5
9258 > sed 's/^/| /' conftest.$ac_ext >&5
9259 >
9260 > fi
9261 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9262 >  done
9263 > done
9264 > done
9265 > # Provide a safe default value.
9266 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
9267 >
9268 > fi
9269 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9270 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
9271 > ac_save_IFS=$IFS; IFS=','
9272 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9273 > IFS=$ac_save_IFS
9274 > shift
9275 >
9276 > cat >>confdefs.h <<_ACEOF
9277 > #define SELECT_TYPE_ARG1 $1
9278 > _ACEOF
9279 >
9280 >
9281 > cat >>confdefs.h <<_ACEOF
9282 > #define SELECT_TYPE_ARG234 ($2)
9283 > _ACEOF
9284 >
9285 >
9286 > cat >>confdefs.h <<_ACEOF
9287 > #define SELECT_TYPE_ARG5 ($3)
9288 > _ACEOF
9289 >
9290 > rm -f conftest*
9291 >
9292 >
9293 > for ac_func in strftime
9294 > do
9295 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9296 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9297 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9298 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9299 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9300 > else
9301 >  cat >conftest.$ac_ext <<_ACEOF
9302 > /* confdefs.h.  */
9303 > _ACEOF
9304 > cat confdefs.h >>conftest.$ac_ext
9305 > cat >>conftest.$ac_ext <<_ACEOF
9306 > /* end confdefs.h.  */
9307 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9308 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9309 > #define $ac_func innocuous_$ac_func
9310 >
9311 > /* System header to define __stub macros and hopefully few prototypes,
9312 >    which can conflict with char $ac_func (); below.
9313 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9314 >    <limits.h> exists even on freestanding compilers.  */
9315 >
9316 > #ifdef __STDC__
9317 > # include <limits.h>
9318 > #else
9319 > # include <assert.h>
9320 > #endif
9321 >
9322 > #undef $ac_func
9323 >
9324 > /* Override any gcc2 internal prototype to avoid an error.  */
9325 > #ifdef __cplusplus
9326 > extern "C"
9327 > {
9328 > #endif
9329 > /* We use char because int might match the return type of a gcc2
9330 >   builtin and then its argument prototype would still apply.  */
9331 > char $ac_func ();
9332 > /* The GNU C library defines this for functions which it implements
9333 >    to always fail with ENOSYS.  Some functions are actually named
9334 >    something starting with __ and the normal name is an alias.  */
9335 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9336 > choke me
9337 > #else
9338 > char (*f) () = $ac_func;
9339 > #endif
9340 > #ifdef __cplusplus
9341 > }
9342 > #endif
9343 >
9344 > #ifdef FC_DUMMY_MAIN
9345 > #ifndef FC_DUMMY_MAIN_EQ_F77
9346 > #  ifdef __cplusplus
9347 >     extern "C"
9348 > #  endif
9349 >   int FC_DUMMY_MAIN() { return 1; }
9350 > #endif
9351 > #endif
9352 > int
9353 > main ()
9354 > {
9355 > return f != $ac_func;
9356 >  ;
9357 >  return 0;
9358 > }
9359 > _ACEOF
9360 > rm -f conftest.$ac_objext conftest$ac_exeext
9361 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9362 >  (eval $ac_link) 2>conftest.er1
9363 >  ac_status=$?
9364 >  grep -v '^ *+' conftest.er1 >conftest.err
9365 >  rm -f conftest.er1
9366 >  cat conftest.err >&5
9367 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9368 >  (exit $ac_status); } &&
9369 >         { ac_try='test -z "$ac_c_werror_flag"
9370 >                         || test ! -s conftest.err'
9371 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9372 >  (eval $ac_try) 2>&5
9373 >  ac_status=$?
9374 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9375 >  (exit $ac_status); }; } &&
9376 >         { ac_try='test -s conftest$ac_exeext'
9377 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9378 >  (eval $ac_try) 2>&5
9379 >  ac_status=$?
9380 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9381 >  (exit $ac_status); }; }; then
9382 >  eval "$as_ac_var=yes"
9383 > else
9384 >  echo "$as_me: failed program was:" >&5
9385 > sed 's/^/| /' conftest.$ac_ext >&5
9386 >
9387 > eval "$as_ac_var=no"
9388 > fi
9389 > rm -f conftest.err conftest.$ac_objext \
9390 >      conftest$ac_exeext conftest.$ac_ext
9391 > fi
9392 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9393 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9394 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9395 >  cat >>confdefs.h <<_ACEOF
9396 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9397 > _ACEOF
9398 >
9399 > else
9400 >  # strftime is in -lintl on SCO UNIX.
9401 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9402 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9403 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9404 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9405 > else
9406 >  ac_check_lib_save_LIBS=$LIBS
9407 > LIBS="-lintl  $LIBS"
9408 > cat >conftest.$ac_ext <<_ACEOF
9409 > /* confdefs.h.  */
9410 > _ACEOF
9411 > cat confdefs.h >>conftest.$ac_ext
9412 > cat >>conftest.$ac_ext <<_ACEOF
9413 > /* end confdefs.h.  */
9414 >
9415 > /* Override any gcc2 internal prototype to avoid an error.  */
9416 > #ifdef __cplusplus
9417 > extern "C"
9418 > #endif
9419 > /* We use char because int might match the return type of a gcc2
9420 >   builtin and then its argument prototype would still apply.  */
9421 > char strftime ();
9422 > #ifdef FC_DUMMY_MAIN
9423 > #ifndef FC_DUMMY_MAIN_EQ_F77
9424 > #  ifdef __cplusplus
9425 >     extern "C"
9426 > #  endif
9427 >   int FC_DUMMY_MAIN() { return 1; }
9428 > #endif
9429 > #endif
9430 > int
9431 > main ()
9432 > {
9433 > strftime ();
9434 >  ;
9435 >  return 0;
9436 > }
9437 > _ACEOF
9438 > rm -f conftest.$ac_objext conftest$ac_exeext
9439 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9440 >  (eval $ac_link) 2>conftest.er1
9441 >  ac_status=$?
9442 >  grep -v '^ *+' conftest.er1 >conftest.err
9443 >  rm -f conftest.er1
9444 >  cat conftest.err >&5
9445 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9446 >  (exit $ac_status); } &&
9447 >         { ac_try='test -z "$ac_c_werror_flag"
9448 >                         || test ! -s conftest.err'
9449 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9450 >  (eval $ac_try) 2>&5
9451 >  ac_status=$?
9452 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9453 >  (exit $ac_status); }; } &&
9454 >         { ac_try='test -s conftest$ac_exeext'
9455 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9456 >  (eval $ac_try) 2>&5
9457 >  ac_status=$?
9458 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9459 >  (exit $ac_status); }; }; then
9460 >  ac_cv_lib_intl_strftime=yes
9461 > else
9462 >  echo "$as_me: failed program was:" >&5
9463 > sed 's/^/| /' conftest.$ac_ext >&5
9464 >
9465 > ac_cv_lib_intl_strftime=no
9466 > fi
9467 > rm -f conftest.err conftest.$ac_objext \
9468 >      conftest$ac_exeext conftest.$ac_ext
9469 > LIBS=$ac_check_lib_save_LIBS
9470 > fi
9471 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9472 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9473 > if test $ac_cv_lib_intl_strftime = yes; then
9474 >  cat >>confdefs.h <<\_ACEOF
9475 > #define HAVE_STRFTIME 1
9476 > _ACEOF
9477 >
9478 > LIBS="-lintl $LIBS"
9479 > fi
9480 >
9481 > fi
9482 > done
9483 >
9484 > echo "$as_me:$LINENO: checking for working strtod" >&5
9485 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9486 > if test "${ac_cv_func_strtod+set}" = set; then
9487 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9488 > else
9489 >  if test "$cross_compiling" = yes; then
9490 >  ac_cv_func_strtod=no
9491 > else
9492 >  cat >conftest.$ac_ext <<_ACEOF
9493 > /* confdefs.h.  */
9494 > _ACEOF
9495 > cat confdefs.h >>conftest.$ac_ext
9496 > cat >>conftest.$ac_ext <<_ACEOF
9497 > /* end confdefs.h.  */
9498 >
9499 > double strtod ();
9500 > int
9501 > main()
9502 > {
9503 >  {
9504 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9505 >    char *string = " +69";
9506 >    char *term;
9507 >    double value;
9508 >    value = strtod (string, &term);
9509 >    if (value != 69 || term != (string + 4))
9510 >      exit (1);
9511 >  }
9512 >
9513 >  {
9514 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9515 >       terminating character under some conditions.  */
9516 >    char *string = "NaN";
9517 >    char *term;
9518 >    strtod (string, &term);
9519 >    if (term != string && *(term - 1) == 0)
9520 >      exit (1);
9521 >  }
9522 >  exit (0);
9523 > }
9524 >
9525 > _ACEOF
9526 > rm -f conftest$ac_exeext
9527 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9528 >  (eval $ac_link) 2>&5
9529 >  ac_status=$?
9530 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9531 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9532 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9533 >  (eval $ac_try) 2>&5
9534 >  ac_status=$?
9535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9536 >  (exit $ac_status); }; }; then
9537 >  ac_cv_func_strtod=yes
9538 > else
9539 >  echo "$as_me: program exited with status $ac_status" >&5
9540 > echo "$as_me: failed program was:" >&5
9541 > sed 's/^/| /' conftest.$ac_ext >&5
9542 >
9543 > ( exit $ac_status )
9544 > ac_cv_func_strtod=no
9545 > fi
9546 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9547 > fi
9548 > fi
9549 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9550 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9551 > if test $ac_cv_func_strtod = no; then
9552 >  case $LIBOBJS in
9553 >    "strtod.$ac_objext"   | \
9554 >  *" strtod.$ac_objext"   | \
9555 >    "strtod.$ac_objext "* | \
9556 >  *" strtod.$ac_objext "* ) ;;
9557 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9558 > esac
9559 >
9560 > echo "$as_me:$LINENO: checking for pow" >&5
9561 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9562 > if test "${ac_cv_func_pow+set}" = set; then
9563 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9564 > else
9565 >  cat >conftest.$ac_ext <<_ACEOF
9566 > /* confdefs.h.  */
9567 > _ACEOF
9568 > cat confdefs.h >>conftest.$ac_ext
9569 > cat >>conftest.$ac_ext <<_ACEOF
9570 > /* end confdefs.h.  */
9571 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9572 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9573 > #define pow innocuous_pow
9574 >
9575 > /* System header to define __stub macros and hopefully few prototypes,
9576 >    which can conflict with char pow (); below.
9577 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9578 >    <limits.h> exists even on freestanding compilers.  */
9579 >
9580 > #ifdef __STDC__
9581 > # include <limits.h>
9582 > #else
9583 > # include <assert.h>
9584 > #endif
9585 >
9586 > #undef pow
9587 >
9588 > /* Override any gcc2 internal prototype to avoid an error.  */
9589 > #ifdef __cplusplus
9590 > extern "C"
9591 > {
9592 > #endif
9593 > /* We use char because int might match the return type of a gcc2
9594 >   builtin and then its argument prototype would still apply.  */
9595 > char pow ();
9596 > /* The GNU C library defines this for functions which it implements
9597 >    to always fail with ENOSYS.  Some functions are actually named
9598 >    something starting with __ and the normal name is an alias.  */
9599 > #if defined (__stub_pow) || defined (__stub___pow)
9600 > choke me
9601 > #else
9602 > char (*f) () = pow;
9603 > #endif
9604 > #ifdef __cplusplus
9605 > }
9606 > #endif
9607 >
9608 > #ifdef FC_DUMMY_MAIN
9609 > #ifndef FC_DUMMY_MAIN_EQ_F77
9610 > #  ifdef __cplusplus
9611 >     extern "C"
9612 > #  endif
9613 >   int FC_DUMMY_MAIN() { return 1; }
9614 > #endif
9615 > #endif
9616 > int
9617 > main ()
9618 > {
9619 > return f != pow;
9620 >  ;
9621 >  return 0;
9622 > }
9623 > _ACEOF
9624 > rm -f conftest.$ac_objext conftest$ac_exeext
9625 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9626 >  (eval $ac_link) 2>conftest.er1
9627 >  ac_status=$?
9628 >  grep -v '^ *+' conftest.er1 >conftest.err
9629 >  rm -f conftest.er1
9630 >  cat conftest.err >&5
9631 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9632 >  (exit $ac_status); } &&
9633 >         { ac_try='test -z "$ac_c_werror_flag"
9634 >                         || test ! -s conftest.err'
9635 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9636 >  (eval $ac_try) 2>&5
9637 >  ac_status=$?
9638 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9639 >  (exit $ac_status); }; } &&
9640 >         { ac_try='test -s conftest$ac_exeext'
9641 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642 >  (eval $ac_try) 2>&5
9643 >  ac_status=$?
9644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645 >  (exit $ac_status); }; }; then
9646 >  ac_cv_func_pow=yes
9647 > else
9648 >  echo "$as_me: failed program was:" >&5
9649 > sed 's/^/| /' conftest.$ac_ext >&5
9650 >
9651 > ac_cv_func_pow=no
9652 > fi
9653 > rm -f conftest.err conftest.$ac_objext \
9654 >      conftest$ac_exeext conftest.$ac_ext
9655 > fi
9656 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9657 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9658 >
9659 > if test $ac_cv_func_pow = no; then
9660 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9661 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9662 > if test "${ac_cv_lib_m_pow+set}" = set; then
9663 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9664 > else
9665 >  ac_check_lib_save_LIBS=$LIBS
9666 > LIBS="-lm  $LIBS"
9667 > cat >conftest.$ac_ext <<_ACEOF
9668 > /* confdefs.h.  */
9669 > _ACEOF
9670 > cat confdefs.h >>conftest.$ac_ext
9671 > cat >>conftest.$ac_ext <<_ACEOF
9672 > /* end confdefs.h.  */
9673 >
9674 > /* Override any gcc2 internal prototype to avoid an error.  */
9675 > #ifdef __cplusplus
9676 > extern "C"
9677 > #endif
9678 > /* We use char because int might match the return type of a gcc2
9679 >   builtin and then its argument prototype would still apply.  */
9680 > char pow ();
9681 > #ifdef FC_DUMMY_MAIN
9682 > #ifndef FC_DUMMY_MAIN_EQ_F77
9683 > #  ifdef __cplusplus
9684 >     extern "C"
9685 > #  endif
9686 >   int FC_DUMMY_MAIN() { return 1; }
9687 > #endif
9688 > #endif
9689 > int
9690 > main ()
9691 > {
9692 > pow ();
9693 >  ;
9694 >  return 0;
9695 > }
9696 > _ACEOF
9697 > rm -f conftest.$ac_objext conftest$ac_exeext
9698 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9699 >  (eval $ac_link) 2>conftest.er1
9700 >  ac_status=$?
9701 >  grep -v '^ *+' conftest.er1 >conftest.err
9702 >  rm -f conftest.er1
9703 >  cat conftest.err >&5
9704 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9705 >  (exit $ac_status); } &&
9706 >         { ac_try='test -z "$ac_c_werror_flag"
9707 >                         || test ! -s conftest.err'
9708 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9709 >  (eval $ac_try) 2>&5
9710 >  ac_status=$?
9711 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9712 >  (exit $ac_status); }; } &&
9713 >         { ac_try='test -s conftest$ac_exeext'
9714 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9715 >  (eval $ac_try) 2>&5
9716 >  ac_status=$?
9717 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9718 >  (exit $ac_status); }; }; then
9719 >  ac_cv_lib_m_pow=yes
9720 > else
9721 >  echo "$as_me: failed program was:" >&5
9722 > sed 's/^/| /' conftest.$ac_ext >&5
9723 >
9724 > ac_cv_lib_m_pow=no
9725 > fi
9726 > rm -f conftest.err conftest.$ac_objext \
9727 >      conftest$ac_exeext conftest.$ac_ext
9728 > LIBS=$ac_check_lib_save_LIBS
9729 > fi
9730 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9731 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9732 > if test $ac_cv_lib_m_pow = yes; then
9733 >  POW_LIB=-lm
9734 > else
9735 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9736 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9737 > fi
9738 >
9739 > fi
9740 >
9741 > fi
9742 >
9743 >
9744 >
9745 >
9746 >
9747 >
9748 >
9749 >
9750 >
9751 >
9752 >
9753 >
9754 >
9755 >
9756 >
9757 >
9758 >
9759 >
9760 >
9761 >
9762 >
9763 >
9764 >
9765 >
9766 >
9767 >
9768 >
9769 >
9770 > 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
9771 > do
9772 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9773 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9774 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9775 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9776 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9777 > else
9778 >  cat >conftest.$ac_ext <<_ACEOF
9779 > /* confdefs.h.  */
9780 > _ACEOF
9781 > cat confdefs.h >>conftest.$ac_ext
9782 > cat >>conftest.$ac_ext <<_ACEOF
9783 > /* end confdefs.h.  */
9784 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9785 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9786 > #define $ac_func innocuous_$ac_func
9787 >
9788 > /* System header to define __stub macros and hopefully few prototypes,
9789 >    which can conflict with char $ac_func (); below.
9790 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9791 >    <limits.h> exists even on freestanding compilers.  */
9792 >
9793 > #ifdef __STDC__
9794 > # include <limits.h>
9795 > #else
9796 > # include <assert.h>
9797 > #endif
9798 >
9799 > #undef $ac_func
9800 >
9801 > /* Override any gcc2 internal prototype to avoid an error.  */
9802 > #ifdef __cplusplus
9803 > extern "C"
9804 > {
9805 > #endif
9806 > /* We use char because int might match the return type of a gcc2
9807 >   builtin and then its argument prototype would still apply.  */
9808 > char $ac_func ();
9809 > /* The GNU C library defines this for functions which it implements
9810 >    to always fail with ENOSYS.  Some functions are actually named
9811 >    something starting with __ and the normal name is an alias.  */
9812 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9813 > choke me
9814 > #else
9815 > char (*f) () = $ac_func;
9816 > #endif
9817 > #ifdef __cplusplus
9818 > }
9819 > #endif
9820 >
9821 > #ifdef FC_DUMMY_MAIN
9822 > #ifndef FC_DUMMY_MAIN_EQ_F77
9823 > #  ifdef __cplusplus
9824 >     extern "C"
9825 > #  endif
9826 >   int FC_DUMMY_MAIN() { return 1; }
9827 > #endif
9828 > #endif
9829 > int
9830 > main ()
9831 > {
9832 > return f != $ac_func;
9833 >  ;
9834 >  return 0;
9835 > }
9836 > _ACEOF
9837 > rm -f conftest.$ac_objext conftest$ac_exeext
9838 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9839 >  (eval $ac_link) 2>conftest.er1
9840 >  ac_status=$?
9841 >  grep -v '^ *+' conftest.er1 >conftest.err
9842 >  rm -f conftest.er1
9843 >  cat conftest.err >&5
9844 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9845 >  (exit $ac_status); } &&
9846 >         { ac_try='test -z "$ac_c_werror_flag"
9847 >                         || test ! -s conftest.err'
9848 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9849 >  (eval $ac_try) 2>&5
9850 >  ac_status=$?
9851 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9852 >  (exit $ac_status); }; } &&
9853 >         { ac_try='test -s conftest$ac_exeext'
9854 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9855 >  (eval $ac_try) 2>&5
9856 >  ac_status=$?
9857 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9858 >  (exit $ac_status); }; }; then
9859 >  eval "$as_ac_var=yes"
9860 > else
9861 >  echo "$as_me: failed program was:" >&5
9862 > sed 's/^/| /' conftest.$ac_ext >&5
9863 >
9864 > eval "$as_ac_var=no"
9865 > fi
9866 > rm -f conftest.err conftest.$ac_objext \
9867 >      conftest$ac_exeext conftest.$ac_ext
9868 > fi
9869 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9870 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9871 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9872 >  cat >>confdefs.h <<_ACEOF
9873 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9874 > _ACEOF
9875 >
9876 > fi
9877 > done
9878 >
9879 >
9880 > # special check for _system_configuration because AIX <4.3.2 do not
9881 > # contain the `physmem' member.
9882 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9883 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9884 > cat >conftest.$ac_ext <<_ACEOF
9885 > /* confdefs.h.  */
9886 > _ACEOF
9887 > cat confdefs.h >>conftest.$ac_ext
9888 > cat >>conftest.$ac_ext <<_ACEOF
9889 > /* end confdefs.h.  */
9890 > #include <sys/systemcfg.h>
9891 > #ifdef FC_DUMMY_MAIN
9892 > #ifndef FC_DUMMY_MAIN_EQ_F77
9893 > #  ifdef __cplusplus
9894 >     extern "C"
9895 > #  endif
9896 >   int FC_DUMMY_MAIN() { return 1; }
9897 > #endif
9898 > #endif
9899 > int
9900 > main ()
9901 > {
9902 > double x = _system_configuration.physmem;
9903 >  ;
9904 >  return 0;
9905 > }
9906 > _ACEOF
9907 > rm -f conftest.$ac_objext
9908 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9909 >  (eval $ac_compile) 2>conftest.er1
9910 >  ac_status=$?
9911 >  grep -v '^ *+' conftest.er1 >conftest.err
9912 >  rm -f conftest.er1
9913 >  cat conftest.err >&5
9914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9915 >  (exit $ac_status); } &&
9916 >         { ac_try='test -z "$ac_c_werror_flag"
9917 >                         || test ! -s conftest.err'
9918 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9919 >  (eval $ac_try) 2>&5
9920 >  ac_status=$?
9921 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9922 >  (exit $ac_status); }; } &&
9923 >         { ac_try='test -s conftest.$ac_objext'
9924 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9925 >  (eval $ac_try) 2>&5
9926 >  ac_status=$?
9927 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9928 >  (exit $ac_status); }; }; then
9929 >  echo "$as_me:$LINENO: result: yes" >&5
9930 > echo "${ECHO_T}yes" >&6
9931 >
9932 > cat >>confdefs.h <<\_ACEOF
9933 > #define HAVE__SYSTEM_CONFIGURATION 1
9934 > _ACEOF
9935 >
9936 > else
9937 >  echo "$as_me: failed program was:" >&5
9938 > sed 's/^/| /' conftest.$ac_ext >&5
9939 >
9940 > echo "$as_me:$LINENO: result: no" >&5
9941 > echo "${ECHO_T}no" >&6
9942 > fi
9943 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9944 >
9945 >  # clean out junk possibly left behind by a previous configuration
9946 >  rm -f src/getopt.h
9947 >  # Check for getopt_long support
9948 >
9949 > for ac_header in getopt.h
9950 > do
9951 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9952 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9953 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9954 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9955 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9956 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9957 > fi
9958 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9959 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9960 > else
9961 >  # Is the header compilable?
9962 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9963 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9964 > cat >conftest.$ac_ext <<_ACEOF
9965 > /* confdefs.h.  */
9966 > _ACEOF
9967 > cat confdefs.h >>conftest.$ac_ext
9968 > cat >>conftest.$ac_ext <<_ACEOF
9969 > /* end confdefs.h.  */
9970 > $ac_includes_default
9971 > #include <$ac_header>
9972 > _ACEOF
9973 > rm -f conftest.$ac_objext
9974 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9975 >  (eval $ac_compile) 2>conftest.er1
9976 >  ac_status=$?
9977 >  grep -v '^ *+' conftest.er1 >conftest.err
9978 >  rm -f conftest.er1
9979 >  cat conftest.err >&5
9980 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9981 >  (exit $ac_status); } &&
9982 >         { ac_try='test -z "$ac_c_werror_flag"
9983 >                         || test ! -s conftest.err'
9984 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9985 >  (eval $ac_try) 2>&5
9986 >  ac_status=$?
9987 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9988 >  (exit $ac_status); }; } &&
9989 >         { ac_try='test -s conftest.$ac_objext'
9990 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9991 >  (eval $ac_try) 2>&5
9992 >  ac_status=$?
9993 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9994 >  (exit $ac_status); }; }; then
9995 >  ac_header_compiler=yes
9996 > else
9997 >  echo "$as_me: failed program was:" >&5
9998 > sed 's/^/| /' conftest.$ac_ext >&5
9999 >
10000 > ac_header_compiler=no
10001 > fi
10002 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10003 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10004 > echo "${ECHO_T}$ac_header_compiler" >&6
10005 >
10006 > # Is the header present?
10007 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10008 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10009 > cat >conftest.$ac_ext <<_ACEOF
10010 > /* confdefs.h.  */
10011 > _ACEOF
10012 > cat confdefs.h >>conftest.$ac_ext
10013 > cat >>conftest.$ac_ext <<_ACEOF
10014 > /* end confdefs.h.  */
10015 > #include <$ac_header>
10016 > _ACEOF
10017 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10018 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10019 >  ac_status=$?
10020 >  grep -v '^ *+' conftest.er1 >conftest.err
10021 >  rm -f conftest.er1
10022 >  cat conftest.err >&5
10023 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10024 >  (exit $ac_status); } >/dev/null; then
10025 >  if test -s conftest.err; then
10026 >    ac_cpp_err=$ac_c_preproc_warn_flag
10027 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10028 >  else
10029 >    ac_cpp_err=
10030 >  fi
10031 > else
10032 >  ac_cpp_err=yes
10033 > fi
10034 > if test -z "$ac_cpp_err"; then
10035 >  ac_header_preproc=yes
10036 > else
10037 >  echo "$as_me: failed program was:" >&5
10038 > sed 's/^/| /' conftest.$ac_ext >&5
10039 >
10040 >  ac_header_preproc=no
10041 > fi
10042 > rm -f conftest.err conftest.$ac_ext
10043 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10044 > echo "${ECHO_T}$ac_header_preproc" >&6
10045 >
10046 > # So?  What about this header?
10047 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10048 >  yes:no: )
10049 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10050 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10051 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10052 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10053 >    ac_header_preproc=yes
10054 >    ;;
10055 >  no:yes:* )
10056 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10057 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10058 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10059 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10060 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10061 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10062 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10063 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10064 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10065 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10066 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10067 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10068 >    (
10069 >      cat <<\_ASBOX
10070 > ## ------------------------------ ##
10071 > ## Report this to gezelter@nd.edu ##
10072 > ## ------------------------------ ##
10073 > _ASBOX
10074 >    ) |
10075 >      sed "s/^/$as_me: WARNING:     /" >&2
10076 >    ;;
10077 > esac
10078 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10079 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10080 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10081 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10082 > else
10083 >  eval "$as_ac_Header=\$ac_header_preproc"
10084 > fi
10085 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10086 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10087 >
10088 > fi
10089 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10090 >  cat >>confdefs.h <<_ACEOF
10091 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10092 > _ACEOF
10093 >
10094 > fi
10095 >
10096 > done
10097 >
10098 >
10099 > for ac_func in getopt_long
10100 > do
10101 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10102 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10103 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10104 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10105 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10106 > else
10107 >  cat >conftest.$ac_ext <<_ACEOF
10108 > /* confdefs.h.  */
10109 > _ACEOF
10110 > cat confdefs.h >>conftest.$ac_ext
10111 > cat >>conftest.$ac_ext <<_ACEOF
10112 > /* end confdefs.h.  */
10113 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10114 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10115 > #define $ac_func innocuous_$ac_func
10116 >
10117 > /* System header to define __stub macros and hopefully few prototypes,
10118 >    which can conflict with char $ac_func (); below.
10119 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10120 >    <limits.h> exists even on freestanding compilers.  */
10121 >
10122 > #ifdef __STDC__
10123 > # include <limits.h>
10124 > #else
10125 > # include <assert.h>
10126 > #endif
10127 >
10128 > #undef $ac_func
10129 >
10130 > /* Override any gcc2 internal prototype to avoid an error.  */
10131 > #ifdef __cplusplus
10132 > extern "C"
10133 > {
10134 > #endif
10135 > /* We use char because int might match the return type of a gcc2
10136 >   builtin and then its argument prototype would still apply.  */
10137 > char $ac_func ();
10138 > /* The GNU C library defines this for functions which it implements
10139 >    to always fail with ENOSYS.  Some functions are actually named
10140 >    something starting with __ and the normal name is an alias.  */
10141 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10142 > choke me
10143 > #else
10144 > char (*f) () = $ac_func;
10145 > #endif
10146 > #ifdef __cplusplus
10147 > }
10148 > #endif
10149 >
10150 > #ifdef FC_DUMMY_MAIN
10151 > #ifndef FC_DUMMY_MAIN_EQ_F77
10152 > #  ifdef __cplusplus
10153 >     extern "C"
10154 > #  endif
10155 >   int FC_DUMMY_MAIN() { return 1; }
10156 > #endif
10157 > #endif
10158 > int
10159 > main ()
10160 > {
10161 > return f != $ac_func;
10162 >  ;
10163 >  return 0;
10164 > }
10165 > _ACEOF
10166 > rm -f conftest.$ac_objext conftest$ac_exeext
10167 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10168 >  (eval $ac_link) 2>conftest.er1
10169 >  ac_status=$?
10170 >  grep -v '^ *+' conftest.er1 >conftest.err
10171 >  rm -f conftest.er1
10172 >  cat conftest.err >&5
10173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10174 >  (exit $ac_status); } &&
10175 >         { ac_try='test -z "$ac_c_werror_flag"
10176 >                         || test ! -s conftest.err'
10177 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10178 >  (eval $ac_try) 2>&5
10179 >  ac_status=$?
10180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10181 >  (exit $ac_status); }; } &&
10182 >         { ac_try='test -s conftest$ac_exeext'
10183 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10184 >  (eval $ac_try) 2>&5
10185 >  ac_status=$?
10186 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10187 >  (exit $ac_status); }; }; then
10188 >  eval "$as_ac_var=yes"
10189 > else
10190 >  echo "$as_me: failed program was:" >&5
10191 > sed 's/^/| /' conftest.$ac_ext >&5
10192 >
10193 > eval "$as_ac_var=no"
10194 > fi
10195 > rm -f conftest.err conftest.$ac_objext \
10196 >      conftest$ac_exeext conftest.$ac_ext
10197 > fi
10198 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10199 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10200 > if test `eval echo '${'$as_ac_var'}'` = yes; then
10201 >  cat >>confdefs.h <<_ACEOF
10202 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10203 > _ACEOF
10204 >
10205 > else
10206 >  # FreeBSD has a gnugetopt library for this
10207 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10208 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10209 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10210 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10211 > else
10212 >  ac_check_lib_save_LIBS=$LIBS
10213 > LIBS="-lgnugetopt  $LIBS"
10214 > cat >conftest.$ac_ext <<_ACEOF
10215 > /* confdefs.h.  */
10216 > _ACEOF
10217 > cat confdefs.h >>conftest.$ac_ext
10218 > cat >>conftest.$ac_ext <<_ACEOF
10219 > /* end confdefs.h.  */
10220 >
10221 > /* Override any gcc2 internal prototype to avoid an error.  */
10222 > #ifdef __cplusplus
10223 > extern "C"
10224 > #endif
10225 > /* We use char because int might match the return type of a gcc2
10226 >   builtin and then its argument prototype would still apply.  */
10227 > char getopt_long ();
10228 > #ifdef FC_DUMMY_MAIN
10229 > #ifndef FC_DUMMY_MAIN_EQ_F77
10230 > #  ifdef __cplusplus
10231 >     extern "C"
10232 > #  endif
10233 >   int FC_DUMMY_MAIN() { return 1; }
10234 > #endif
10235 > #endif
10236 > int
10237 > main ()
10238 > {
10239 > getopt_long ();
10240 >  ;
10241 >  return 0;
10242 > }
10243 > _ACEOF
10244 > rm -f conftest.$ac_objext conftest$ac_exeext
10245 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10246 >  (eval $ac_link) 2>conftest.er1
10247 >  ac_status=$?
10248 >  grep -v '^ *+' conftest.er1 >conftest.err
10249 >  rm -f conftest.er1
10250 >  cat conftest.err >&5
10251 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10252 >  (exit $ac_status); } &&
10253 >         { ac_try='test -z "$ac_c_werror_flag"
10254 >                         || test ! -s conftest.err'
10255 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10256 >  (eval $ac_try) 2>&5
10257 >  ac_status=$?
10258 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10259 >  (exit $ac_status); }; } &&
10260 >         { ac_try='test -s conftest$ac_exeext'
10261 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10262 >  (eval $ac_try) 2>&5
10263 >  ac_status=$?
10264 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10265 >  (exit $ac_status); }; }; then
10266 >  ac_cv_lib_gnugetopt_getopt_long=yes
10267 > else
10268 >  echo "$as_me: failed program was:" >&5
10269 > sed 's/^/| /' conftest.$ac_ext >&5
10270 >
10271 > ac_cv_lib_gnugetopt_getopt_long=no
10272 > fi
10273 > rm -f conftest.err conftest.$ac_objext \
10274 >      conftest$ac_exeext conftest.$ac_ext
10275 > LIBS=$ac_check_lib_save_LIBS
10276 > fi
10277 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10278 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10279 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10280 >  cat >>confdefs.h <<\_ACEOF
10281 > #define HAVE_GETOPT_LONG 1
10282 > _ACEOF
10283 >
10284 > else
10285 >  # use the GNU replacement
10286 >      case $LIBOBJS in
10287 >    "getopt.$ac_objext"   | \
10288 >  *" getopt.$ac_objext"   | \
10289 >    "getopt.$ac_objext "* | \
10290 >  *" getopt.$ac_objext "* ) ;;
10291 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10292 > esac
10293 >
10294 >      case $LIBOBJS in
10295 >    "getopt1.$ac_objext"   | \
10296 >  *" getopt1.$ac_objext"   | \
10297 >    "getopt1.$ac_objext "* | \
10298 >  *" getopt1.$ac_objext "* ) ;;
10299 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10300 > esac
10301 >
10302 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10303 >
10304 > fi
10305 >
10306 > fi
10307 > done
10308 >
10309 >
10310 > ac_ext=cc
10311 > ac_cpp='$CXXCPP $CPPFLAGS'
10312 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10313 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10314 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10315 >
10316 >
10317 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10318 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10319 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10320 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10321 > else
10322 >
10323 >
10324 > ac_ext=cc
10325 > ac_cpp='$CXXCPP $CPPFLAGS'
10326 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10327 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10328 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10329 >
10330 > cat >conftest.$ac_ext <<_ACEOF
10331 > /* confdefs.h.  */
10332 > _ACEOF
10333 > cat confdefs.h >>conftest.$ac_ext
10334 > cat >>conftest.$ac_ext <<_ACEOF
10335 > /* end confdefs.h.  */
10336 > namespace Outer { namespace Inner { int i = 0; }}
10337 > #ifdef FC_DUMMY_MAIN
10338 > #ifndef FC_DUMMY_MAIN_EQ_F77
10339 > #  ifdef __cplusplus
10340 >     extern "C"
10341 > #  endif
10342 >   int FC_DUMMY_MAIN() { return 1; }
10343 > #endif
10344 > #endif
10345 > int
10346 > main ()
10347 > {
10348 > using namespace Outer::Inner; return i;
10349 >  ;
10350 >  return 0;
10351 > }
10352 > _ACEOF
10353 > rm -f conftest.$ac_objext
10354 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10355 >  (eval $ac_compile) 2>conftest.er1
10356 >  ac_status=$?
10357 >  grep -v '^ *+' conftest.er1 >conftest.err
10358 >  rm -f conftest.er1
10359 >  cat conftest.err >&5
10360 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10361 >  (exit $ac_status); } &&
10362 >         { ac_try='test -z "$ac_cxx_werror_flag"
10363 >                         || test ! -s conftest.err'
10364 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10365 >  (eval $ac_try) 2>&5
10366 >  ac_status=$?
10367 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10368 >  (exit $ac_status); }; } &&
10369 >         { ac_try='test -s conftest.$ac_objext'
10370 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10371 >  (eval $ac_try) 2>&5
10372 >  ac_status=$?
10373 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10374 >  (exit $ac_status); }; }; then
10375 >  ac_cv_cxx_namespaces=yes
10376 > else
10377 >  echo "$as_me: failed program was:" >&5
10378 > sed 's/^/| /' conftest.$ac_ext >&5
10379 >
10380 > ac_cv_cxx_namespaces=no
10381 > fi
10382 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10383 > ac_ext=cc
10384 > ac_cpp='$CXXCPP $CPPFLAGS'
10385 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10386 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10387 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10388 >
10389 >
10390 > fi
10391 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10392 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10393 > if test "$ac_cv_cxx_namespaces" = yes; then
10394 >
10395 > cat >>confdefs.h <<\_ACEOF
10396 > #define HAVE_NAMESPACES
10397 > _ACEOF
10398 >
10399 > fi
10400 >
10401 > ac_ext=cc
10402 > ac_cpp='$CXXCPP $CPPFLAGS'
10403 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10404 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10405 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10406 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10407 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10408 > if test -z "$CXXCPP"; then
10409 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10410 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10411 > else
10412 >      # Double quotes because CXXCPP needs to be expanded
10413 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10414 >    do
10415 >      ac_preproc_ok=false
10416 > for ac_cxx_preproc_warn_flag in '' yes
10417 > do
10418 >  # Use a header file that comes with gcc, so configuring glibc
10419 >  # with a fresh cross-compiler works.
10420 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10421 >  # <limits.h> exists even on freestanding compilers.
10422 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10423 >  # not just through cpp. "Syntax error" is here to catch this case.
10424 >  cat >conftest.$ac_ext <<_ACEOF
10425 > /* confdefs.h.  */
10426 > _ACEOF
10427 > cat confdefs.h >>conftest.$ac_ext
10428 > cat >>conftest.$ac_ext <<_ACEOF
10429 > /* end confdefs.h.  */
10430 > #ifdef __STDC__
10431 > # include <limits.h>
10432 > #else
10433 > # include <assert.h>
10434 > #endif
10435 >                     Syntax error
10436 > _ACEOF
10437 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10438 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10439 >  ac_status=$?
10440 >  grep -v '^ *+' conftest.er1 >conftest.err
10441 >  rm -f conftest.er1
10442 >  cat conftest.err >&5
10443 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10444 >  (exit $ac_status); } >/dev/null; then
10445 >  if test -s conftest.err; then
10446 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10447 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10448 >  else
10449 >    ac_cpp_err=
10450 >  fi
10451 > else
10452 >  ac_cpp_err=yes
10453 > fi
10454 > if test -z "$ac_cpp_err"; then
10455 >  :
10456 > else
10457 >  echo "$as_me: failed program was:" >&5
10458 > sed 's/^/| /' conftest.$ac_ext >&5
10459 >
10460 >  # Broken: fails on valid input.
10461 > continue
10462 > fi
10463 > rm -f conftest.err conftest.$ac_ext
10464 >
10465 >  # OK, works on sane cases.  Now check whether non-existent headers
10466 >  # can be detected and how.
10467 >  cat >conftest.$ac_ext <<_ACEOF
10468 > /* confdefs.h.  */
10469 > _ACEOF
10470 > cat confdefs.h >>conftest.$ac_ext
10471 > cat >>conftest.$ac_ext <<_ACEOF
10472 > /* end confdefs.h.  */
10473 > #include <ac_nonexistent.h>
10474 > _ACEOF
10475 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10476 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10477 >  ac_status=$?
10478 >  grep -v '^ *+' conftest.er1 >conftest.err
10479 >  rm -f conftest.er1
10480 >  cat conftest.err >&5
10481 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10482 >  (exit $ac_status); } >/dev/null; then
10483 >  if test -s conftest.err; then
10484 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10485 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10486 >  else
10487 >    ac_cpp_err=
10488 >  fi
10489 > else
10490 >  ac_cpp_err=yes
10491 > fi
10492 > if test -z "$ac_cpp_err"; then
10493 >  # Broken: success on invalid input.
10494 > continue
10495 > else
10496 >  echo "$as_me: failed program was:" >&5
10497 > sed 's/^/| /' conftest.$ac_ext >&5
10498 >
10499 >  # Passes both tests.
10500 > ac_preproc_ok=:
10501 > break
10502 > fi
10503 > rm -f conftest.err conftest.$ac_ext
10504 >
10505 > done
10506 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10507 > rm -f conftest.err conftest.$ac_ext
10508 > if $ac_preproc_ok; then
10509 >  break
10510 > fi
10511 >
10512 >    done
10513 >    ac_cv_prog_CXXCPP=$CXXCPP
10514 >
10515 > fi
10516 >  CXXCPP=$ac_cv_prog_CXXCPP
10517 > else
10518 >  ac_cv_prog_CXXCPP=$CXXCPP
10519 > fi
10520 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10521 > echo "${ECHO_T}$CXXCPP" >&6
10522 > ac_preproc_ok=false
10523 > for ac_cxx_preproc_warn_flag in '' yes
10524 > do
10525 >  # Use a header file that comes with gcc, so configuring glibc
10526 >  # with a fresh cross-compiler works.
10527 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10528 >  # <limits.h> exists even on freestanding compilers.
10529 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10530 >  # not just through cpp. "Syntax error" is here to catch this case.
10531 >  cat >conftest.$ac_ext <<_ACEOF
10532 > /* confdefs.h.  */
10533 > _ACEOF
10534 > cat confdefs.h >>conftest.$ac_ext
10535 > cat >>conftest.$ac_ext <<_ACEOF
10536 > /* end confdefs.h.  */
10537 > #ifdef __STDC__
10538 > # include <limits.h>
10539 > #else
10540 > # include <assert.h>
10541 > #endif
10542 >                     Syntax error
10543 > _ACEOF
10544 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10545 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10546 >  ac_status=$?
10547 >  grep -v '^ *+' conftest.er1 >conftest.err
10548 >  rm -f conftest.er1
10549 >  cat conftest.err >&5
10550 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10551 >  (exit $ac_status); } >/dev/null; then
10552 >  if test -s conftest.err; then
10553 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10554 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10555 >  else
10556 >    ac_cpp_err=
10557 >  fi
10558 > else
10559 >  ac_cpp_err=yes
10560 > fi
10561 > if test -z "$ac_cpp_err"; then
10562 >  :
10563 > else
10564 >  echo "$as_me: failed program was:" >&5
10565 > sed 's/^/| /' conftest.$ac_ext >&5
10566 >
10567 >  # Broken: fails on valid input.
10568 > continue
10569 > fi
10570 > rm -f conftest.err conftest.$ac_ext
10571 >
10572 >  # OK, works on sane cases.  Now check whether non-existent headers
10573 >  # can be detected and how.
10574 >  cat >conftest.$ac_ext <<_ACEOF
10575 > /* confdefs.h.  */
10576 > _ACEOF
10577 > cat confdefs.h >>conftest.$ac_ext
10578 > cat >>conftest.$ac_ext <<_ACEOF
10579 > /* end confdefs.h.  */
10580 > #include <ac_nonexistent.h>
10581 > _ACEOF
10582 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10583 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10584 >  ac_status=$?
10585 >  grep -v '^ *+' conftest.er1 >conftest.err
10586 >  rm -f conftest.er1
10587 >  cat conftest.err >&5
10588 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589 >  (exit $ac_status); } >/dev/null; then
10590 >  if test -s conftest.err; then
10591 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10592 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10593 >  else
10594 >    ac_cpp_err=
10595 >  fi
10596 > else
10597 >  ac_cpp_err=yes
10598 > fi
10599 > if test -z "$ac_cpp_err"; then
10600 >  # Broken: success on invalid input.
10601 > continue
10602 > else
10603 >  echo "$as_me: failed program was:" >&5
10604 > sed 's/^/| /' conftest.$ac_ext >&5
10605 >
10606 >  # Passes both tests.
10607 > ac_preproc_ok=:
10608 > break
10609 > fi
10610 > rm -f conftest.err conftest.$ac_ext
10611 >
10612 > done
10613 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10614 > rm -f conftest.err conftest.$ac_ext
10615 > if $ac_preproc_ok; then
10616 >  :
10617 > else
10618 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10619 > See \`config.log' for more details." >&5
10620 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10621 > See \`config.log' for more details." >&2;}
10622 >   { (exit 1); exit 1; }; }
10623 > fi
10624 >
10625 > ac_ext=cc
10626 > ac_cpp='$CXXCPP $CPPFLAGS'
10627 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10628 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10629 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10630 >
10631 >
10632 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10633 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10634 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10635 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10636 > else
10637 >
10638 >
10639 >
10640 > ac_ext=cc
10641 > ac_cpp='$CXXCPP $CPPFLAGS'
10642 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10643 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10644 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10645 >
10646 > cat >conftest.$ac_ext <<_ACEOF
10647 > /* confdefs.h.  */
10648 > _ACEOF
10649 > cat confdefs.h >>conftest.$ac_ext
10650 > cat >>conftest.$ac_ext <<_ACEOF
10651 > /* end confdefs.h.  */
10652 > #include <list>
10653 > #include <deque>
10654 > #ifdef HAVE_NAMESPACES
10655 > using namespace std;
10656 > #endif
10657 > #ifdef FC_DUMMY_MAIN
10658 > #ifndef FC_DUMMY_MAIN_EQ_F77
10659 > #  ifdef __cplusplus
10660 >     extern "C"
10661 > #  endif
10662 >   int FC_DUMMY_MAIN() { return 1; }
10663 > #endif
10664 > #endif
10665 > int
10666 > main ()
10667 > {
10668 > list<int> x; x.push_back(5);
10669 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10670 >  ;
10671 >  return 0;
10672 > }
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_cv_cxx_have_stl=yes
10697 > else
10698 >  echo "$as_me: failed program was:" >&5
10699 > sed 's/^/| /' conftest.$ac_ext >&5
10700 >
10701 > ac_cv_cxx_have_stl=no
10702 > fi
10703 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10704 > ac_ext=cc
10705 > ac_cpp='$CXXCPP $CPPFLAGS'
10706 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10707 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10708 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10709 >
10710 >
10711 > fi
10712 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10713 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10714 > if test "$ac_cv_cxx_have_stl" = yes; then
10715 >
10716 > cat >>confdefs.h <<\_ACEOF
10717 > #define HAVE_STL
10718 > _ACEOF
10719 >
10720 > fi
10721 >
10722 >
10723 >
10724 >  if test "${ac_cv_header_iostream+set}" = set; then
10725 >  echo "$as_me:$LINENO: checking for iostream" >&5
10726 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10727 > if test "${ac_cv_header_iostream+set}" = set; then
10728 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10729 > fi
10730 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10731 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10732 > else
10733 >  # Is the header compilable?
10734 > echo "$as_me:$LINENO: checking iostream usability" >&5
10735 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10736 > cat >conftest.$ac_ext <<_ACEOF
10737 > /* confdefs.h.  */
10738 > _ACEOF
10739 > cat confdefs.h >>conftest.$ac_ext
10740 > cat >>conftest.$ac_ext <<_ACEOF
10741 > /* end confdefs.h.  */
10742 > $ac_includes_default
10743 > #include <iostream>
10744 > _ACEOF
10745 > rm -f conftest.$ac_objext
10746 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10747 >  (eval $ac_compile) 2>conftest.er1
10748 >  ac_status=$?
10749 >  grep -v '^ *+' conftest.er1 >conftest.err
10750 >  rm -f conftest.er1
10751 >  cat conftest.err >&5
10752 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10753 >  (exit $ac_status); } &&
10754 >         { ac_try='test -z "$ac_cxx_werror_flag"
10755 >                         || test ! -s conftest.err'
10756 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10757 >  (eval $ac_try) 2>&5
10758 >  ac_status=$?
10759 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10760 >  (exit $ac_status); }; } &&
10761 >         { ac_try='test -s conftest.$ac_objext'
10762 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10763 >  (eval $ac_try) 2>&5
10764 >  ac_status=$?
10765 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10766 >  (exit $ac_status); }; }; then
10767 >  ac_header_compiler=yes
10768 > else
10769 >  echo "$as_me: failed program was:" >&5
10770 > sed 's/^/| /' conftest.$ac_ext >&5
10771 >
10772 > ac_header_compiler=no
10773 > fi
10774 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10775 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10776 > echo "${ECHO_T}$ac_header_compiler" >&6
10777 >
10778 > # Is the header present?
10779 > echo "$as_me:$LINENO: checking iostream presence" >&5
10780 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10781 > cat >conftest.$ac_ext <<_ACEOF
10782 > /* confdefs.h.  */
10783 > _ACEOF
10784 > cat confdefs.h >>conftest.$ac_ext
10785 > cat >>conftest.$ac_ext <<_ACEOF
10786 > /* end confdefs.h.  */
10787 > #include <iostream>
10788 > _ACEOF
10789 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10790 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10791 >  ac_status=$?
10792 >  grep -v '^ *+' conftest.er1 >conftest.err
10793 >  rm -f conftest.er1
10794 >  cat conftest.err >&5
10795 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10796 >  (exit $ac_status); } >/dev/null; then
10797 >  if test -s conftest.err; then
10798 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10799 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10800 >  else
10801 >    ac_cpp_err=
10802 >  fi
10803 > else
10804 >  ac_cpp_err=yes
10805 > fi
10806 > if test -z "$ac_cpp_err"; then
10807 >  ac_header_preproc=yes
10808 > else
10809 >  echo "$as_me: failed program was:" >&5
10810 > sed 's/^/| /' conftest.$ac_ext >&5
10811 >
10812 >  ac_header_preproc=no
10813 > fi
10814 > rm -f conftest.err conftest.$ac_ext
10815 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10816 > echo "${ECHO_T}$ac_header_preproc" >&6
10817 >
10818 > # So?  What about this header?
10819 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10820 >  yes:no: )
10821 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10822 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10823 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10824 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10825 >    ac_header_preproc=yes
10826 >    ;;
10827 >  no:yes:* )
10828 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10829 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10830 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10831 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10832 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10833 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10834 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10835 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10836 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10837 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10838 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10839 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10840 >    (
10841 >      cat <<\_ASBOX
10842 > ## ------------------------------ ##
10843 > ## Report this to gezelter@nd.edu ##
10844 > ## ------------------------------ ##
10845 > _ASBOX
10846 >    ) |
10847 >      sed "s/^/$as_me: WARNING:     /" >&2
10848 >    ;;
10849 > esac
10850 > echo "$as_me:$LINENO: checking for iostream" >&5
10851 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10852 > if test "${ac_cv_header_iostream+set}" = set; then
10853 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10854 > else
10855 >  ac_cv_header_iostream=$ac_header_preproc
10856 > fi
10857 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10858 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10859 >
10860 > fi
10861 > if test $ac_cv_header_iostream = yes; then
10862 >
10863 >
10864 > cat >>confdefs.h <<\_ACEOF
10865 > #define HAVE_IOSTREAM 1
10866 > _ACEOF
10867 >
10868 >
10869 > else
10870 >
10871 >
10872 > for ac_header in iostream.h
10873 > do
10874 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10875 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10876 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10877 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10878 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10879 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10880 > fi
10881 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10882 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10883 > else
10884 >  # Is the header compilable?
10885 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10886 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10887 > cat >conftest.$ac_ext <<_ACEOF
10888 > /* confdefs.h.  */
10889 > _ACEOF
10890 > cat confdefs.h >>conftest.$ac_ext
10891 > cat >>conftest.$ac_ext <<_ACEOF
10892 > /* end confdefs.h.  */
10893 > $ac_includes_default
10894 > #include <$ac_header>
10895 > _ACEOF
10896 > rm -f conftest.$ac_objext
10897 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10898 >  (eval $ac_compile) 2>conftest.er1
10899 >  ac_status=$?
10900 >  grep -v '^ *+' conftest.er1 >conftest.err
10901 >  rm -f conftest.er1
10902 >  cat conftest.err >&5
10903 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10904 >  (exit $ac_status); } &&
10905 >         { ac_try='test -z "$ac_cxx_werror_flag"
10906 >                         || test ! -s conftest.err'
10907 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10908 >  (eval $ac_try) 2>&5
10909 >  ac_status=$?
10910 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10911 >  (exit $ac_status); }; } &&
10912 >         { ac_try='test -s conftest.$ac_objext'
10913 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10914 >  (eval $ac_try) 2>&5
10915 >  ac_status=$?
10916 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10917 >  (exit $ac_status); }; }; then
10918 >  ac_header_compiler=yes
10919 > else
10920 >  echo "$as_me: failed program was:" >&5
10921 > sed 's/^/| /' conftest.$ac_ext >&5
10922 >
10923 > ac_header_compiler=no
10924 > fi
10925 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10926 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10927 > echo "${ECHO_T}$ac_header_compiler" >&6
10928 >
10929 > # Is the header present?
10930 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10931 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10932 > cat >conftest.$ac_ext <<_ACEOF
10933 > /* confdefs.h.  */
10934 > _ACEOF
10935 > cat confdefs.h >>conftest.$ac_ext
10936 > cat >>conftest.$ac_ext <<_ACEOF
10937 > /* end confdefs.h.  */
10938 > #include <$ac_header>
10939 > _ACEOF
10940 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10941 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10942 >  ac_status=$?
10943 >  grep -v '^ *+' conftest.er1 >conftest.err
10944 >  rm -f conftest.er1
10945 >  cat conftest.err >&5
10946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10947 >  (exit $ac_status); } >/dev/null; then
10948 >  if test -s conftest.err; then
10949 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10950 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10951 >  else
10952 >    ac_cpp_err=
10953 >  fi
10954 > else
10955 >  ac_cpp_err=yes
10956 > fi
10957 > if test -z "$ac_cpp_err"; then
10958 >  ac_header_preproc=yes
10959 > else
10960 >  echo "$as_me: failed program was:" >&5
10961 > sed 's/^/| /' conftest.$ac_ext >&5
10962 >
10963 >  ac_header_preproc=no
10964 > fi
10965 > rm -f conftest.err conftest.$ac_ext
10966 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10967 > echo "${ECHO_T}$ac_header_preproc" >&6
10968 >
10969 > # So?  What about this header?
10970 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10971 >  yes:no: )
10972 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10973 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10974 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10975 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10976 >    ac_header_preproc=yes
10977 >    ;;
10978 >  no:yes:* )
10979 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10980 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10981 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10982 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10983 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10984 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10985 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10986 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10987 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10988 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10989 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10990 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10991 >    (
10992 >      cat <<\_ASBOX
10993 > ## ------------------------------ ##
10994 > ## Report this to gezelter@nd.edu ##
10995 > ## ------------------------------ ##
10996 > _ASBOX
10997 >    ) |
10998 >      sed "s/^/$as_me: WARNING:     /" >&2
10999 >    ;;
11000 > esac
11001 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11002 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11003 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11004 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11005 > else
11006 >  eval "$as_ac_Header=\$ac_header_preproc"
11007 > fi
11008 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11009 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11010 >
11011 > fi
11012 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11013 >  cat >>confdefs.h <<_ACEOF
11014 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11015 > _ACEOF
11016 >
11017 > fi
11018 >
11019 > done
11020 >
11021 >
11022 > fi
11023 >
11024 >
11025 >
11026 >
11027 >  if test "${ac_cv_header_iomanip+set}" = set; then
11028 >  echo "$as_me:$LINENO: checking for iomanip" >&5
11029 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11030 > if test "${ac_cv_header_iomanip+set}" = set; then
11031 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11032 > fi
11033 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11034 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11035 > else
11036 >  # Is the header compilable?
11037 > echo "$as_me:$LINENO: checking iomanip usability" >&5
11038 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
11039 > cat >conftest.$ac_ext <<_ACEOF
11040 > /* confdefs.h.  */
11041 > _ACEOF
11042 > cat confdefs.h >>conftest.$ac_ext
11043 > cat >>conftest.$ac_ext <<_ACEOF
11044 > /* end confdefs.h.  */
11045 > $ac_includes_default
11046 > #include <iomanip>
11047 > _ACEOF
11048 > rm -f conftest.$ac_objext
11049 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11050 >  (eval $ac_compile) 2>conftest.er1
11051 >  ac_status=$?
11052 >  grep -v '^ *+' conftest.er1 >conftest.err
11053 >  rm -f conftest.er1
11054 >  cat conftest.err >&5
11055 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11056 >  (exit $ac_status); } &&
11057 >         { ac_try='test -z "$ac_cxx_werror_flag"
11058 >                         || test ! -s conftest.err'
11059 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11060 >  (eval $ac_try) 2>&5
11061 >  ac_status=$?
11062 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11063 >  (exit $ac_status); }; } &&
11064 >         { ac_try='test -s conftest.$ac_objext'
11065 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11066 >  (eval $ac_try) 2>&5
11067 >  ac_status=$?
11068 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11069 >  (exit $ac_status); }; }; then
11070 >  ac_header_compiler=yes
11071 > else
11072 >  echo "$as_me: failed program was:" >&5
11073 > sed 's/^/| /' conftest.$ac_ext >&5
11074 >
11075 > ac_header_compiler=no
11076 > fi
11077 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11078 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11079 > echo "${ECHO_T}$ac_header_compiler" >&6
11080 >
11081 > # Is the header present?
11082 > echo "$as_me:$LINENO: checking iomanip presence" >&5
11083 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11084 > cat >conftest.$ac_ext <<_ACEOF
11085 > /* confdefs.h.  */
11086 > _ACEOF
11087 > cat confdefs.h >>conftest.$ac_ext
11088 > cat >>conftest.$ac_ext <<_ACEOF
11089 > /* end confdefs.h.  */
11090 > #include <iomanip>
11091 > _ACEOF
11092 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11093 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11094 >  ac_status=$?
11095 >  grep -v '^ *+' conftest.er1 >conftest.err
11096 >  rm -f conftest.er1
11097 >  cat conftest.err >&5
11098 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11099 >  (exit $ac_status); } >/dev/null; then
11100 >  if test -s conftest.err; then
11101 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11102 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11103 >  else
11104 >    ac_cpp_err=
11105 >  fi
11106 > else
11107 >  ac_cpp_err=yes
11108 > fi
11109 > if test -z "$ac_cpp_err"; then
11110 >  ac_header_preproc=yes
11111 > else
11112 >  echo "$as_me: failed program was:" >&5
11113 > sed 's/^/| /' conftest.$ac_ext >&5
11114 >
11115 >  ac_header_preproc=no
11116 > fi
11117 > rm -f conftest.err conftest.$ac_ext
11118 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11119 > echo "${ECHO_T}$ac_header_preproc" >&6
11120 >
11121 > # So?  What about this header?
11122 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11123 >  yes:no: )
11124 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11125 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11126 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11127 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11128 >    ac_header_preproc=yes
11129 >    ;;
11130 >  no:yes:* )
11131 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11132 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11133 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11134 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11135 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11136 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11137 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11138 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11139 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11140 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11141 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11142 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11143 >    (
11144 >      cat <<\_ASBOX
11145 > ## ------------------------------ ##
11146 > ## Report this to gezelter@nd.edu ##
11147 > ## ------------------------------ ##
11148 > _ASBOX
11149 >    ) |
11150 >      sed "s/^/$as_me: WARNING:     /" >&2
11151 >    ;;
11152 > esac
11153 > echo "$as_me:$LINENO: checking for iomanip" >&5
11154 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11155 > if test "${ac_cv_header_iomanip+set}" = set; then
11156 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11157 > else
11158 >  ac_cv_header_iomanip=$ac_header_preproc
11159 > fi
11160 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11161 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11162 >
11163 > fi
11164 > if test $ac_cv_header_iomanip = yes; then
11165 >
11166 >
11167 > cat >>confdefs.h <<\_ACEOF
11168 > #define HAVE_IOMANIP 1
11169 > _ACEOF
11170 >
11171 >
11172 > else
11173 >
11174 >
11175 > for ac_header in iomanip.h
11176 > do
11177 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11178 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11179 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11180 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11181 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11182 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11183 > fi
11184 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11185 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11186 > else
11187 >  # Is the header compilable?
11188 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11189 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11190 > cat >conftest.$ac_ext <<_ACEOF
11191 > /* confdefs.h.  */
11192 > _ACEOF
11193 > cat confdefs.h >>conftest.$ac_ext
11194 > cat >>conftest.$ac_ext <<_ACEOF
11195 > /* end confdefs.h.  */
11196 > $ac_includes_default
11197 > #include <$ac_header>
11198 > _ACEOF
11199 > rm -f conftest.$ac_objext
11200 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11201 >  (eval $ac_compile) 2>conftest.er1
11202 >  ac_status=$?
11203 >  grep -v '^ *+' conftest.er1 >conftest.err
11204 >  rm -f conftest.er1
11205 >  cat conftest.err >&5
11206 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11207 >  (exit $ac_status); } &&
11208 >         { ac_try='test -z "$ac_cxx_werror_flag"
11209 >                         || test ! -s conftest.err'
11210 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11211 >  (eval $ac_try) 2>&5
11212 >  ac_status=$?
11213 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11214 >  (exit $ac_status); }; } &&
11215 >         { ac_try='test -s conftest.$ac_objext'
11216 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11217 >  (eval $ac_try) 2>&5
11218 >  ac_status=$?
11219 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11220 >  (exit $ac_status); }; }; then
11221 >  ac_header_compiler=yes
11222 > else
11223 >  echo "$as_me: failed program was:" >&5
11224 > sed 's/^/| /' conftest.$ac_ext >&5
11225 >
11226 > ac_header_compiler=no
11227 > fi
11228 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11229 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11230 > echo "${ECHO_T}$ac_header_compiler" >&6
11231 >
11232 > # Is the header present?
11233 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11234 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11235 > cat >conftest.$ac_ext <<_ACEOF
11236 > /* confdefs.h.  */
11237 > _ACEOF
11238 > cat confdefs.h >>conftest.$ac_ext
11239 > cat >>conftest.$ac_ext <<_ACEOF
11240 > /* end confdefs.h.  */
11241 > #include <$ac_header>
11242 > _ACEOF
11243 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11244 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11245 >  ac_status=$?
11246 >  grep -v '^ *+' conftest.er1 >conftest.err
11247 >  rm -f conftest.er1
11248 >  cat conftest.err >&5
11249 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11250 >  (exit $ac_status); } >/dev/null; then
11251 >  if test -s conftest.err; then
11252 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11253 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11254 >  else
11255 >    ac_cpp_err=
11256 >  fi
11257 > else
11258 >  ac_cpp_err=yes
11259 > fi
11260 > if test -z "$ac_cpp_err"; then
11261 >  ac_header_preproc=yes
11262 > else
11263 >  echo "$as_me: failed program was:" >&5
11264 > sed 's/^/| /' conftest.$ac_ext >&5
11265 >
11266 >  ac_header_preproc=no
11267 > fi
11268 > rm -f conftest.err conftest.$ac_ext
11269 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11270 > echo "${ECHO_T}$ac_header_preproc" >&6
11271 >
11272 > # So?  What about this header?
11273 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11274 >  yes:no: )
11275 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11276 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11277 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11278 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11279 >    ac_header_preproc=yes
11280 >    ;;
11281 >  no:yes:* )
11282 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11283 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11284 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11285 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11286 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11287 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11288 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11289 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11290 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11291 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11292 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11293 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11294 >    (
11295 >      cat <<\_ASBOX
11296 > ## ------------------------------ ##
11297 > ## Report this to gezelter@nd.edu ##
11298 > ## ------------------------------ ##
11299 > _ASBOX
11300 >    ) |
11301 >      sed "s/^/$as_me: WARNING:     /" >&2
11302 >    ;;
11303 > esac
11304 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11305 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11306 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11307 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11308 > else
11309 >  eval "$as_ac_Header=\$ac_header_preproc"
11310 > fi
11311 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11312 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11313 >
11314 > fi
11315 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11316 >  cat >>confdefs.h <<_ACEOF
11317 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11318 > _ACEOF
11319 >
11320 > fi
11321 >
11322 > done
11323 >
11324 >
11325 > fi
11326 >
11327 >
11328 >
11329 >
11330 > for ac_header in cmath
11331 > do
11332 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11333 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11334 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11335 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11336 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11337 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11338 > fi
11339 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11340 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11341 > else
11342 >  # Is the header compilable?
11343 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11344 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11345 > cat >conftest.$ac_ext <<_ACEOF
11346 > /* confdefs.h.  */
11347 > _ACEOF
11348 > cat confdefs.h >>conftest.$ac_ext
11349 > cat >>conftest.$ac_ext <<_ACEOF
11350 > /* end confdefs.h.  */
11351 > $ac_includes_default
11352 > #include <$ac_header>
11353 > _ACEOF
11354 > rm -f conftest.$ac_objext
11355 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11356 >  (eval $ac_compile) 2>conftest.er1
11357 >  ac_status=$?
11358 >  grep -v '^ *+' conftest.er1 >conftest.err
11359 >  rm -f conftest.er1
11360 >  cat conftest.err >&5
11361 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11362 >  (exit $ac_status); } &&
11363 >         { ac_try='test -z "$ac_cxx_werror_flag"
11364 >                         || test ! -s conftest.err'
11365 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11366 >  (eval $ac_try) 2>&5
11367 >  ac_status=$?
11368 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11369 >  (exit $ac_status); }; } &&
11370 >         { ac_try='test -s conftest.$ac_objext'
11371 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11372 >  (eval $ac_try) 2>&5
11373 >  ac_status=$?
11374 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11375 >  (exit $ac_status); }; }; then
11376 >  ac_header_compiler=yes
11377 > else
11378 >  echo "$as_me: failed program was:" >&5
11379 > sed 's/^/| /' conftest.$ac_ext >&5
11380 >
11381 > ac_header_compiler=no
11382 > fi
11383 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11384 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11385 > echo "${ECHO_T}$ac_header_compiler" >&6
11386 >
11387 > # Is the header present?
11388 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11389 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11390 > cat >conftest.$ac_ext <<_ACEOF
11391 > /* confdefs.h.  */
11392 > _ACEOF
11393 > cat confdefs.h >>conftest.$ac_ext
11394 > cat >>conftest.$ac_ext <<_ACEOF
11395 > /* end confdefs.h.  */
11396 > #include <$ac_header>
11397 > _ACEOF
11398 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11399 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11400 >  ac_status=$?
11401 >  grep -v '^ *+' conftest.er1 >conftest.err
11402 >  rm -f conftest.er1
11403 >  cat conftest.err >&5
11404 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11405 >  (exit $ac_status); } >/dev/null; then
11406 >  if test -s conftest.err; then
11407 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11408 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11409 >  else
11410 >    ac_cpp_err=
11411 >  fi
11412 > else
11413 >  ac_cpp_err=yes
11414 > fi
11415 > if test -z "$ac_cpp_err"; then
11416 >  ac_header_preproc=yes
11417 > else
11418 >  echo "$as_me: failed program was:" >&5
11419 > sed 's/^/| /' conftest.$ac_ext >&5
11420 >
11421 >  ac_header_preproc=no
11422 > fi
11423 > rm -f conftest.err conftest.$ac_ext
11424 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11425 > echo "${ECHO_T}$ac_header_preproc" >&6
11426 >
11427 > # So?  What about this header?
11428 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11429 >  yes:no: )
11430 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11431 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11432 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11433 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11434 >    ac_header_preproc=yes
11435 >    ;;
11436 >  no:yes:* )
11437 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11438 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11439 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11440 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11441 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11442 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11443 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11444 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11445 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11446 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11447 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11448 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11449 >    (
11450 >      cat <<\_ASBOX
11451 > ## ------------------------------ ##
11452 > ## Report this to gezelter@nd.edu ##
11453 > ## ------------------------------ ##
11454 > _ASBOX
11455 >    ) |
11456 >      sed "s/^/$as_me: WARNING:     /" >&2
11457 >    ;;
11458 > esac
11459 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11460 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11461 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11462 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11463 > else
11464 >  eval "$as_ac_Header=\$ac_header_preproc"
11465 > fi
11466 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11467 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11468 >
11469 > fi
11470 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11471 >  cat >>confdefs.h <<_ACEOF
11472 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11473 > _ACEOF
11474 >
11475 > fi
11476 >
11477 > done
11478 >
11479 >
11480 >
11481 >
11482 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11483 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11484 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11485 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11486 > else
11487 >
11488 >      ac_cv_cxx_have_std_iostream=no
11489 >      ac_cv_cxx_need_use_std_iostream=no
11490 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11491 >
11492 >
11493 >        ac_ext=cc
11494 > ac_cpp='$CXXCPP $CPPFLAGS'
11495 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11496 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11497 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11498 >
11499 >        cat >conftest.$ac_ext <<_ACEOF
11500 > /* confdefs.h.  */
11501 > _ACEOF
11502 > cat confdefs.h >>conftest.$ac_ext
11503 > cat >>conftest.$ac_ext <<_ACEOF
11504 > /* end confdefs.h.  */
11505 >
11506 > #ifdef HAVE_IOSTREAM
11507 > #include <iostream>
11508 > #else
11509 > #include <iostream.h>
11510 > #endif
11511 >
11512 > #ifdef FC_DUMMY_MAIN
11513 > #ifndef FC_DUMMY_MAIN_EQ_F77
11514 > #  ifdef __cplusplus
11515 >     extern "C"
11516 > #  endif
11517 >   int FC_DUMMY_MAIN() { return 1; }
11518 > #endif
11519 > #endif
11520 > int
11521 > main ()
11522 > {
11523 > std::cout<<"Hello World"<<std::endl;return 0;
11524 >  ;
11525 >  return 0;
11526 > }
11527 > _ACEOF
11528 > rm -f conftest.$ac_objext
11529 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11530 >  (eval $ac_compile) 2>conftest.er1
11531 >  ac_status=$?
11532 >  grep -v '^ *+' conftest.er1 >conftest.err
11533 >  rm -f conftest.er1
11534 >  cat conftest.err >&5
11535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11536 >  (exit $ac_status); } &&
11537 >         { ac_try='test -z "$ac_cxx_werror_flag"
11538 >                         || test ! -s conftest.err'
11539 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11540 >  (eval $ac_try) 2>&5
11541 >  ac_status=$?
11542 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11543 >  (exit $ac_status); }; } &&
11544 >         { ac_try='test -s conftest.$ac_objext'
11545 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11546 >  (eval $ac_try) 2>&5
11547 >  ac_status=$?
11548 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11549 >  (exit $ac_status); }; }; then
11550 >  ac_cv_cxx_have_std_iostream=yes
11551 > else
11552 >  echo "$as_me: failed program was:" >&5
11553 > sed 's/^/| /' conftest.$ac_ext >&5
11554 >
11555 > fi
11556 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11557 >        cat >conftest.$ac_ext <<_ACEOF
11558 > /* confdefs.h.  */
11559 > _ACEOF
11560 > cat confdefs.h >>conftest.$ac_ext
11561 > cat >>conftest.$ac_ext <<_ACEOF
11562 > /* end confdefs.h.  */
11563 >
11564 > #define __USE_STD_IOSTREAM 1
11565 > #ifdef HAVE_IOSTREAM
11566 > #include <iostream>
11567 > #else
11568 > #include <iostream.h>
11569 > #endif
11570 >
11571 > #ifdef FC_DUMMY_MAIN
11572 > #ifndef FC_DUMMY_MAIN_EQ_F77
11573 > #  ifdef __cplusplus
11574 >     extern "C"
11575 > #  endif
11576 >   int FC_DUMMY_MAIN() { return 1; }
11577 > #endif
11578 > #endif
11579 > int
11580 > main ()
11581 > {
11582 > std::cout<<"Hello World"<<std::endl;return 0;
11583 >  ;
11584 >  return 0;
11585 > }
11586 > _ACEOF
11587 > rm -f conftest.$ac_objext
11588 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11589 >  (eval $ac_compile) 2>conftest.er1
11590 >  ac_status=$?
11591 >  grep -v '^ *+' conftest.er1 >conftest.err
11592 >  rm -f conftest.er1
11593 >  cat conftest.err >&5
11594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11595 >  (exit $ac_status); } &&
11596 >         { ac_try='test -z "$ac_cxx_werror_flag"
11597 >                         || test ! -s conftest.err'
11598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11599 >  (eval $ac_try) 2>&5
11600 >  ac_status=$?
11601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11602 >  (exit $ac_status); }; } &&
11603 >         { ac_try='test -s conftest.$ac_objext'
11604 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11605 >  (eval $ac_try) 2>&5
11606 >  ac_status=$?
11607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11608 >  (exit $ac_status); }; }; then
11609 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11610 > else
11611 >  echo "$as_me: failed program was:" >&5
11612 > sed 's/^/| /' conftest.$ac_ext >&5
11613 >
11614 > fi
11615 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11616 >        ac_ext=cc
11617 > ac_cpp='$CXXCPP $CPPFLAGS'
11618 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11619 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11620 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11621 >
11622 >      fi
11623 >
11624 > fi
11625 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11626 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11627 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11628 >
11629 > cat >>confdefs.h <<\_ACEOF
11630 > #define HAVE_STD_IOSTREAM 1
11631 > _ACEOF
11632 >
11633 >  fi
11634 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11635 >
11636 > cat >>confdefs.h <<\_ACEOF
11637 > #define __USE_STD_IOSTREAM 1
11638 > _ACEOF
11639 >
11640 >  fi
11641 >
11642 >
11643 >
11644 >
11645 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11646 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11647 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11648 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11649 > else
11650 >
11651 >      ac_cv_cxx_have_std_stl=no
11652 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11653 >
11654 >
11655 >        ac_ext=cc
11656 > ac_cpp='$CXXCPP $CPPFLAGS'
11657 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11658 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11659 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11660 >
11661 >        cat >conftest.$ac_ext <<_ACEOF
11662 > /* confdefs.h.  */
11663 > _ACEOF
11664 > cat confdefs.h >>conftest.$ac_ext
11665 > cat >>conftest.$ac_ext <<_ACEOF
11666 > /* end confdefs.h.  */
11667 > #include <list>
11668 >
11669 > #ifdef FC_DUMMY_MAIN
11670 > #ifndef FC_DUMMY_MAIN_EQ_F77
11671 > #  ifdef __cplusplus
11672 >     extern "C"
11673 > #  endif
11674 >   int FC_DUMMY_MAIN() { return 1; }
11675 > #endif
11676 > #endif
11677 > int
11678 > main ()
11679 > {
11680 > std::list<int> foo;return 0;
11681 >  ;
11682 >  return 0;
11683 > }
11684 > _ACEOF
11685 > rm -f conftest.$ac_objext
11686 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11687 >  (eval $ac_compile) 2>conftest.er1
11688 >  ac_status=$?
11689 >  grep -v '^ *+' conftest.er1 >conftest.err
11690 >  rm -f conftest.er1
11691 >  cat conftest.err >&5
11692 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11693 >  (exit $ac_status); } &&
11694 >         { ac_try='test -z "$ac_cxx_werror_flag"
11695 >                         || test ! -s conftest.err'
11696 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11697 >  (eval $ac_try) 2>&5
11698 >  ac_status=$?
11699 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11700 >  (exit $ac_status); }; } &&
11701 >         { ac_try='test -s conftest.$ac_objext'
11702 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11703 >  (eval $ac_try) 2>&5
11704 >  ac_status=$?
11705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11706 >  (exit $ac_status); }; }; then
11707 >  ac_cv_cxx_have_std_stl=yes
11708 > else
11709 >  echo "$as_me: failed program was:" >&5
11710 > sed 's/^/| /' conftest.$ac_ext >&5
11711 >
11712 > fi
11713 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11714 >        ac_ext=cc
11715 > ac_cpp='$CXXCPP $CPPFLAGS'
11716 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11717 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11718 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11719 >
11720 >      fi
11721 >
11722 > fi
11723 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11724 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11725 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11726 >
11727 > cat >>confdefs.h <<\_ACEOF
11728 > #define HAVE_STD_STL 1
11729 > _ACEOF
11730 >
11731 >  fi
11732 >
11733 >
11734 >
11735 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11736 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11737 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11738 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11739 > else
11740 >
11741 >    ac_cv_cxx_have_fstream_attach=no
11742 >
11743 >
11744 >    ac_ext=cc
11745 > ac_cpp='$CXXCPP $CPPFLAGS'
11746 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749 >
11750 >    cat >conftest.$ac_ext <<_ACEOF
11751 > /* confdefs.h.  */
11752 > _ACEOF
11753 > cat confdefs.h >>conftest.$ac_ext
11754 > cat >>conftest.$ac_ext <<_ACEOF
11755 > /* end confdefs.h.  */
11756 >
11757 > #ifdef HAVE_IOSTREAM
11758 > #include <fstream>
11759 > #else
11760 > #include <fstream.h>
11761 > #endif
11762 > #ifdef HAVE_STD_IOSTREAM
11763 > using namespace std;
11764 > #endif
11765 >
11766 > #ifdef FC_DUMMY_MAIN
11767 > #ifndef FC_DUMMY_MAIN_EQ_F77
11768 > #  ifdef __cplusplus
11769 >     extern "C"
11770 > #  endif
11771 >   int FC_DUMMY_MAIN() { return 1; }
11772 > #endif
11773 > #endif
11774 > int
11775 > main ()
11776 > {
11777 > int fd=0;ofstream s;s.attach(fd);
11778 >  ;
11779 >  return 0;
11780 > }
11781 > _ACEOF
11782 > rm -f conftest.$ac_objext
11783 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11784 >  (eval $ac_compile) 2>conftest.er1
11785 >  ac_status=$?
11786 >  grep -v '^ *+' conftest.er1 >conftest.err
11787 >  rm -f conftest.er1
11788 >  cat conftest.err >&5
11789 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11790 >  (exit $ac_status); } &&
11791 >         { ac_try='test -z "$ac_cxx_werror_flag"
11792 >                         || test ! -s conftest.err'
11793 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11794 >  (eval $ac_try) 2>&5
11795 >  ac_status=$?
11796 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11797 >  (exit $ac_status); }; } &&
11798 >         { ac_try='test -s conftest.$ac_objext'
11799 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11800 >  (eval $ac_try) 2>&5
11801 >  ac_status=$?
11802 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11803 >  (exit $ac_status); }; }; then
11804 >  ac_cv_cxx_have_fstream_attach=yes
11805 > else
11806 >  echo "$as_me: failed program was:" >&5
11807 > sed 's/^/| /' conftest.$ac_ext >&5
11808 >
11809 > fi
11810 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11811 >    ac_ext=cc
11812 > ac_cpp='$CXXCPP $CPPFLAGS'
11813 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11814 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11815 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11816 >
11817 >
11818 > fi
11819 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11820 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11821 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11822 >
11823 > cat >>confdefs.h <<\_ACEOF
11824 > #define HAVE_FSTREAM_ATTACH 1
11825 > _ACEOF
11826 >
11827 >  fi
11828 >
11829 >
11830 >
11831 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11832 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11833 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11834 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11835 > else
11836 >
11837 >    ac_cv_cxx_have_fstream_open=no
11838 >    ac_cv_cxx_fstream_open_prot=no
11839 >
11840 >
11841 >    ac_ext=cc
11842 > ac_cpp='$CXXCPP $CPPFLAGS'
11843 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11844 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11845 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11846 >
11847 >    # Try with 2 parameters
11848 >    cat >conftest.$ac_ext <<_ACEOF
11849 > /* confdefs.h.  */
11850 > _ACEOF
11851 > cat confdefs.h >>conftest.$ac_ext
11852 > cat >>conftest.$ac_ext <<_ACEOF
11853 > /* end confdefs.h.  */
11854 >
11855 > #ifdef HAVE_IOSTREAM
11856 > #include <fstream>
11857 > #else
11858 > #include <fstream.h>
11859 > #endif
11860 > #ifdef HAVE_STD_IOSTREAM
11861 > using namespace std;
11862 > #endif
11863 >
11864 > #ifdef FC_DUMMY_MAIN
11865 > #ifndef FC_DUMMY_MAIN_EQ_F77
11866 > #  ifdef __cplusplus
11867 >     extern "C"
11868 > #  endif
11869 >   int FC_DUMMY_MAIN() { return 1; }
11870 > #endif
11871 > #endif
11872 > int
11873 > main ()
11874 > {
11875 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11876 >  ;
11877 >  return 0;
11878 > }
11879 > _ACEOF
11880 > rm -f conftest.$ac_objext
11881 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11882 >  (eval $ac_compile) 2>conftest.er1
11883 >  ac_status=$?
11884 >  grep -v '^ *+' conftest.er1 >conftest.err
11885 >  rm -f conftest.er1
11886 >  cat conftest.err >&5
11887 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11888 >  (exit $ac_status); } &&
11889 >         { ac_try='test -z "$ac_cxx_werror_flag"
11890 >                         || test ! -s conftest.err'
11891 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11892 >  (eval $ac_try) 2>&5
11893 >  ac_status=$?
11894 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11895 >  (exit $ac_status); }; } &&
11896 >         { ac_try='test -s conftest.$ac_objext'
11897 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11898 >  (eval $ac_try) 2>&5
11899 >  ac_status=$?
11900 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11901 >  (exit $ac_status); }; }; then
11902 >  ac_cv_cxx_have_fstream_open=yes
11903 > else
11904 >  echo "$as_me: failed program was:" >&5
11905 > sed 's/^/| /' conftest.$ac_ext >&5
11906 >
11907 > fi
11908 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11909 >    # Try with mode parameter
11910 >    cat >conftest.$ac_ext <<_ACEOF
11911 > /* confdefs.h.  */
11912 > _ACEOF
11913 > cat confdefs.h >>conftest.$ac_ext
11914 > cat >>conftest.$ac_ext <<_ACEOF
11915 > /* end confdefs.h.  */
11916 >
11917 > #ifdef HAVE_IOSTREAM
11918 > #include <fstream>
11919 > #else
11920 > #include <fstream.h>
11921 > #endif
11922 > #ifdef HAVE_STD_IOSTREAM
11923 > using namespace std;
11924 > #endif
11925 >
11926 > #ifdef FC_DUMMY_MAIN
11927 > #ifndef FC_DUMMY_MAIN_EQ_F77
11928 > #  ifdef __cplusplus
11929 >     extern "C"
11930 > #  endif
11931 >   int FC_DUMMY_MAIN() { return 1; }
11932 > #endif
11933 > #endif
11934 > int
11935 > main ()
11936 > {
11937 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11938 >  ;
11939 >  return 0;
11940 > }
11941 > _ACEOF
11942 > rm -f conftest.$ac_objext
11943 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11944 >  (eval $ac_compile) 2>conftest.er1
11945 >  ac_status=$?
11946 >  grep -v '^ *+' conftest.er1 >conftest.err
11947 >  rm -f conftest.er1
11948 >  cat conftest.err >&5
11949 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11950 >  (exit $ac_status); } &&
11951 >         { ac_try='test -z "$ac_cxx_werror_flag"
11952 >                         || test ! -s conftest.err'
11953 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11954 >  (eval $ac_try) 2>&5
11955 >  ac_status=$?
11956 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11957 >  (exit $ac_status); }; } &&
11958 >         { ac_try='test -s conftest.$ac_objext'
11959 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11960 >  (eval $ac_try) 2>&5
11961 >  ac_status=$?
11962 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11963 >  (exit $ac_status); }; }; then
11964 >  ac_cv_cxx_fstream_open_prot=yes
11965 > else
11966 >  echo "$as_me: failed program was:" >&5
11967 > sed 's/^/| /' conftest.$ac_ext >&5
11968 >
11969 > fi
11970 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11971 >    ac_ext=cc
11972 > ac_cpp='$CXXCPP $CPPFLAGS'
11973 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11974 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11975 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11976 >
11977 >
11978 > fi
11979 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11980 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11981 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11982 >
11983 > cat >>confdefs.h <<\_ACEOF
11984 > #define HAVE_FSTREAM_OPEN 1
11985 > _ACEOF
11986 >
11987 >  fi
11988 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11989 >
11990 > cat >>confdefs.h <<\_ACEOF
11991 > #define FSTREAM_OPEN_PROT 1
11992 > _ACEOF
11993 >
11994 >  fi
11995 >
11996 >
11997 >
11998 >
11999 >
12000 >
12001 >
12002 > for ac_header in ctype.h iostream fstream sstream strstream
12003 > do
12004 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
12005 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
12006 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
12007 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
12008 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
12009 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12010 > fi
12011 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
12012 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
12013 > else
12014 >  # Is the header compilable?
12015 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
12016 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
12017 > cat >conftest.$ac_ext <<_ACEOF
12018 > /* confdefs.h.  */
12019 > _ACEOF
12020 > cat confdefs.h >>conftest.$ac_ext
12021 > cat >>conftest.$ac_ext <<_ACEOF
12022 > /* end confdefs.h.  */
12023 > $ac_includes_default
12024 > #include <$ac_header>
12025 > _ACEOF
12026 > rm -f conftest.$ac_objext
12027 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12028 >  (eval $ac_compile) 2>conftest.er1
12029 >  ac_status=$?
12030 >  grep -v '^ *+' conftest.er1 >conftest.err
12031 >  rm -f conftest.er1
12032 >  cat conftest.err >&5
12033 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12034 >  (exit $ac_status); } &&
12035 >         { ac_try='test -z "$ac_cxx_werror_flag"
12036 >                         || test ! -s conftest.err'
12037 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12038 >  (eval $ac_try) 2>&5
12039 >  ac_status=$?
12040 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12041 >  (exit $ac_status); }; } &&
12042 >         { ac_try='test -s conftest.$ac_objext'
12043 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12044 >  (eval $ac_try) 2>&5
12045 >  ac_status=$?
12046 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12047 >  (exit $ac_status); }; }; then
12048 >  ac_header_compiler=yes
12049 > else
12050 >  echo "$as_me: failed program was:" >&5
12051 > sed 's/^/| /' conftest.$ac_ext >&5
12052 >
12053 > ac_header_compiler=no
12054 > fi
12055 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12056 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12057 > echo "${ECHO_T}$ac_header_compiler" >&6
12058 >
12059 > # Is the header present?
12060 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
12061 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
12062 > cat >conftest.$ac_ext <<_ACEOF
12063 > /* confdefs.h.  */
12064 > _ACEOF
12065 > cat confdefs.h >>conftest.$ac_ext
12066 > cat >>conftest.$ac_ext <<_ACEOF
12067 > /* end confdefs.h.  */
12068 > #include <$ac_header>
12069 > _ACEOF
12070 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
12071 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
12072 >  ac_status=$?
12073 >  grep -v '^ *+' conftest.er1 >conftest.err
12074 >  rm -f conftest.er1
12075 >  cat conftest.err >&5
12076 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12077 >  (exit $ac_status); } >/dev/null; then
12078 >  if test -s conftest.err; then
12079 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
12080 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12081 >  else
12082 >    ac_cpp_err=
12083 >  fi
12084 > else
12085 >  ac_cpp_err=yes
12086 > fi
12087 > if test -z "$ac_cpp_err"; then
12088 >  ac_header_preproc=yes
12089 > else
12090 >  echo "$as_me: failed program was:" >&5
12091 > sed 's/^/| /' conftest.$ac_ext >&5
12092 >
12093 >  ac_header_preproc=no
12094 > fi
12095 > rm -f conftest.err conftest.$ac_ext
12096 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
12097 > echo "${ECHO_T}$ac_header_preproc" >&6
12098 >
12099 > # So?  What about this header?
12100 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12101 >  yes:no: )
12102 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12103 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
12104 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
12105 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
12106 >    ac_header_preproc=yes
12107 >    ;;
12108 >  no:yes:* )
12109 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
12110 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
12111 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
12112 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
12113 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
12114 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
12115 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
12116 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
12117 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12118 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12119 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
12120 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
12121 >    (
12122 >      cat <<\_ASBOX
12123 > ## ------------------------------ ##
12124 > ## Report this to gezelter@nd.edu ##
12125 > ## ------------------------------ ##
12126 > _ASBOX
12127 >    ) |
12128 >      sed "s/^/$as_me: WARNING:     /" >&2
12129 >    ;;
12130 > esac
12131 > echo "$as_me:$LINENO: checking for $ac_header" >&5
12132 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
12133 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
12134 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12135 > else
12136 >  eval "$as_ac_Header=\$ac_header_preproc"
12137 > fi
12138 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
12139 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
12140 >
12141 > fi
12142 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
12143 >  cat >>confdefs.h <<_ACEOF
12144 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
12145 > _ACEOF
12146 >
12147 > fi
12148 >
12149 > done
12150 >
12151 > # AC_CPP_FUNC
12152 > # ------------------ #
12153 > # Checks to see if ANSI C99 CPP variable __func__ works.
12154 > # If not, perhaps __FUNCTION__ works instead.
12155 > # If not, we'll just define __func__ to "".
12156 > # AC_CPP_FUNC
12157 >
12158 >
12159 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12160 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12161 > if test "${ac_cv_cpp_func+set}" = set; then
12162 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12163 > else
12164 >  cat >conftest.$ac_ext <<_ACEOF
12165 > /* confdefs.h.  */
12166 > _ACEOF
12167 > cat confdefs.h >>conftest.$ac_ext
12168 > cat >>conftest.$ac_ext <<_ACEOF
12169 > /* end confdefs.h.  */
12170 >
12171 > #ifdef FC_DUMMY_MAIN
12172 > #ifndef FC_DUMMY_MAIN_EQ_F77
12173 > #  ifdef __cplusplus
12174 >     extern "C"
12175 > #  endif
12176 >   int FC_DUMMY_MAIN() { return 1; }
12177 > #endif
12178 > #endif
12179 > int
12180 > main ()
12181 > {
12182 > const char *foo = __func__;
12183 >  ;
12184 >  return 0;
12185 > }
12186 > _ACEOF
12187 > rm -f conftest.$ac_objext
12188 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12189 >  (eval $ac_compile) 2>conftest.er1
12190 >  ac_status=$?
12191 >  grep -v '^ *+' conftest.er1 >conftest.err
12192 >  rm -f conftest.er1
12193 >  cat conftest.err >&5
12194 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12195 >  (exit $ac_status); } &&
12196 >         { ac_try='test -z "$ac_cxx_werror_flag"
12197 >                         || test ! -s conftest.err'
12198 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12199 >  (eval $ac_try) 2>&5
12200 >  ac_status=$?
12201 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12202 >  (exit $ac_status); }; } &&
12203 >         { ac_try='test -s conftest.$ac_objext'
12204 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12205 >  (eval $ac_try) 2>&5
12206 >  ac_status=$?
12207 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12208 >  (exit $ac_status); }; }; then
12209 >  ac_cv_cpp_func=yes
12210 > else
12211 >  echo "$as_me: failed program was:" >&5
12212 > sed 's/^/| /' conftest.$ac_ext >&5
12213 >
12214 > cat >conftest.$ac_ext <<_ACEOF
12215 > /* confdefs.h.  */
12216 > _ACEOF
12217 > cat confdefs.h >>conftest.$ac_ext
12218 > cat >>conftest.$ac_ext <<_ACEOF
12219 > /* end confdefs.h.  */
12220 >
12221 > #ifdef FC_DUMMY_MAIN
12222 > #ifndef FC_DUMMY_MAIN_EQ_F77
12223 > #  ifdef __cplusplus
12224 >     extern "C"
12225 > #  endif
12226 >   int FC_DUMMY_MAIN() { return 1; }
12227 > #endif
12228 > #endif
12229 > int
12230 > main ()
12231 > {
12232 > const char *foo = __FUNCTION__;
12233 >  ;
12234 >  return 0;
12235 > }
12236 > _ACEOF
12237 > rm -f conftest.$ac_objext
12238 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12239 >  (eval $ac_compile) 2>conftest.er1
12240 >  ac_status=$?
12241 >  grep -v '^ *+' conftest.er1 >conftest.err
12242 >  rm -f conftest.er1
12243 >  cat conftest.err >&5
12244 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12245 >  (exit $ac_status); } &&
12246 >         { ac_try='test -z "$ac_cxx_werror_flag"
12247 >                         || test ! -s conftest.err'
12248 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12249 >  (eval $ac_try) 2>&5
12250 >  ac_status=$?
12251 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12252 >  (exit $ac_status); }; } &&
12253 >         { ac_try='test -s conftest.$ac_objext'
12254 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12255 >  (eval $ac_try) 2>&5
12256 >  ac_status=$?
12257 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12258 >  (exit $ac_status); }; }; then
12259 >  ac_cv_cpp_func=__FUNCTION__
12260 > else
12261 >  echo "$as_me: failed program was:" >&5
12262 > sed 's/^/| /' conftest.$ac_ext >&5
12263 >
12264 > ac_cv_cpp_func=no
12265 > fi
12266 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12267 > fi
12268 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12269 > fi
12270 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12271 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
12272 > if test $ac_cv_cpp_func = __FUNCTION__; then
12273 >
12274 > cat >>confdefs.h <<\_ACEOF
12275 > #define __func__ __FUNCTION__
12276 > _ACEOF
12277 >
12278 > elif test $ac_cv_cpp_func = no; then
12279 >
12280 > cat >>confdefs.h <<\_ACEOF
12281 > #define __func__ ""
12282 > _ACEOF
12283 >
12284 > fi
12285 >
12286 >
12287 >
12288 >
12289 >
12290 > case $debug in
12291 >  1)
12292 >     ;;
12293 >  *)
12294 >
12295 >
12296 >
12297 >
12298 > # Try to determine "good" native compiler flags if none specified on command
12299 > # line
12300 >
12301 > if test "$ac_test_FFLAGS" != "set"; then
12302 >  FCFLAGS=""
12303 >  case "${host_cpu}-${host_os}" in
12304 >
12305 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12306 >                    FCFLAGS="-O3 -ip -no-prec-div"
12307 >                fi;;
12308 >   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12309 >                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12310 >                fi;;
12311 >   powerpc*-aix*)
12312 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12313 >                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12314 >                echo "*******************************************************"
12315 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12316 >                echo "*  recommended that you use                           *"
12317 >                echo "*                                                     *"
12318 >                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12319 >                echo "*                                 ^^^                 *"
12320 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12321 >                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12322 >                echo "*******************************************************"
12323 >        fi;;
12324 >   *darwin*)
12325 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12326 >                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12327 >        fi
12328 >        if test "$FC" = ifort; then
12329 >                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12330 >        fi;;
12331 >  esac
12332 >
12333 >  if test -n "$CPU_FLAGS"; then
12334 >        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12335 >  fi
12336 >
12337 >  if test -z "$FCFLAGS"; then
12338 >        echo ""
12339 >        echo "*********************************************************"
12340 >        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12341 >        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12342 >        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12343 >        echo "*********************************************************"
12344 >        echo ""
12345 >        FCFLAGS="-O3"
12346 >  fi
12347 >
12348 >
12349 > echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12350 > echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12351 > if test "${ac_guessed_f90flags+set}" = set; then
12352 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12353 > else
12354 >
12355 >
12356 >
12357 > ac_ext=${FC_SRCEXT-f}
12358 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12359 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12360 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12361 >
12362 > echo 'program main' > conftest.$ac_ext
12363 > echo 'end program main' >> conftest.$ac_ext
12364 > ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12365 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12366 >  (eval $ac_compile) 2>&5
12367 >  ac_status=$?
12368 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12369 >  (exit $ac_status); }; then
12370 >        ac_guessed_f90flags=yes
12371 > else
12372 >        ac_guessed_f90flags=no
12373 > fi
12374 > rm -f conftest*
12375 > ac_ext=cc
12376 > ac_cpp='$CXXCPP $CPPFLAGS'
12377 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12378 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12379 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12380 >
12381 >
12382 > fi
12383 > echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12384 > echo "${ECHO_T}$ac_guessed_f90flags" >&6
12385 > if test "$ac_guessed_f90flags" = yes; then
12386 >        :
12387 >
12388 > else
12389 >        :
12390 >
12391 >        echo ""
12392 >        echo "**********************************************************"
12393 >        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12394 >        echo "* your compiler.                                        *"
12395 >        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12396 >        echo "*********************************************************"
12397 >        echo ""
12398 >        FCFLAGS=""
12399 >
12400 > fi
12401 >
12402 >
12403 > fi
12404 >
12405 >
12406 >
12407 >
12408 >
12409 >
12410 >
12411 > echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12412 > echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12413 > if test "${ac_cv_prog_really_gcc+set}" = set; then
12414 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12415 > else
12416 >
12417 > cat > conftest.c <<EOF
12418 > #ifdef __GNUC__
12419 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12420 >     no;
12421 >  #else
12422 >     yes;
12423 >  #endif
12424 > #endif
12425 > EOF
12426 > if { ac_try='${CC-cc} -E conftest.c'
12427 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12428 >  (eval $ac_try) 2>&5
12429 >  ac_status=$?
12430 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12431 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12432 >  ac_cv_prog_really_gcc=yes
12433 > else
12434 >  ac_cv_prog_really_gcc=no
12435 > fi
12436 >
12437 > fi
12438 > echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
12439 > echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6
12440 > if test "$ac_cv_prog_really_gcc" = yes; then
12441 >        :
12442 >
12443 > else
12444 >        :
12445 >
12446 > fi
12447 >
12448 >
12449 > # Try to determine "good" native compiler flags if none specified on command
12450 > # line
12451 > if test "$ac_test_CFLAGS" != "set"; then
12452 >  CFLAGS=""
12453 >  case "${host_cpu}-${host_os}" in
12454 >
12455 >  *linux*) if test "$CC" = icc; then
12456 >                    CFLAGS="-O"
12457 >                fi;;
12458 >  sparc-solaris2*) if test "$CC" = cc; then
12459 >                    CFLAGS="-O -dalign"
12460 >                 fi;;
12461 >
12462 >  alpha*-osf*)  if test "$CC" = cc; then
12463 >                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
12464 >                fi;;
12465 >
12466 >  hppa*-hpux*)  if test "$CC" = cc; then
12467 >                    CFLAGS="-Ae +O3 +Oall"
12468 >                fi;;
12469 >
12470 >   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
12471 >                    CFLAGS="-O3 -qtune=auto -qansialias -w"
12472 >                fi;;
12473 >   powerpc*-aix*)
12474 >        if test "$CC" = cc -o "$CC" = xlc; then
12475 >                CFLAGS="-O3 -qtune=auto -qansialias -w"
12476 >                echo "*******************************************************"
12477 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12478 >                echo "*  recommended that you use                           *"
12479 >                echo "*                                                     *"
12480 >                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12481 >                echo "*                                 ^^^                 *"
12482 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12483 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12484 >                echo "*******************************************************"
12485 >        fi;;
12486 >   *darwin*)
12487 >        if test "$CC" = xlc -o "$CC" = cc; then
12488 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12489 >        fi
12490 >        if test "$CC" = icc; then
12491 >                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12492 >        fi;;
12493 >  esac
12494 >
12495 >  # use default flags for gcc on all systems
12496 >  if test $ac_cv_prog_really_gcc = yes; then
12497 >     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12498 >  fi
12499 >
12500 >  # test for gcc-specific flags:
12501 >  if test $ac_cv_prog_really_gcc = yes; then
12502 >    # -malign-double for x86 systems
12503 >
12504 >
12505 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12506 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12507 > if test "${ac_align_double+set}" = set; then
12508 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12509 > else
12510 >  echo 'void f(){}' > conftest.c
12511 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12512 >        ac_align_double=yes
12513 > else
12514 >        ac_align_double=no
12515 > fi
12516 > rm -f conftest*
12517 >
12518 > fi
12519 > echo "$as_me:$LINENO: result: $ac_align_double" >&5
12520 > echo "${ECHO_T}$ac_align_double" >&6
12521 > if test "$ac_align_double" = yes; then
12522 >        :
12523 >        CFLAGS="$CFLAGS -malign-double"
12524 > else
12525 >        :
12526 >
12527 > fi
12528 >
12529 >    # -fstrict-aliasing for gcc-2.95+
12530 >
12531 >
12532 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12533 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12534 > if test "${ac_fstrict_aliasing+set}" = set; then
12535 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12536 > else
12537 >  echo 'void f(){}' > conftest.c
12538 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12539 >        ac_fstrict_aliasing=yes
12540 > else
12541 >        ac_fstrict_aliasing=no
12542 > fi
12543 > rm -f conftest*
12544 >
12545 > fi
12546 > echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
12547 > echo "${ECHO_T}$ac_fstrict_aliasing" >&6
12548 > if test "$ac_fstrict_aliasing" = yes; then
12549 >        :
12550 >        CFLAGS="$CFLAGS -fstrict-aliasing"
12551 > else
12552 >        :
12553 >
12554 > fi
12555 >
12556 >  fi
12557 >
12558 >  CPU_FLAGS=""
12559 >  if test $ac_cv_prog_really_gcc = yes; then
12560 >                  case "${host_cpu}" in
12561 >          i586*)
12562 >
12563 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12564 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12565 > if test "${ac_cpu_pentium+set}" = set; then
12566 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12567 > else
12568 >  echo 'void f(){}' > conftest.c
12569 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12570 >        ac_cpu_pentium=yes
12571 > else
12572 >        ac_cpu_pentium=no
12573 > fi
12574 > rm -f conftest*
12575 >
12576 > fi
12577 > echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
12578 > echo "${ECHO_T}$ac_cpu_pentium" >&6
12579 > if test "$ac_cpu_pentium" = yes; then
12580 >        :
12581 >        CPU_FLAGS=-mcpu=pentium
12582 > else
12583 >        :
12584 >
12585 >
12586 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12587 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12588 > if test "${ac_pentium+set}" = set; then
12589 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12590 > else
12591 >  echo 'void f(){}' > conftest.c
12592 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12593 >        ac_pentium=yes
12594 > else
12595 >        ac_pentium=no
12596 > fi
12597 > rm -f conftest*
12598 >
12599 > fi
12600 > echo "$as_me:$LINENO: result: $ac_pentium" >&5
12601 > echo "${ECHO_T}$ac_pentium" >&6
12602 > if test "$ac_pentium" = yes; then
12603 >        :
12604 >        CPU_FLAGS=-mpentium
12605 > else
12606 >        :
12607 >
12608 > fi
12609 >
12610 > fi
12611 >
12612 >                  ;;
12613 >          i686*)
12614 >
12615 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12616 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12617 > if test "${ac_cpu_pentiumpro+set}" = set; then
12618 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12619 > else
12620 >  echo 'void f(){}' > conftest.c
12621 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12622 >        ac_cpu_pentiumpro=yes
12623 > else
12624 >        ac_cpu_pentiumpro=no
12625 > fi
12626 > rm -f conftest*
12627 >
12628 > fi
12629 > echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
12630 > echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
12631 > if test "$ac_cpu_pentiumpro" = yes; then
12632 >        :
12633 >        CPU_FLAGS=-mcpu=pentiumpro
12634 > else
12635 >        :
12636 >
12637 >
12638 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12639 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12640 > if test "${ac_pentiumpro+set}" = set; then
12641 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12642 > else
12643 >  echo 'void f(){}' > conftest.c
12644 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12645 >        ac_pentiumpro=yes
12646 > else
12647 >        ac_pentiumpro=no
12648 > fi
12649 > rm -f conftest*
12650 >
12651 > fi
12652 > echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
12653 > echo "${ECHO_T}$ac_pentiumpro" >&6
12654 > if test "$ac_pentiumpro" = yes; then
12655 >        :
12656 >        CPU_FLAGS=-mpentiumpro
12657 > else
12658 >        :
12659 >
12660 > fi
12661 >
12662 > fi
12663 >
12664 >                  ;;
12665 >          powerpc*)
12666 >                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
12667 >                is60x=`echo $cputype | egrep "^600-9e?$"`
12668 >                if test -n "$is60x"; then
12669 >
12670 >
12671 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12672 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12673 > if test "${ac_m_cpu_60x+set}" = set; then
12674 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12675 > else
12676 >  echo 'void f(){}' > conftest.c
12677 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12678 >        ac_m_cpu_60x=yes
12679 > else
12680 >        ac_m_cpu_60x=no
12681 > fi
12682 > rm -f conftest*
12683 >
12684 > fi
12685 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
12686 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
12687 > if test "$ac_m_cpu_60x" = yes; then
12688 >        :
12689 >        CPU_FLAGS=-mcpu=$cputype
12690 > else
12691 >        :
12692 >
12693 > fi
12694 >
12695 >                elif test "$cputype" = 750; then
12696 >
12697 >
12698 > echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
12699 > echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6
12700 > if test "${ac_cv_prog_gcc_2_95+set}" = set; then
12701 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12702 > else
12703 >
12704 > cat > conftest.c <<EOF
12705 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12706 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12707 >     yes;
12708 > #  endif
12709 > #endif
12710 > EOF
12711 > if { ac_try='${CC-cc} -E conftest.c'
12712 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12713 >  (eval $ac_try) 2>&5
12714 >  ac_status=$?
12715 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12716 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12717 >  ac_cv_prog_gcc_2_95=yes
12718 > else
12719 >  ac_cv_prog_gcc_2_95=no
12720 > fi
12721 >
12722 > fi
12723 > echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
12724 > echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6
12725 > if test "$ac_cv_prog_gcc_2_95" = yes; then
12726 >        :
12727 >
12728 >
12729 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12730 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12731 > if test "${ac_m_cpu_750+set}" = set; then
12732 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12733 > else
12734 >  echo 'void f(){}' > conftest.c
12735 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12736 >        ac_m_cpu_750=yes
12737 > else
12738 >        ac_m_cpu_750=no
12739 > fi
12740 > rm -f conftest*
12741 >
12742 > fi
12743 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12744 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12745 > if test "$ac_m_cpu_750" = yes; then
12746 >        :
12747 >        CPU_FLAGS=-mcpu=750
12748 > else
12749 >        :
12750 >
12751 > fi
12752 >
12753 > else
12754 >        :
12755 >
12756 > fi
12757 >
12758 >                fi
12759 >                if test -z "$CPU_FLAGS"; then
12760 >
12761 >
12762 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12763 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12764 > if test "${ac_m_cpu_powerpc+set}" = set; then
12765 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12766 > else
12767 >  echo 'void f(){}' > conftest.c
12768 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12769 >        ac_m_cpu_powerpc=yes
12770 > else
12771 >        ac_m_cpu_powerpc=no
12772 > fi
12773 > rm -f conftest*
12774 >
12775 > fi
12776 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12777 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12778 > if test "$ac_m_cpu_powerpc" = yes; then
12779 >        :
12780 >        CPU_FLAGS=-mcpu=powerpc
12781 > else
12782 >        :
12783 >
12784 > fi
12785 >
12786 >                fi
12787 >                if test -z "$CPU_FLAGS"; then
12788 >
12789 >
12790 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12791 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12792 > if test "${ac_m_powerpc+set}" = set; then
12793 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12794 > else
12795 >  echo 'void f(){}' > conftest.c
12796 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12797 >        ac_m_powerpc=yes
12798 > else
12799 >        ac_m_powerpc=no
12800 > fi
12801 > rm -f conftest*
12802 >
12803 > fi
12804 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12805 > echo "${ECHO_T}$ac_m_powerpc" >&6
12806 > if test "$ac_m_powerpc" = yes; then
12807 >        :
12808 >        CPU_FLAGS=-mpowerpc
12809 > else
12810 >        :
12811 >
12812 > fi
12813 >
12814 >                fi
12815 >          esac
12816 >  fi
12817 >
12818 >  if test -n "$CPU_FLAGS"; then
12819 >        CFLAGS="$CFLAGS $CPU_FLAGS"
12820 >  fi
12821 >
12822 >  if test -z "$CFLAGS"; then
12823 >        echo ""
12824 >        echo "********************************************************"
12825 >        echo "* WARNING: Don't know the best CFLAGS for this system  *"
12826 >        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
12827 >        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
12828 >        echo "********************************************************"
12829 >        echo ""
12830 >        CFLAGS="-O3"
12831 >  fi
12832 >
12833 >
12834 >
12835 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12836 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12837 > if test "${ac_guessed_cflags+set}" = set; then
12838 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12839 > else
12840 >  echo 'void f(){}' > conftest.c
12841 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12842 >        ac_guessed_cflags=yes
12843 > else
12844 >        ac_guessed_cflags=no
12845 > fi
12846 > rm -f conftest*
12847 >
12848 > fi
12849 > echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
12850 > echo "${ECHO_T}$ac_guessed_cflags" >&6
12851 > if test "$ac_guessed_cflags" = yes; then
12852 >        :
12853 >
12854 > else
12855 >        :
12856 >
12857 >        echo ""
12858 >        echo "********************************************************"
12859 >        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
12860 >        echo "* your compiler.                                       *"
12861 >        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
12862 >        echo "********************************************************"
12863 >        echo ""
12864 >        CFLAGS=""
12865 >
12866 > fi
12867 >
12868 >
12869 > fi
12870 >
12871 >
12872 >
12873 >
12874 >
12875 >
12876 >
12877 > echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
12878 > echo $ECHO_N "checking whether we are *really* using GNU c++... $ECHO_C" >&6
12879 > if test "${ac_cv_prog_really_gxx+set}" = set; then
12880 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12881 > else
12882 >
12883 > cat > conftest.cpp <<EOF
12884 > #ifdef __GNUC__
12885 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12886 >     no;
12887 >  #else
12888 >     yes;
12889 >  #endif
12890 > #endif
12891 > EOF
12892 > if { ac_try='${CXX-c++} -E conftest.cpp'
12893 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12894 >  (eval $ac_try) 2>&5
12895 >  ac_status=$?
12896 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12897 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12898 >  ac_cv_prog_really_gxx=yes
12899 > else
12900 >  ac_cv_prog_really_gxx=no
12901 > fi
12902 >
12903 > fi
12904 > echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
12905 > echo "${ECHO_T}$ac_cv_prog_really_gxx" >&6
12906 > if test "$ac_cv_prog_really_gxx" = yes; then
12907 >        :
12908 >
12909 > else
12910 >        :
12911 >
12912 > fi
12913 >
12914 >
12915 > # Try to determine "good" native compiler flags if none specified on command
12916 > # line
12917 > if test "$ac_test_CXXFLAGS" != "set"; then
12918 >  CXXFLAGS=""
12919 >  case "${host_cpu}-${host_os}" in
12920 >
12921 >  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
12922 >                    CXXFLAGS="-O"
12923 >                fi;;
12924 >  sparc-solaris2*) if test "$CXX" = CC; then
12925 >                    CXXFLAGS="-features=extensions -O -dalign"
12926 >                 fi;;
12927 >   rs6000*-aix*)  if test "$CXX" = xlC; then
12928 >                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12929 >                fi;;
12930 >   powerpc*-aix*)
12931 >        if test "$CXX" = xlC; then
12932 >                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
12933 >                echo "*******************************************************"
12934 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12935 >                echo "*  recommended that you use                           *"
12936 >                echo "*                                                     *"
12937 >                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12938 >                echo "*                                 ^^^                 *"
12939 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12940 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12941 >                echo "*******************************************************"
12942 >        fi;;
12943 >   *darwin*)
12944 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12945 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12946 >        fi
12947 >        if test "$CXX" = icpc; then
12948 >                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12949 >        fi;;
12950 >  esac
12951 >
12952 >  # use default flags for gcc on all systems
12953 >  if test $ac_cv_prog_really_gxx = yes; then
12954 >     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12955 >  fi
12956 >
12957 >  # test for gcc-specific flags:
12958 >  if test $ac_cv_prog_really_gxx = yes; then
12959 >    # -malign-double for x86 systems
12960 >
12961 >
12962 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12963 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12964 > if test "${ac_align_double+set}" = set; then
12965 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12966 > else
12967 >  echo 'void f(){}' > conftest.cpp
12968 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12969 >        ac_align_double=yes
12970 > else
12971 >        ac_align_double=no
12972 > fi
12973 > rm -f conftest*
12974 >
12975 > fi
12976 > echo "$as_me:$LINENO: result: $ac_align_double" >&5
12977 > echo "${ECHO_T}$ac_align_double" >&6
12978 > if test "$ac_align_double" = yes; then
12979 >        :
12980 >        CXXFLAGS="$CXXFLAGS -malign-double"
12981 > else
12982 >        :
12983 >
12984 > fi
12985 >
12986 >    # -fstrict-aliasing for gcc-2.95+
12987 >
12988 >
12989 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12990 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12991 > if test "${ac_fstrict_aliasing+set}" = set; then
12992 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12993 > else
12994 >  echo 'void f(){}' > conftest.cpp
12995 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12996 >        ac_fstrict_aliasing=yes
12997 > else
12998 >        ac_fstrict_aliasing=no
12999 > fi
13000 > rm -f conftest*
13001 >
13002 > fi
13003 > echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
13004 > echo "${ECHO_T}$ac_fstrict_aliasing" >&6
13005 > if test "$ac_fstrict_aliasing" = yes; then
13006 >        :
13007 >        CXXFLAGS="$CXXFLAGS -fstrict-aliasing"
13008 > else
13009 >        :
13010 >
13011 > fi
13012 >
13013 >  fi
13014 >
13015 >  CPU_FLAGS=""
13016 >  if test $ac_cv_prog_really_gxx = yes; then
13017 >                  case "${host_cpu}" in
13018 >          i586*)
13019 >
13020 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
13021 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
13022 > if test "${ac_cpu_pentium+set}" = set; then
13023 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13024 > else
13025 >  echo 'void f(){}' > conftest.cpp
13026 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
13027 >        ac_cpu_pentium=yes
13028 > else
13029 >        ac_cpu_pentium=no
13030 > fi
13031 > rm -f conftest*
13032 >
13033 > fi
13034 > echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
13035 > echo "${ECHO_T}$ac_cpu_pentium" >&6
13036 > if test "$ac_cpu_pentium" = yes; then
13037 >        :
13038 >        CPU_FLAGS=-mcpu=pentium
13039 > else
13040 >        :
13041 >
13042 >
13043 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
13044 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
13045   if test "${ac_pentium+set}" = set; then
13046    echo $ECHO_N "(cached) $ECHO_C" >&6
13047   else
13048    echo 'void f(){}' > conftest.cpp
13049 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
13049 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
13050          ac_pentium=yes
13051   else
13052          ac_pentium=no
# Line 8265 | Line 13069 | fi
13069                    ;;
13070            i686*)
13071  
13072 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13073 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13072 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13073 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13074   if test "${ac_cpu_pentiumpro+set}" = set; then
13075    echo $ECHO_N "(cached) $ECHO_C" >&6
13076   else
13077    echo 'void f(){}' > conftest.cpp
13078 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13078 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13079          ac_cpu_pentiumpro=yes
13080   else
13081          ac_cpu_pentiumpro=no
# Line 8288 | Line 13092 | else
13092          :
13093  
13094  
13095 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13096 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13095 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13096 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13097   if test "${ac_pentiumpro+set}" = set; then
13098    echo $ECHO_N "(cached) $ECHO_C" >&6
13099   else
13100    echo 'void f(){}' > conftest.cpp
13101 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13101 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13102          ac_pentiumpro=yes
13103   else
13104          ac_pentiumpro=no
# Line 8321 | Line 13125 | fi
13125                  if test -n "$is60x"; then
13126  
13127  
13128 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13129 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13128 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13129 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13130   if test "${ac_m_cpu_60x+set}" = set; then
13131    echo $ECHO_N "(cached) $ECHO_C" >&6
13132   else
13133    echo 'void f(){}' > conftest.cpp
13134 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13134 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13135          ac_m_cpu_60x=yes
13136   else
13137          ac_m_cpu_60x=no
# Line 8379 | Line 13183 | if test "$ac_cv_prog_gxx_2_95" = yes; then
13183          :
13184  
13185  
13186 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
13187 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
13186 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13187 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13188   if test "${ac_m_cpu_750+set}" = set; then
13189    echo $ECHO_N "(cached) $ECHO_C" >&6
13190   else
13191    echo 'void f(){}' > conftest.cpp
13192 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
13192 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13193          ac_m_cpu_750=yes
13194   else
13195          ac_m_cpu_750=no
# Line 8412 | Line 13216 | fi
13216                  if test -z "$CPU_FLAGS"; then
13217  
13218  
13219 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
13220 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
13219 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13220 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13221   if test "${ac_m_cpu_powerpc+set}" = set; then
13222    echo $ECHO_N "(cached) $ECHO_C" >&6
13223   else
13224    echo 'void f(){}' > conftest.cpp
13225 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13225 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13226          ac_m_cpu_powerpc=yes
13227   else
13228          ac_m_cpu_powerpc=no
# Line 8440 | Line 13244 | fi
13244                  if test -z "$CPU_FLAGS"; then
13245  
13246  
13247 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
13248 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
13247 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13248 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13249   if test "${ac_m_powerpc+set}" = set; then
13250    echo $ECHO_N "(cached) $ECHO_C" >&6
13251   else
13252    echo 'void f(){}' > conftest.cpp
13253 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
13253 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13254          ac_m_powerpc=yes
13255   else
13256          ac_m_powerpc=no
# Line 8485 | Line 13289 | fi
13289  
13290  
13291  
13292 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
13293 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
13292 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13293 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13294   if test "${ac_guessed_cxxflags+set}" = set; then
13295    echo $ECHO_N "(cached) $ECHO_C" >&6
13296   else
13297    echo 'void f(){}' > conftest.cpp
13298 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13298 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13299          ac_guessed_cxxflags=yes
13300   else
13301          ac_guessed_cxxflags=no
# Line 8515 | Line 13319 | else
13319          echo "**********************************************************"
13320          echo ""
13321          CXXFLAGS=""
8518
8519 fi
8520
8521
8522 fi
8523
8524
8525
8526
8527
8528 # Try to determine "good" native compiler flags if none specified on command
8529 # line
8530
8531 if test x"$F90FLAGS" = x ; then
8532  F90FLAGS=""
8533  case "${host_cpu}-${host_os}" in
8534
8535  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8536                    F90FLAGS="-O"
8537                fi;;
8538   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8539                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8540                fi;;
8541   powerpc*-aix*)
8542        if test "$F90" = f90 -o "$F90" = xlf90; then
8543                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8544                echo "*******************************************************"
8545                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8546                echo "*  recommended that you use                           *"
8547                echo "*                                                     *"
8548                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8549                echo "*                                 ^^^                 *"
8550                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8551                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8552                echo "*******************************************************"
8553        fi;;
8554   *darwin*)
8555        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8556                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8557        fi;;
8558  esac
8559
8560  if test -n "$CPU_FLAGS"; then
8561        F90FLAGS="$F90FLAGS $CPU_FLAGS"
8562  fi
8563
8564  if test -z "$F90FLAGS"; then
8565        echo ""
8566        echo "**********************************************************"
8567        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8568        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8569        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8570        echo "**********************************************************"
8571        echo ""
8572        F90FLAGS="-O3"
8573  fi
8574
8575
8576 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8577 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8578 if test "${ac_guessed_f90flags+set}" = set; then
8579  echo $ECHO_N "(cached) $ECHO_C" >&6
8580 else
8581
8582
8583
8584 ac_ext=f90
8585 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8586 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8587 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8588
8589 echo 'program main' > conftest.$ac_ext
8590 echo 'end program main' >> conftest.$ac_ext
8591 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8592 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8593  (eval $ac_compile) 2>&5
8594  ac_status=$?
8595  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8596  (exit $ac_status); }; then
8597        ac_guessed_f90flags=yes
8598 else
8599        ac_guessed_f90flags=no
8600 fi
8601 rm -f conftest*
8602 ac_ext=c
8603 ac_cpp='$CPP $CPPFLAGS'
8604 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8605 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8606 ac_compiler_gnu=$ac_cv_c_compiler_gnu
13322  
8608
13323   fi
8610 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8611 echo "${ECHO_T}$ac_guessed_f90flags" >&6
8612 if test "$ac_guessed_f90flags" = yes; then
8613        :
13324  
8615 else
8616        :
13325  
8618        echo ""
8619        echo "**********************************************************"
8620        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8621        echo "* your compiler.                                         *"
8622        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8623        echo "**********************************************************"
8624        echo ""
8625        F90FLAGS=""
8626
13326   fi
13327  
8629
8630 fi
8631
13328       ;;
13329   esac
8634
8635 # Find a good install program.  We prefer a C program (faster),
8636 # so one script is as good as another.  But avoid the broken or
8637 # incompatible versions:
8638 # SysV /etc/install, /usr/sbin/install
8639 # SunOS /usr/etc/install
8640 # IRIX /sbin/install
8641 # AIX /bin/install
8642 # AmigaOS /C/install, which installs bootblocks on floppy discs
8643 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8644 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8645 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8646 # OS/2's system install, which has a completely different semantic
8647 # ./install, which can be erroneously created by make from ./install.sh.
8648 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8649 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8650 if test -z "$INSTALL"; then
8651 if test "${ac_cv_path_install+set}" = set; then
8652  echo $ECHO_N "(cached) $ECHO_C" >&6
8653 else
8654  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8655 for as_dir in $PATH
8656 do
8657  IFS=$as_save_IFS
8658  test -z "$as_dir" && as_dir=.
8659  # Account for people who put trailing slashes in PATH elements.
8660 case $as_dir/ in
8661  ./ | .// | /cC/* | \
8662  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8663  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8664  /usr/ucb/* ) ;;
8665  *)
8666    # OSF1 and SCO ODT 3.0 have their own names for install.
8667    # Don't use installbsd from OSF since it installs stuff as root
8668    # by default.
8669    for ac_prog in ginstall scoinst install; do
8670      for ac_exec_ext in '' $ac_executable_extensions; do
8671        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8672          if test $ac_prog = install &&
8673            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8674            # AIX install.  It has an incompatible calling convention.
8675            :
8676          elif test $ac_prog = install &&
8677            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8678            # program-specific install script used by HP pwplus--don't use.
8679            :
8680          else
8681            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8682            break 3
8683          fi
8684        fi
8685      done
8686    done
8687    ;;
8688 esac
8689 done
8690
8691
8692 fi
8693  if test "${ac_cv_path_install+set}" = set; then
8694    INSTALL=$ac_cv_path_install
8695  else
8696    # As a last resort, use the slow shell script.  We don't cache a
8697    # path for INSTALL within a source directory, because that will
8698    # break other packages using the cache if that directory is
8699    # removed, or if the path is relative.
8700    INSTALL=$ac_install_sh
8701  fi
8702 fi
8703 echo "$as_me:$LINENO: result: $INSTALL" >&5
8704 echo "${ECHO_T}$INSTALL" >&6
8705
8706 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8707 # It thinks the first close brace ends the variable substitution.
8708 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8709
8710 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8711
8712 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8713
8714 echo "$as_me:$LINENO: checking whether ln -s works" >&5
8715 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8716 LN_S=$as_ln_s
8717 if test "$LN_S" = "ln -s"; then
8718  echo "$as_me:$LINENO: result: yes" >&5
8719 echo "${ECHO_T}yes" >&6
8720 else
8721  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8722 echo "${ECHO_T}no, using $LN_S" >&6
8723 fi
8724
8725 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8726 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8727 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8728 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
8729  echo $ECHO_N "(cached) $ECHO_C" >&6
8730 else
8731  cat >conftest.make <<\_ACEOF
8732 all:
8733        @echo 'ac_maketemp="$(MAKE)"'
8734 _ACEOF
8735 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8736 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8737 if test -n "$ac_maketemp"; then
8738  eval ac_cv_prog_make_${ac_make}_set=yes
8739 else
8740  eval ac_cv_prog_make_${ac_make}_set=no
8741 fi
8742 rm -f conftest.make
8743 fi
8744 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
8745  echo "$as_me:$LINENO: result: yes" >&5
8746 echo "${ECHO_T}yes" >&6
8747  SET_MAKE=
8748 else
8749  echo "$as_me:$LINENO: result: no" >&5
8750 echo "${ECHO_T}no" >&6
8751  SET_MAKE="MAKE=${MAKE-make}"
8752 fi
13330  
8754 if test -n "$ac_tool_prefix"; then
8755  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
8756 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
8757 echo "$as_me:$LINENO: checking for $ac_word" >&5
8758 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8759 if test "${ac_cv_prog_RANLIB+set}" = set; then
8760  echo $ECHO_N "(cached) $ECHO_C" >&6
8761 else
8762  if test -n "$RANLIB"; then
8763  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8764 else
8765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8766 for as_dir in $PATH
8767 do
8768  IFS=$as_save_IFS
8769  test -z "$as_dir" && as_dir=.
8770  for ac_exec_ext in '' $ac_executable_extensions; do
8771  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8772    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8773    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8774    break 2
8775  fi
8776 done
8777 done
13331  
8779 fi
8780 fi
8781 RANLIB=$ac_cv_prog_RANLIB
8782 if test -n "$RANLIB"; then
8783  echo "$as_me:$LINENO: result: $RANLIB" >&5
8784 echo "${ECHO_T}$RANLIB" >&6
8785 else
8786  echo "$as_me:$LINENO: result: no" >&5
8787 echo "${ECHO_T}no" >&6
8788 fi
8789
8790 fi
8791 if test -z "$ac_cv_prog_RANLIB"; then
8792  ac_ct_RANLIB=$RANLIB
8793  # Extract the first word of "ranlib", so it can be a program name with args.
8794 set dummy ranlib; ac_word=$2
8795 echo "$as_me:$LINENO: checking for $ac_word" >&5
8796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8797 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
8798  echo $ECHO_N "(cached) $ECHO_C" >&6
8799 else
8800  if test -n "$ac_ct_RANLIB"; then
8801  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
8802 else
8803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804 for as_dir in $PATH
8805 do
8806  IFS=$as_save_IFS
8807  test -z "$as_dir" && as_dir=.
8808  for ac_exec_ext in '' $ac_executable_extensions; do
8809  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810    ac_cv_prog_ac_ct_RANLIB="ranlib"
8811    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812    break 2
8813  fi
8814 done
8815 done
8816
8817  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
8818 fi
8819 fi
8820 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
8821 if test -n "$ac_ct_RANLIB"; then
8822  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
8823 echo "${ECHO_T}$ac_ct_RANLIB" >&6
8824 else
8825  echo "$as_me:$LINENO: result: no" >&5
8826 echo "${ECHO_T}no" >&6
8827 fi
8828
8829  RANLIB=$ac_ct_RANLIB
8830 else
8831  RANLIB="$ac_cv_prog_RANLIB"
8832 fi
8833
8834 for ac_prog in 'bison -y' byacc
8835 do
8836  # Extract the first word of "$ac_prog", so it can be a program name with args.
8837 set dummy $ac_prog; ac_word=$2
8838 echo "$as_me:$LINENO: checking for $ac_word" >&5
8839 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8840 if test "${ac_cv_prog_YACC+set}" = set; then
8841  echo $ECHO_N "(cached) $ECHO_C" >&6
8842 else
8843  if test -n "$YACC"; then
8844  ac_cv_prog_YACC="$YACC" # Let the user override the test.
8845 else
8846 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8847 for as_dir in $PATH
8848 do
8849  IFS=$as_save_IFS
8850  test -z "$as_dir" && as_dir=.
8851  for ac_exec_ext in '' $ac_executable_extensions; do
8852  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8853    ac_cv_prog_YACC="$ac_prog"
8854    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8855    break 2
8856  fi
8857 done
8858 done
8859
8860 fi
8861 fi
8862 YACC=$ac_cv_prog_YACC
8863 if test -n "$YACC"; then
8864  echo "$as_me:$LINENO: result: $YACC" >&5
8865 echo "${ECHO_T}$YACC" >&6
8866 else
8867  echo "$as_me:$LINENO: result: no" >&5
8868 echo "${ECHO_T}no" >&6
8869 fi
8870
8871  test -n "$YACC" && break
8872 done
8873 test -n "$YACC" || YACC="yacc"
8874
8875 for ac_prog in flex lex
8876 do
8877  # Extract the first word of "$ac_prog", so it can be a program name with args.
8878 set dummy $ac_prog; ac_word=$2
8879 echo "$as_me:$LINENO: checking for $ac_word" >&5
8880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8881 if test "${ac_cv_prog_LEX+set}" = set; then
8882  echo $ECHO_N "(cached) $ECHO_C" >&6
8883 else
8884  if test -n "$LEX"; then
8885  ac_cv_prog_LEX="$LEX" # Let the user override the test.
8886 else
8887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8888 for as_dir in $PATH
8889 do
8890  IFS=$as_save_IFS
8891  test -z "$as_dir" && as_dir=.
8892  for ac_exec_ext in '' $ac_executable_extensions; do
8893  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8894    ac_cv_prog_LEX="$ac_prog"
8895    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8896    break 2
8897  fi
8898 done
8899 done
8900
8901 fi
8902 fi
8903 LEX=$ac_cv_prog_LEX
8904 if test -n "$LEX"; then
8905  echo "$as_me:$LINENO: result: $LEX" >&5
8906 echo "${ECHO_T}$LEX" >&6
8907 else
8908  echo "$as_me:$LINENO: result: no" >&5
8909 echo "${ECHO_T}no" >&6
8910 fi
8911
8912  test -n "$LEX" && break
8913 done
8914 test -n "$LEX" || LEX=":"
8915
8916 if test -z "$LEXLIB"
8917 then
8918  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8919 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8920 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8921  echo $ECHO_N "(cached) $ECHO_C" >&6
8922 else
8923  ac_check_lib_save_LIBS=$LIBS
8924 LIBS="-lfl  $LIBS"
8925 cat >conftest.$ac_ext <<_ACEOF
8926 /* confdefs.h.  */
8927 _ACEOF
8928 cat confdefs.h >>conftest.$ac_ext
8929 cat >>conftest.$ac_ext <<_ACEOF
8930 /* end confdefs.h.  */
8931
8932 /* Override any gcc2 internal prototype to avoid an error.  */
8933 #ifdef __cplusplus
8934 extern "C"
8935 #endif
8936 /* We use char because int might match the return type of a gcc2
8937   builtin and then its argument prototype would still apply.  */
8938 char yywrap ();
8939 int
8940 main ()
8941 {
8942 yywrap ();
8943  ;
8944  return 0;
8945 }
8946 _ACEOF
8947 rm -f conftest.$ac_objext conftest$ac_exeext
8948 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8949  (eval $ac_link) 2>conftest.er1
8950  ac_status=$?
8951  grep -v '^ *+' conftest.er1 >conftest.err
8952  rm -f conftest.er1
8953  cat conftest.err >&5
8954  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8955  (exit $ac_status); } &&
8956         { ac_try='test -z "$ac_c_werror_flag"
8957                         || test ! -s conftest.err'
8958  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8959  (eval $ac_try) 2>&5
8960  ac_status=$?
8961  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8962  (exit $ac_status); }; } &&
8963         { ac_try='test -s conftest$ac_exeext'
8964  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8965  (eval $ac_try) 2>&5
8966  ac_status=$?
8967  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8968  (exit $ac_status); }; }; then
8969  ac_cv_lib_fl_yywrap=yes
8970 else
8971  echo "$as_me: failed program was:" >&5
8972 sed 's/^/| /' conftest.$ac_ext >&5
8973
8974 ac_cv_lib_fl_yywrap=no
8975 fi
8976 rm -f conftest.err conftest.$ac_objext \
8977      conftest$ac_exeext conftest.$ac_ext
8978 LIBS=$ac_check_lib_save_LIBS
8979 fi
8980 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8981 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8982 if test $ac_cv_lib_fl_yywrap = yes; then
8983  LEXLIB="-lfl"
8984 else
8985  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8986 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8987 if test "${ac_cv_lib_l_yywrap+set}" = set; then
8988  echo $ECHO_N "(cached) $ECHO_C" >&6
8989 else
8990  ac_check_lib_save_LIBS=$LIBS
8991 LIBS="-ll  $LIBS"
8992 cat >conftest.$ac_ext <<_ACEOF
8993 /* confdefs.h.  */
8994 _ACEOF
8995 cat confdefs.h >>conftest.$ac_ext
8996 cat >>conftest.$ac_ext <<_ACEOF
8997 /* end confdefs.h.  */
8998
8999 /* Override any gcc2 internal prototype to avoid an error.  */
9000 #ifdef __cplusplus
9001 extern "C"
9002 #endif
9003 /* We use char because int might match the return type of a gcc2
9004   builtin and then its argument prototype would still apply.  */
9005 char yywrap ();
9006 int
9007 main ()
9008 {
9009 yywrap ();
9010  ;
9011  return 0;
9012 }
9013 _ACEOF
9014 rm -f conftest.$ac_objext conftest$ac_exeext
9015 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9016  (eval $ac_link) 2>conftest.er1
9017  ac_status=$?
9018  grep -v '^ *+' conftest.er1 >conftest.err
9019  rm -f conftest.er1
9020  cat conftest.err >&5
9021  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022  (exit $ac_status); } &&
9023         { ac_try='test -z "$ac_c_werror_flag"
9024                         || test ! -s conftest.err'
9025  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9026  (eval $ac_try) 2>&5
9027  ac_status=$?
9028  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9029  (exit $ac_status); }; } &&
9030         { ac_try='test -s conftest$ac_exeext'
9031  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9032  (eval $ac_try) 2>&5
9033  ac_status=$?
9034  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9035  (exit $ac_status); }; }; then
9036  ac_cv_lib_l_yywrap=yes
9037 else
9038  echo "$as_me: failed program was:" >&5
9039 sed 's/^/| /' conftest.$ac_ext >&5
9040
9041 ac_cv_lib_l_yywrap=no
9042 fi
9043 rm -f conftest.err conftest.$ac_objext \
9044      conftest$ac_exeext conftest.$ac_ext
9045 LIBS=$ac_check_lib_save_LIBS
9046 fi
9047 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9048 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9049 if test $ac_cv_lib_l_yywrap = yes; then
9050  LEXLIB="-ll"
9051 fi
9052
9053 fi
9054
9055 fi
9056
9057 if test "x$LEX" != "x:"; then
9058  echo "$as_me:$LINENO: checking lex output file root" >&5
9059 echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9060 if test "${ac_cv_prog_lex_root+set}" = set; then
9061  echo $ECHO_N "(cached) $ECHO_C" >&6
9062 else
9063  # The minimal lex program is just a single line: %%.  But some broken lexes
9064 # (Solaris, I think it was) want two %% lines, so accommodate them.
9065 cat >conftest.l <<_ACEOF
9066 %%
9067 %%
9068 _ACEOF
9069 { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9070  (eval $LEX conftest.l) 2>&5
9071  ac_status=$?
9072  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073  (exit $ac_status); }
9074 if test -f lex.yy.c; then
9075  ac_cv_prog_lex_root=lex.yy
9076 elif test -f lexyy.c; then
9077  ac_cv_prog_lex_root=lexyy
9078 else
9079  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9080 echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9081   { (exit 1); exit 1; }; }
9082 fi
9083 fi
9084 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9085 echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9086 rm -f conftest.l
9087 LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
9088
9089 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9090 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9091 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9092  echo $ECHO_N "(cached) $ECHO_C" >&6
9093 else
9094  # POSIX says lex can declare yytext either as a pointer or an array; the
9095 # default is implementation-dependent. Figure out which it is, since
9096 # not all implementations provide the %pointer and %array declarations.
9097 ac_cv_prog_lex_yytext_pointer=no
9098 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9099 ac_save_LIBS=$LIBS
9100 LIBS="$LIBS $LEXLIB"
9101 cat >conftest.$ac_ext <<_ACEOF
9102 `cat $LEX_OUTPUT_ROOT.c`
9103 _ACEOF
9104 rm -f conftest.$ac_objext conftest$ac_exeext
9105 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9106  (eval $ac_link) 2>conftest.er1
9107  ac_status=$?
9108  grep -v '^ *+' conftest.er1 >conftest.err
9109  rm -f conftest.er1
9110  cat conftest.err >&5
9111  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9112  (exit $ac_status); } &&
9113         { ac_try='test -z "$ac_c_werror_flag"
9114                         || test ! -s conftest.err'
9115  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9116  (eval $ac_try) 2>&5
9117  ac_status=$?
9118  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9119  (exit $ac_status); }; } &&
9120         { ac_try='test -s conftest$ac_exeext'
9121  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9122  (eval $ac_try) 2>&5
9123  ac_status=$?
9124  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9125  (exit $ac_status); }; }; then
9126  ac_cv_prog_lex_yytext_pointer=yes
9127 else
9128  echo "$as_me: failed program was:" >&5
9129 sed 's/^/| /' conftest.$ac_ext >&5
9130
9131 fi
9132 rm -f conftest.err conftest.$ac_objext \
9133      conftest$ac_exeext conftest.$ac_ext
9134 LIBS=$ac_save_LIBS
9135 rm -f "${LEX_OUTPUT_ROOT}.c"
9136
9137 fi
9138 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9139 echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9140 if test $ac_cv_prog_lex_yytext_pointer = yes; then
9141
9142 cat >>confdefs.h <<\_ACEOF
9143 #define YYTEXT_POINTER 1
9144 _ACEOF
9145
9146 fi
9147
9148 fi
9149
9150   # Extract the first word of "perl", so it can be a program name with args.
9151 set dummy perl; ac_word=$2
9152 echo "$as_me:$LINENO: checking for $ac_word" >&5
9153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9154 if test "${ac_cv_path_PERLINTERP+set}" = set; then
9155  echo $ECHO_N "(cached) $ECHO_C" >&6
9156 else
9157  case $PERLINTERP in
9158  [\\/]* | ?:[\\/]*)
9159  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9160  ;;
9161  *)
9162  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9163 for as_dir in $PATH
9164 do
9165  IFS=$as_save_IFS
9166  test -z "$as_dir" && as_dir=.
9167  for ac_exec_ext in '' $ac_executable_extensions; do
9168  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9169    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9170    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9171    break 2
9172  fi
9173 done
9174 done
9175
9176  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9177  ;;
9178 esac
9179 fi
9180 PERLINTERP=$ac_cv_path_PERLINTERP
9181
9182 if test -n "$PERLINTERP"; then
9183  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9184 echo "${ECHO_T}$PERLINTERP" >&6
9185 else
9186  echo "$as_me:$LINENO: result: no" >&5
9187 echo "${ECHO_T}no" >&6
9188 fi
9189
9190   ac_cv_path_perlinterp="$PERLINTERP"
9191   _sHpB='#!'
9192
9193
9194 # Check whether --with-perl-shebang or --without-perl-shebang was given.
9195 if test "${with_perl_shebang+set}" = set; then
9196  withval="$with_perl_shebang"
9197  opt_perl_shebang="$withval"
9198 else
9199                opt_perl_shebang="not_set"
9200 fi;
9201   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9202 echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9203 if test "${ax_cv_opt_perl_shebang+set}" = set; then
9204  echo $ECHO_N "(cached) $ECHO_C" >&6
9205 else
9206   case "$opt_perl_shebang" in
9207                      not_set  ) ax_cv_opt_perl_shebang=''
9208                               ;;
9209                         *     )
9210        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9211                    esac
9212
9213 fi
9214 echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9215 echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9216   if test "A$ax_cv_opt_perl_shebang" != "A"
9217     then
9218       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9219       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9220              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9221 echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
9222
9223 # Automatic detection of sharpbang formula starts here
9224     else
9225   _somian_shbangperl=`$PERLINTERP -V:startperl`
9226   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9227   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9228 echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9229 if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9230  echo $ECHO_N "(cached) $ECHO_C" >&6
9231 else
9232  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9233        if test "x$_somian_kspb_perl" == x
9234          then _somian_ksbp_warn_empty='durnit'
9235          else
9236          case "A$_somian_kspb_perl" in
9237                 A#!*perl* )
9238           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9239                        ;;
9240                     A*    )  _somian_ksbp_warn_defau='trouble'
9241                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9242          esac
9243        fi
9244
9245 fi
9246 echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
9247 echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
9248 # The above prints Checking ... result message to user.
9249   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9250
9251    if test A${_somian_ksbp_warn_empty+set} == Aset
9252      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9253 echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9254    fi
9255 # Inform user after printing result value
9256    if test A${_somian_ksbp_warn_defau+set} == Aset
9257      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9258 echo "$as_me: Maybe Not good -" >&6;}
9259           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9260 echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9261      else { echo "$as_me:$LINENO: OK Good result - " >&5
9262 echo "$as_me: OK Good result - " >&6;}
9263           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9264 echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9265    fi
9266  fi
9267
9268 # Extract the first word of "ar", so it can be a program name with args.
9269 set dummy ar; ac_word=$2
9270 echo "$as_me:$LINENO: checking for $ac_word" >&5
9271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9272 if test "${ac_cv_prog_AR+set}" = set; then
9273  echo $ECHO_N "(cached) $ECHO_C" >&6
9274 else
9275  if test -n "$AR"; then
9276  ac_cv_prog_AR="$AR" # Let the user override the test.
9277 else
9278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9279 for as_dir in $PATH
9280 do
9281  IFS=$as_save_IFS
9282  test -z "$as_dir" && as_dir=.
9283  for ac_exec_ext in '' $ac_executable_extensions; do
9284  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9285    ac_cv_prog_AR="ar"
9286    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9287    break 2
9288  fi
9289 done
9290 done
9291
9292  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
9293 fi
9294 fi
9295 AR=$ac_cv_prog_AR
9296 if test -n "$AR"; then
9297  echo "$as_me:$LINENO: result: $AR" >&5
9298 echo "${ECHO_T}$AR" >&6
9299 else
9300  echo "$as_me:$LINENO: result: no" >&5
9301 echo "${ECHO_T}no" >&6
9302 fi
9303
9304 if test "$AR" = "NONE"; then
9305  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9306 echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9307   { (exit 1); exit 1; }; }
9308  cat >confcache <<\_ACEOF
9309 # This file is a shell script that caches the results of configure
9310 # tests run on this system so they can be shared between configure
9311 # scripts and configure runs, see configure's option --config-cache.
9312 # It is not useful on other systems.  If it contains results you don't
9313 # want to keep, you may remove or edit it.
9314 #
9315 # config.status only pays attention to the cache file if you give it
9316 # the --recheck option to rerun configure.
9317 #
9318 # `ac_cv_env_foo' variables (set or unset) will be overridden when
9319 # loading this file, other *unset* `ac_cv_foo' will be assigned the
9320 # following values.
9321
9322 _ACEOF
9323
9324 # The following way of writing the cache mishandles newlines in values,
9325 # but we know of no workaround that is simple, portable, and efficient.
9326 # So, don't put newlines in cache variables' values.
9327 # Ultrix sh set writes to stderr and can't be redirected directly,
9328 # and sets the high bit in the cache file unless we assign to the vars.
9329 {
9330  (set) 2>&1 |
9331    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9332    *ac_space=\ *)
9333      # `set' does not quote correctly, so add quotes (double-quote
9334      # substitution turns \\\\ into \\, and sed turns \\ into \).
9335      sed -n \
9336        "s/'/'\\\\''/g;
9337          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9338      ;;
9339    *)
9340      # `set' quotes correctly as required by POSIX, so do not add quotes.
9341      sed -n \
9342        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9343      ;;
9344    esac;
9345 } |
9346  sed '
9347     t clear
9348     : clear
9349     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9350     t end
9351     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9352     : end' >>confcache
9353 if diff $cache_file confcache >/dev/null 2>&1; then :; else
9354  if test -w $cache_file; then
9355    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9356    cat confcache >$cache_file
9357  else
9358    echo "not updating unwritable cache $cache_file"
9359  fi
9360 fi
9361 rm -f confcache
9362  exit 1
9363 fi
9364
9365 # Extract the first word of "ps", so it can be a program name with args.
9366 set dummy ps; ac_word=$2
9367 echo "$as_me:$LINENO: checking for $ac_word" >&5
9368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9369 if test "${ac_cv_path_PS+set}" = set; then
9370  echo $ECHO_N "(cached) $ECHO_C" >&6
9371 else
9372  case $PS in
9373  [\\/]* | ?:[\\/]*)
9374  ac_cv_path_PS="$PS" # Let the user override the test with a path.
9375  ;;
9376  *)
9377  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9378 for as_dir in $PATH
9379 do
9380  IFS=$as_save_IFS
9381  test -z "$as_dir" && as_dir=.
9382  for ac_exec_ext in '' $ac_executable_extensions; do
9383  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9384    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9385    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9386    break 2
9387  fi
9388 done
9389 done
9390
9391  ;;
9392 esac
9393 fi
9394 PS=$ac_cv_path_PS
9395
9396 if test -n "$PS"; then
9397  echo "$as_me:$LINENO: result: $PS" >&5
9398 echo "${ECHO_T}$PS" >&6
9399 else
9400  echo "$as_me:$LINENO: result: no" >&5
9401 echo "${ECHO_T}no" >&6
9402 fi
9403
9404 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9405 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9406 if test "${ac_cv_prog_ps_syntax+set}" = set; then
9407  echo $ECHO_N "(cached) $ECHO_C" >&6
9408 else
9409
9410        if $PS ax -o rss > /dev/null 2>&1; then
9411                ac_cv_prog_ps_ax=yes
9412        else
9413                ac_cv_prog_ps_ax=no
9414        fi
9415        if $PS -ef -o rss > /dev/null 2>&1; then
9416                ac_cv_prog_ps_ef=yes
9417        else
9418                ac_cv_prog_ps_ef=no
9419        fi
9420        if test "$ac_cv_prog_ps_ax" = yes; then
9421                ac_cv_prog_ps_syntax=BSD
9422        else
9423                if test "$ac_cv_prog_ps_ef" = yes; then
9424                        ac_cv_prog_ps_syntax=POSIX
9425                else
9426                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9427 echo "$as_me: error: Could not determine ps syntax" >&2;}
9428   { (exit 1); exit 1; }; }
9429                fi
9430        fi
9431
9432 fi
9433 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9434 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9435
9436
9437 cat >>confdefs.h <<_ACEOF
9438 #define PSCOMMAND $PS
9439 _ACEOF
9440
9441
13332   cat >>confdefs.h <<\_ACEOF
13333   #define OBAPI
13334   _ACEOF
13335  
13336  
13337  
9448 if test "$ac_cv_prog_ps_syntax" = BSD; then
13338  
9450 cat >>confdefs.h <<\_ACEOF
9451 #define PSTYPE_IS_BSD 1
9452 _ACEOF
9453
9454 else
9455   if test "$ac_cv_prog_ps_syntax" = POSIX; then
9456
9457 cat >>confdefs.h <<\_ACEOF
9458 #define PSTYPE_IS_POSIX 1
9459 _ACEOF
9460
9461   else
9462       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9463 echo "$as_me: error: Unknown ps syntax type!" >&2;}
9464   { (exit 1); exit 1; }; }
9465   fi
9466 fi
9467
9468
13339   # Check whether --with-mpi or --without-mpi was given.
13340   if test "${with_mpi+set}" = set; then
13341    withval="$with_mpi"
# Line 9491 | Line 13361 | MPI_INC_DIR="$MPI/include"
13361  
13362  
13363  
13364 + ac_ext=c
13365 + ac_cpp='$CPP $CPPFLAGS'
13366 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13367 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13368 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13369 +
13370   echo "$as_me:$LINENO: checking for mpi.h" >&5
13371   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13372   have_mpi_h=0
13373   rm -f conftest*
13374 < echo '#include <mpi.h>' > conftest.cc
13375 < if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13374 > echo '#include <mpi.h>' > conftest.c
13375 > if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13376          echo "$as_me:$LINENO: result: yes" >&5
13377   echo "${ECHO_T}yes" >&6
13378          have_mpi_h=1
# Line 9519 | Line 13395 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13395  
13396   echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13397   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13398 +
13399 +
13400 + ac_ext=${FC_SRCEXT-f}
13401 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13402 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13403 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13404 +
13405 + ac_save_ext=$ac_ext
13406 + ac_ext=F90
13407 + ac_save_FCFLAGS=$FCFLAGS
13408   have_mpif_h=0
13409   rm -f conftest*
13410 < cat >conftest.f90 <<EOF
13410 > cat >conftest.$ac_ext <<EOF
13411   program main
13412     include 'mpif.h'
13413   end
13414   EOF
13415 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13415 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13416          echo "$as_me:$LINENO: result: yes" >&5
13417   echo "${ECHO_T}yes" >&6
13418          MPI_F90_INC="$MPI_INC_DIR"
# Line 9548 | Line 13434 | fi
13434   _ACEOF
13435  
13436   fi
13437 + FCFLAGS=$ac_save_FCFLAGS
13438 + ac_ext=$ac_save_ext
13439 + ac_ext=c
13440 + ac_cpp='$CPP $CPPFLAGS'
13441 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13442 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13443 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13444  
13445 +
13446   ac_ext=c
13447   ac_cpp='$CPP $CPPFLAGS'
13448   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 9556 | Line 13450 | ac_save_LDFLAGS=$LDFLAGS
13450   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13451  
13452   ac_save_LDFLAGS=$LDFLAGS
13453 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13453 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13454  
13455   if test x = x"$MPI_LIB"; then
13456          echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
# Line 9580 | Line 13474 | char MPI_Init ();
13474   /* We use char because int might match the return type of a gcc2
13475     builtin and then its argument prototype would still apply.  */
13476   char MPI_Init ();
13477 + #ifdef FC_DUMMY_MAIN
13478 + #ifndef FC_DUMMY_MAIN_EQ_F77
13479 + #  ifdef __cplusplus
13480 +     extern "C"
13481 + #  endif
13482 +   int FC_DUMMY_MAIN() { return 1; }
13483 + #endif
13484 + #endif
13485   int
13486   main ()
13487   {
# Line 9628 | Line 13530 | fi
13530   fi
13531  
13532   fi
13533 + $as_unset ac_cv_lib_mpich_MPI_Init
13534   if test x = x"$MPI_LIB"; then
13535 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13536 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13537 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13535 >        echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13536 > echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13537 > if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13538    echo $ECHO_N "(cached) $ECHO_C" >&6
13539   else
13540    ac_check_lib_save_LIBS=$LIBS
13541 < LIBS="-lmpi  $LIBS"
13541 > LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13542   cat >conftest.$ac_ext <<_ACEOF
13543   /* confdefs.h.  */
13544   _ACEOF
# Line 9650 | Line 13553 | char MPI_Init ();
13553   /* We use char because int might match the return type of a gcc2
13554     builtin and then its argument prototype would still apply.  */
13555   char MPI_Init ();
13556 + #ifdef FC_DUMMY_MAIN
13557 + #ifndef FC_DUMMY_MAIN_EQ_F77
13558 + #  ifdef __cplusplus
13559 +     extern "C"
13560 + #  endif
13561 +   int FC_DUMMY_MAIN() { return 1; }
13562 + #endif
13563 + #endif
13564   int
13565   main ()
13566   {
# Line 9680 | Line 13591 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13591    ac_status=$?
13592    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13593    (exit $ac_status); }; }; then
13594 <  ac_cv_lib_mpi_MPI_Init=yes
13594 >  ac_cv_lib_pmpich_MPI_Init=yes
13595   else
13596    echo "$as_me: failed program was:" >&5
13597   sed 's/^/| /' conftest.$ac_ext >&5
13598  
13599 < ac_cv_lib_mpi_MPI_Init=no
13599 > ac_cv_lib_pmpich_MPI_Init=no
13600   fi
13601   rm -f conftest.err conftest.$ac_objext \
13602        conftest$ac_exeext conftest.$ac_ext
13603   LIBS=$ac_check_lib_save_LIBS
13604   fi
13605 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13606 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13607 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13608 <  MPI_LIB="-lmpi"
13605 > echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13606 > echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13607 > if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13608 >  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13609   fi
13610  
13611   fi
9701 $as_unset ac_cv_lib_mpi_MPI_Init
13612   if test x = x"$MPI_LIB"; then
13613          echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13614   echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
# Line 9706 | Line 13616 | else
13616    echo $ECHO_N "(cached) $ECHO_C" >&6
13617   else
13618    ac_check_lib_save_LIBS=$LIBS
13619 < LIBS="-lmpi "-llam" $LIBS"
13619 > LIBS="-lmpi  $LIBS"
13620   cat >conftest.$ac_ext <<_ACEOF
13621   /* confdefs.h.  */
13622   _ACEOF
# Line 9721 | Line 13631 | char MPI_Init ();
13631   /* We use char because int might match the return type of a gcc2
13632     builtin and then its argument prototype would still apply.  */
13633   char MPI_Init ();
13634 + #ifdef FC_DUMMY_MAIN
13635 + #ifndef FC_DUMMY_MAIN_EQ_F77
13636 + #  ifdef __cplusplus
13637 +     extern "C"
13638 + #  endif
13639 +   int FC_DUMMY_MAIN() { return 1; }
13640 + #endif
13641 + #endif
13642   int
13643   main ()
13644   {
# Line 9765 | Line 13683 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13683   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13684   echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13685   if test $ac_cv_lib_mpi_MPI_Init = yes; then
13686 <  MPI_LIB="-lmpi -llam"
13686 >  MPI_LIB="-lmpi"
13687   fi
13688  
13689   fi
13690 < $as_unset ac_cv_lib_mpich_MPI_Init
13690 > $as_unset ac_cv_lib_mpi_MPI_Init
13691   if test x = x"$MPI_LIB"; then
13692 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13693 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13694 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13692 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13693 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13694 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13695    echo $ECHO_N "(cached) $ECHO_C" >&6
13696   else
13697    ac_check_lib_save_LIBS=$LIBS
13698 < LIBS="-lmpich "-lpmpich" $LIBS"
13698 > LIBS="-lmpi -llam $LIBS"
13699   cat >conftest.$ac_ext <<_ACEOF
13700   /* confdefs.h.  */
13701   _ACEOF
# Line 9792 | Line 13710 | char MPI_Init ();
13710   /* We use char because int might match the return type of a gcc2
13711     builtin and then its argument prototype would still apply.  */
13712   char MPI_Init ();
13713 + #ifdef FC_DUMMY_MAIN
13714 + #ifndef FC_DUMMY_MAIN_EQ_F77
13715 + #  ifdef __cplusplus
13716 +     extern "C"
13717 + #  endif
13718 +   int FC_DUMMY_MAIN() { return 1; }
13719 + #endif
13720 + #endif
13721   int
13722   main ()
13723   {
# Line 9822 | Line 13748 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13748    ac_status=$?
13749    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13750    (exit $ac_status); }; }; then
13751 <  ac_cv_lib_mpich_MPI_Init=yes
13751 >  ac_cv_lib_mpi_MPI_Init=yes
13752   else
13753    echo "$as_me: failed program was:" >&5
13754   sed 's/^/| /' conftest.$ac_ext >&5
13755  
13756 < ac_cv_lib_mpich_MPI_Init=no
13756 > ac_cv_lib_mpi_MPI_Init=no
13757   fi
13758   rm -f conftest.err conftest.$ac_objext \
13759        conftest$ac_exeext conftest.$ac_ext
13760   LIBS=$ac_check_lib_save_LIBS
13761   fi
13762 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13763 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13764 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13765 <  MPI_LIB="-lmpich -lpmpich"
13762 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13763 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13764 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13765 >  MPI_LIB="-lmpi -llam"
13766   fi
13767  
13768   fi
9843
13769   $as_unset ac_cv_lib_mpi_MPI_Init
13770   if test x = x"$MPI_LIB"; then
13771   echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
# Line 9864 | Line 13789 | char MPI_Init ();
13789   /* We use char because int might match the return type of a gcc2
13790     builtin and then its argument prototype would still apply.  */
13791   char MPI_Init ();
13792 + #ifdef FC_DUMMY_MAIN
13793 + #ifndef FC_DUMMY_MAIN_EQ_F77
13794 + #  ifdef __cplusplus
13795 +     extern "C"
13796 + #  endif
13797 +   int FC_DUMMY_MAIN() { return 1; }
13798 + #endif
13799 + #endif
13800   int
13801   main ()
13802   {
# Line 9940 | Line 13873 | fi
13873  
13874  
13875  
13876 + acx_cgal_found=no
13877  
13878 < USE_CGAL=no
13879 < cgal_makefile=auto
13878 > # Check whether --with-cgalmakefile or --without-cgalmakefile was given.
13879 > if test "${with_cgalmakefile+set}" = set; then
13880 >  withval="$with_cgalmakefile"
13881  
9947 # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
9948 if test "${with_cgal_makefile+set}" = set; then
9949  withval="$with_cgal_makefile"
9950  cgal_makefile="$withval"
13882   fi;
13883 + case $with_cgalmakefile in
13884 +        yes | "") ;;
13885 +        no) acx_cgal_found=disable ;;
13886 +        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13887 +        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13888 + esac
13889  
13890 < if test "x$cgal_makefile" != xno; then
13890 > if test "$acx_cgal_found" == no; then
13891 >    echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
13892 > echo $ECHO_N "checking CGAL_MAKEFILE... $ECHO_C" >&6
13893  
13894 <  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
9956 <    cgal_makefile="$CGAL_MAKEFILE"
9957 <  fi
13894 >    if test \! -z "$CGAL_MAKEFILE"; then
13895  
13896 <  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13897 < echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13896 >        if test -e "$CGAL_MAKEFILE"; then
13897 >            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
13898  
13899 <  if test -f "$cgal_makefile"; then
13899 > cat > $tname << _ACEOF
13900 > include $CGAL_MAKEFILE
13901  
13902 <    cat >config.tmp.Makefile <<EOF
13903 < include $cgal_makefile
9966 < default:
9967 <        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
9968 <        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
9969 <        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
9970 <        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
9971 <        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
9972 <        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
9973 <        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
9974 <        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
9975 <        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
9976 <        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
9977 <        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
9978 <        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
9979 < EOF
13902 > cppflags:
13903 >        @echo \$(CGAL_CXXFLAGS)
13904  
13905 <    make -s -f config.tmp.Makefile
13906 <    . config.tmp.cgalvariables
13907 <
13908 <    rm -f config.tmp.Makefile config.tmp.cgalvariables
13909 <
13910 <    if test "x$CGAL_INCLDIR" = "x"; then
13911 <      CGAL_INCLDIR=""
13905 > cxxflags:
13906 >        @echo
13907 > ldflags:
13908 >        @echo \$(CGAL_LDFLAGS)
13909 > _ACEOF
13910 >            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
13911 >            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
13912 >            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
13913 >            for i in $CGAL_LDFLAGST; do
13914 >                if test `echo $i| grep -c ^-l`; then
13915 >                    CGAL_LIBS="$CGAL_LIBS $i"
13916 >                else
13917 >                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
13918 >                fi
13919 >            done
13920 >            rm -f $tname
13921 >            echo "$as_me:$LINENO: result: yes" >&5
13922 > echo "${ECHO_T}yes" >&6
13923 >            acx_cgal_found=yes
13924 >                                   else
13925 >            echo "$as_me:$LINENO: result: invalid" >&5
13926 > echo "${ECHO_T}invalid" >&6
13927 >            { { echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
13928 > echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
13929 >   { (exit 1); exit 1; }; }
13930 >        fi
13931 >    else
13932 >        echo "$as_me:$LINENO: result: not defined" >&5
13933 > echo "${ECHO_T}not defined" >&6
13934      fi
13935 + fi
13936  
13937 <    if test "x$CGAL_LIBDIR" = "x"; then
13938 <      CGAL_LIBDIR=""
13939 <    fi
13940 <
13941 <    if test "x$CGAL_RLIBDIR" = "x"; then
9995 <      CGAL_RLIBDIR=""
9996 <    fi
9997 <
9998 <    if test "x$LEDA_INCLDIR" = "x"; then
9999 <      LEDA_INCLDIR=""
10000 <    fi
10001 <
10002 <    if test "x$LEDA_LIBDIR" = "x"; then
10003 <      LEDA_LIBDIR=""
10004 <    fi
10005 <
10006 <    if test "x$LEDA_RLIBDIR" = "x"; then
10007 <      LEDA_RLIBDIR=""
10008 <    fi
10009 <
10010 <    if test "x$GMP_INCLDIR" = "x"; then
10011 <      GMP_INCLDIR=""
10012 <    fi
10013 <
10014 <    if test "x$GMP_LIBDIR" = "x"; then
10015 <      GMP_LIBDIR=""
10016 <    fi
10017 <
10018 <    if test "x$GMP_RLIBDIR" = "x"; then
10019 <      GMP_RLIBDIR=""
10020 <    fi
10021 <
10022 <    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
10023 < echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
10024 <    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
10025 < echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
10026 <    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
10027 < echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
10028 <    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
10029 < echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
10030 <    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
10031 < echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
10032 <    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
10033 < echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
10034 <    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
10035 < echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
10036 <    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
10037 < echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
10038 <    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
10039 < echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
10040 <
10041 <    ac_ext=cc
10042 < ac_cpp='$CXXCPP $CPPFLAGS'
10043 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10044 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10045 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10046 <
10047 <    save_CXXFLAGS="$CXXFLAGS"
10048 <    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
10049 <    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10050 <  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
10051 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
10052 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13937 > if test "$acx_cgal_found" == no; then
13938 >        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13939 >  echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13940 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13941 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13942    echo $ECHO_N "(cached) $ECHO_C" >&6
13943   fi
13944 < echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13945 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13944 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13945 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13946   else
13947    # Is the header compilable?
13948 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13949 < echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13948 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
13949 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... $ECHO_C" >&6
13950   cat >conftest.$ac_ext <<_ACEOF
13951   /* confdefs.h.  */
13952   _ACEOF
# Line 10065 | Line 13954 | $ac_includes_default
13954   cat >>conftest.$ac_ext <<_ACEOF
13955   /* end confdefs.h.  */
13956   $ac_includes_default
13957 < #include <CGAL/Cartesian.h>
13957 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13958   _ACEOF
13959   rm -f conftest.$ac_objext
13960   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 10076 | Line 13965 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13965    cat conftest.err >&5
13966    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13967    (exit $ac_status); } &&
13968 <         { ac_try='test -z "$ac_cxx_werror_flag"
13968 >         { ac_try='test -z "$ac_c_werror_flag"
13969                           || test ! -s conftest.err'
13970    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13971    (eval $ac_try) 2>&5
# Line 10101 | Line 13990 | echo "${ECHO_T}$ac_header_compiler" >&6
13990   echo "${ECHO_T}$ac_header_compiler" >&6
13991  
13992   # Is the header present?
13993 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13994 < echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13993 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
13994 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... $ECHO_C" >&6
13995   cat >conftest.$ac_ext <<_ACEOF
13996   /* confdefs.h.  */
13997   _ACEOF
13998   cat confdefs.h >>conftest.$ac_ext
13999   cat >>conftest.$ac_ext <<_ACEOF
14000   /* end confdefs.h.  */
14001 < #include <CGAL/Cartesian.h>
14001 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
14002   _ACEOF
14003   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
14004    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 10120 | Line 14009 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
14009    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14010    (exit $ac_status); } >/dev/null; then
14011    if test -s conftest.err; then
14012 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
14013 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
14012 >    ac_cpp_err=$ac_c_preproc_warn_flag
14013 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
14014    else
14015      ac_cpp_err=
14016    fi
# Line 10141 | Line 14030 | echo "${ECHO_T}$ac_header_preproc" >&6
14030   echo "${ECHO_T}$ac_header_preproc" >&6
14031  
14032   # So?  What about this header?
14033 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
14033 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
14034    yes:no: )
14035 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
14036 < echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
14037 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
14038 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
14035 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
14036 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
14037 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
14038 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
14039      ac_header_preproc=yes
14040      ;;
14041    no:yes:* )
14042 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
14043 < echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
14044 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
14045 < echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
14046 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
14047 < echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
14048 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
14049 < echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14050 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
14051 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
14052 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
14053 < echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
14042 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
14043 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
14044 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
14045 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
14046 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
14047 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
14048 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
14049 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14050 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
14051 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
14052 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
14053 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
14054      (
14055        cat <<\_ASBOX
14056   ## ------------------------------ ##
# Line 10172 | Line 14061 | esac
14061        sed "s/^/$as_me: WARNING:     /" >&2
14062      ;;
14063   esac
14064 < echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
14065 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
14066 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
14064 > echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
14065 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
14066 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
14067    echo $ECHO_N "(cached) $ECHO_C" >&6
14068   else
14069 <  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
14069 >  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
14070   fi
14071 < echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
14072 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
14071 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
14072 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
14073  
14074   fi
14075 < if test $ac_cv_header_CGAL_Cartesian_h = yes; then
14076 <  cgal=yes
14075 > if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
14076 >  cgal_have_header=yes
14077   else
14078 <  cgal=no
14078 >  cgal_have_header=no
14079   fi
14080  
14081  
14082 <    CXXFLAGS="$save_CXXFLAGS"
14082 >        if test "$cgal_have_header" == yes; then
14083 >                echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
14084 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
14085 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
14086 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14087 > else
14088 >  ac_check_lib_save_LIBS=$LIBS
14089 > LIBS="-lCGAL  $LIBS"
14090 > cat >conftest.$ac_ext <<_ACEOF
14091 > /* confdefs.h.  */
14092 > _ACEOF
14093 > cat confdefs.h >>conftest.$ac_ext
14094 > cat >>conftest.$ac_ext <<_ACEOF
14095 > /* end confdefs.h.  */
14096  
10195    if test "x$cgal" = xyes; then
10196      echo "$as_me:$LINENO: checking for CGAL version" >&5
10197 echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
10198      LOCATION=${CGAL_INCLDIR}
10199      LOCATION=${LOCATION:-/usr/include}
10200      if test -f $LOCATION/CGAL/version.h; then
10201        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
10202      else
10203        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
10204      fi
10205      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
10206        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
10207 echo "${ECHO_T}($CGAL_VERSION) yes" >&6
10208      else
10209        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
10210 echo "${ECHO_T}($CGAL_VERSION) no" >&6
10211        cgal=no
10212      fi
10213    fi
14097  
14098 <    if test "x$cgal" = xyes; then
14099 <      CGAL_LIBS="-lCGAL"
14100 <      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
14101 < echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
14102 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
14103 <        CGAL_USES_LEDA=yes
14104 <        echo "$as_me:$LINENO: result: yes" >&5
14105 < echo "${ECHO_T}yes" >&6
14106 <        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
14107 <      else
14108 <        echo "$as_me:$LINENO: result: no" >&5
14109 < echo "${ECHO_T}no" >&6
14110 <        CGAL_USES_LEDA=no
14111 <      fi
14098 > #ifdef FC_DUMMY_MAIN
14099 > #ifndef FC_DUMMY_MAIN_EQ_F77
14100 > #  ifdef __cplusplus
14101 >     extern "C"
14102 > #  endif
14103 >   int FC_DUMMY_MAIN() { return 1; }
14104 > #endif
14105 > #endif
14106 > int
14107 > main ()
14108 > {
14109 > main ();
14110 >  ;
14111 >  return 0;
14112 > }
14113 > _ACEOF
14114 > rm -f conftest.$ac_objext conftest$ac_exeext
14115 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14116 >  (eval $ac_link) 2>conftest.er1
14117 >  ac_status=$?
14118 >  grep -v '^ *+' conftest.er1 >conftest.err
14119 >  rm -f conftest.er1
14120 >  cat conftest.err >&5
14121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14122 >  (exit $ac_status); } &&
14123 >         { ac_try='test -z "$ac_c_werror_flag"
14124 >                         || test ! -s conftest.err'
14125 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14126 >  (eval $ac_try) 2>&5
14127 >  ac_status=$?
14128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14129 >  (exit $ac_status); }; } &&
14130 >         { ac_try='test -s conftest$ac_exeext'
14131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14132 >  (eval $ac_try) 2>&5
14133 >  ac_status=$?
14134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14135 >  (exit $ac_status); }; }; then
14136 >  ac_cv_lib_CGAL_main=yes
14137 > else
14138 >  echo "$as_me: failed program was:" >&5
14139 > sed 's/^/| /' conftest.$ac_ext >&5
14140  
14141 <      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
14142 < echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
14143 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
14144 <        CGAL_USES_GMP=yes
14145 <        echo "$as_me:$LINENO: result: yes" >&5
14146 < echo "${ECHO_T}yes" >&6
14147 <        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
14148 <      else
14149 <        echo "$as_me:$LINENO: result: no" >&5
14150 < echo "${ECHO_T}no" >&6
14151 <        CGAL_USES_GMP=no
14152 <      fi
14141 > ac_cv_lib_CGAL_main=no
14142 > fi
14143 > rm -f conftest.err conftest.$ac_objext \
14144 >      conftest$ac_exeext conftest.$ac_ext
14145 > LIBS=$ac_check_lib_save_LIBS
14146 > fi
14147 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
14148 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
14149 > if test $ac_cv_lib_CGAL_main = yes; then
14150 >  cgal_have_lib=yes
14151 > else
14152 >  cgal_have_lib=no
14153 > fi
14154  
14155 <      CGAL_LIBS="$CGAL_LIBS -lm"
14155 >                if test "$cgal_have_lib" == no; then
14156 >                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
14157 >                        echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
14158 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
14159 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
14160 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14161 > else
14162 >  ac_check_lib_save_LIBS=$LIBS
14163 > LIBS="-lCGAL  $LIBS"
14164 > cat >conftest.$ac_ext <<_ACEOF
14165 > /* confdefs.h.  */
14166 > _ACEOF
14167 > cat confdefs.h >>conftest.$ac_ext
14168 > cat >>conftest.$ac_ext <<_ACEOF
14169 > /* end confdefs.h.  */
14170  
10245      CGAL_CXXFLAGS="-ftemplate-depth-50"
14171  
14172 <      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
14173 < echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
14174 <      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
14175 < echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
14176 <      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
14177 < echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
14178 <      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
14179 < echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
14180 <      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
14181 < echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
14182 <      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
14183 < echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
14184 <      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
14185 < echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
14186 <    fi
14172 > #ifdef FC_DUMMY_MAIN
14173 > #ifndef FC_DUMMY_MAIN_EQ_F77
14174 > #  ifdef __cplusplus
14175 >     extern "C"
14176 > #  endif
14177 >   int FC_DUMMY_MAIN() { return 1; }
14178 > #endif
14179 > #endif
14180 > int
14181 > main ()
14182 > {
14183 > main ();
14184 >  ;
14185 >  return 0;
14186 > }
14187 > _ACEOF
14188 > rm -f conftest.$ac_objext conftest$ac_exeext
14189 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14190 >  (eval $ac_link) 2>conftest.er1
14191 >  ac_status=$?
14192 >  grep -v '^ *+' conftest.er1 >conftest.err
14193 >  rm -f conftest.er1
14194 >  cat conftest.err >&5
14195 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14196 >  (exit $ac_status); } &&
14197 >         { ac_try='test -z "$ac_c_werror_flag"
14198 >                         || test ! -s conftest.err'
14199 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14200 >  (eval $ac_try) 2>&5
14201 >  ac_status=$?
14202 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14203 >  (exit $ac_status); }; } &&
14204 >         { ac_try='test -s conftest$ac_exeext'
14205 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14206 >  (eval $ac_try) 2>&5
14207 >  ac_status=$?
14208 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14209 >  (exit $ac_status); }; }; then
14210 >  ac_cv_lib_CGAL_main=yes
14211 > else
14212 >  echo "$as_me: failed program was:" >&5
14213 > sed 's/^/| /' conftest.$ac_ext >&5
14214  
14215 <    if test "x$cgal" = xyes; then
14216 <      save_LIBS="$LIBS"
14217 <      LIBS="$LIBS -L$CGAL_LIBDIR"
14218 <      if test "x$CGAL_USES_LEDA" = xyes; then
14219 <        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
14220 <      fi
14221 <      # if test "x$CGAL_USES_GMP" = xyes; then
14222 <      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
14223 <      # fi
14224 <      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
14225 < echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
14226 < save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
14227 < CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
14228 < save_LIBS_CHECK_CXX_LIB="$LIBS"
14229 < LIBS="-lCGAL  $LIBS"
14215 > ac_cv_lib_CGAL_main=no
14216 > fi
14217 > rm -f conftest.err conftest.$ac_objext \
14218 >      conftest$ac_exeext conftest.$ac_ext
14219 > LIBS=$ac_check_lib_save_LIBS
14220 > fi
14221 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
14222 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
14223 > if test $ac_cv_lib_CGAL_main = yes; then
14224 >  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
14225 >                                                  cgal_have_lib=yes
14226 > else
14227 >  cgal_have_lib=no
14228 > fi
14229 >
14230 >                        LIBS="$save_LIBS"
14231 >                else
14232 >                        CGAL_LIBS="-lCGAL"
14233 >                        echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
14234 > echo $ECHO_N "checking for main in -lmpfr... $ECHO_C" >&6
14235 > if test "${ac_cv_lib_mpfr_main+set}" = set; then
14236 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14237 > else
14238 >  ac_check_lib_save_LIBS=$LIBS
14239 > LIBS="-lmpfr  $LIBS"
14240   cat >conftest.$ac_ext <<_ACEOF
14241   /* confdefs.h.  */
14242   _ACEOF
14243   cat confdefs.h >>conftest.$ac_ext
14244   cat >>conftest.$ac_ext <<_ACEOF
14245   /* end confdefs.h.  */
14246 < #include <CGAL/Cartesian.h>
14246 >
14247 >
14248 > #ifdef FC_DUMMY_MAIN
14249 > #ifndef FC_DUMMY_MAIN_EQ_F77
14250 > #  ifdef __cplusplus
14251 >     extern "C"
14252 > #  endif
14253 >   int FC_DUMMY_MAIN() { return 1; }
14254 > #endif
14255 > #endif
14256   int
14257   main ()
14258   {
14259 < ::CGAL::Cartesian<int>::Point_2 P
14259 > main ();
14260    ;
14261    return 0;
14262   }
# Line 10299 | Line 14270 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14270    cat conftest.err >&5
14271    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14272    (exit $ac_status); } &&
14273 <         { ac_try='test -z "$ac_cxx_werror_flag"
14273 >         { ac_try='test -z "$ac_c_werror_flag"
14274                           || test ! -s conftest.err'
14275    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14276    (eval $ac_try) 2>&5
# Line 10312 | Line 14283 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14283    ac_status=$?
14284    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14285    (exit $ac_status); }; }; then
14286 <  echo "$as_me:$LINENO: result: yes" >&5
10316 < echo "${ECHO_T}yes" >&6
10317 < cgal=yes
14286 >  ac_cv_lib_mpfr_main=yes
14287   else
14288    echo "$as_me: failed program was:" >&5
14289   sed 's/^/| /' conftest.$ac_ext >&5
14290  
14291 < echo "$as_me:$LINENO: result: no" >&5
10323 < echo "${ECHO_T}no" >&6
10324 < cgal=no
14291 > ac_cv_lib_mpfr_main=no
14292   fi
14293   rm -f conftest.err conftest.$ac_objext \
14294        conftest$ac_exeext conftest.$ac_ext
14295 < CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
14296 < LIBS="$save_LIBS_CHECK_CXX_LIB"
14297 <      LIBS="$save_LIBS"
14298 <    fi
14295 > LIBS=$ac_check_lib_save_LIBS
14296 > fi
14297 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
14298 > echo "${ECHO_T}$ac_cv_lib_mpfr_main" >&6
14299 > if test $ac_cv_lib_mpfr_main = yes; then
14300 >  CGAL_LIBS="$CGAL_LIBS -lmpfr"
14301 > fi
14302  
14303 <  fi
14304 <  ac_ext=c
14305 < ac_cpp='$CPP $CPPFLAGS'
14306 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14307 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14308 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
14303 >                        echo "$as_me:$LINENO: checking for main in -lgmp" >&5
14304 > echo $ECHO_N "checking for main in -lgmp... $ECHO_C" >&6
14305 > if test "${ac_cv_lib_gmp_main+set}" = set; then
14306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14307 > else
14308 >  ac_check_lib_save_LIBS=$LIBS
14309 > LIBS="-lgmp  $LIBS"
14310 > cat >conftest.$ac_ext <<_ACEOF
14311 > /* confdefs.h.  */
14312 > _ACEOF
14313 > cat confdefs.h >>conftest.$ac_ext
14314 > cat >>conftest.$ac_ext <<_ACEOF
14315 > /* end confdefs.h.  */
14316  
14317  
14318 + #ifdef FC_DUMMY_MAIN
14319 + #ifndef FC_DUMMY_MAIN_EQ_F77
14320 + #  ifdef __cplusplus
14321 +     extern "C"
14322 + #  endif
14323 +   int FC_DUMMY_MAIN() { return 1; }
14324 + #endif
14325 + #endif
14326 + int
14327 + main ()
14328 + {
14329 + main ();
14330 +  ;
14331 +  return 0;
14332 + }
14333 + _ACEOF
14334 + rm -f conftest.$ac_objext conftest$ac_exeext
14335 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14336 +  (eval $ac_link) 2>conftest.er1
14337 +  ac_status=$?
14338 +  grep -v '^ *+' conftest.er1 >conftest.err
14339 +  rm -f conftest.er1
14340 +  cat conftest.err >&5
14341 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14342 +  (exit $ac_status); } &&
14343 +         { ac_try='test -z "$ac_c_werror_flag"
14344 +                         || test ! -s conftest.err'
14345 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14346 +  (eval $ac_try) 2>&5
14347 +  ac_status=$?
14348 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14349 +  (exit $ac_status); }; } &&
14350 +         { ac_try='test -s conftest$ac_exeext'
14351 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14352 +  (eval $ac_try) 2>&5
14353 +  ac_status=$?
14354 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14355 +  (exit $ac_status); }; }; then
14356 +  ac_cv_lib_gmp_main=yes
14357 + else
14358 +  echo "$as_me: failed program was:" >&5
14359 + sed 's/^/| /' conftest.$ac_ext >&5
14360 +
14361 + ac_cv_lib_gmp_main=no
14362   fi
14363 + rm -f conftest.err conftest.$ac_objext \
14364 +      conftest$ac_exeext conftest.$ac_ext
14365 + LIBS=$ac_check_lib_save_LIBS
14366 + fi
14367 + echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
14368 + echo "${ECHO_T}$ac_cv_lib_gmp_main" >&6
14369 + if test $ac_cv_lib_gmp_main = yes; then
14370 +  CGAL_LIBS="$CGAL_LIBS -lgmp"
14371 + fi
14372  
14373 < if test "x$cgal" = xyes; then
14374 <  USE_CGAL=yes
14375 <
14376 < cat >>confdefs.h <<\_ACEOF
14377 < #define HAVE_CGAL 1
14373 >                        echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
14374 > echo $ECHO_N "checking for main in -lgmpxx... $ECHO_C" >&6
14375 > if test "${ac_cv_lib_gmpxx_main+set}" = set; then
14376 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14377 > else
14378 >  ac_check_lib_save_LIBS=$LIBS
14379 > LIBS="-lgmpxx  $LIBS"
14380 > cat >conftest.$ac_ext <<_ACEOF
14381 > /* confdefs.h.  */
14382   _ACEOF
14383 + cat confdefs.h >>conftest.$ac_ext
14384 + cat >>conftest.$ac_ext <<_ACEOF
14385 + /* end confdefs.h.  */
14386  
14387  
14388 < cat >>confdefs.h <<_ACEOF
14389 < #define CGAL_VERSION $CGAL_VERSION
14388 > #ifdef FC_DUMMY_MAIN
14389 > #ifndef FC_DUMMY_MAIN_EQ_F77
14390 > #  ifdef __cplusplus
14391 >     extern "C"
14392 > #  endif
14393 >   int FC_DUMMY_MAIN() { return 1; }
14394 > #endif
14395 > #endif
14396 > int
14397 > main ()
14398 > {
14399 > main ();
14400 >  ;
14401 >  return 0;
14402 > }
14403   _ACEOF
14404 + rm -f conftest.$ac_objext conftest$ac_exeext
14405 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14406 +  (eval $ac_link) 2>conftest.er1
14407 +  ac_status=$?
14408 +  grep -v '^ *+' conftest.er1 >conftest.err
14409 +  rm -f conftest.er1
14410 +  cat conftest.err >&5
14411 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14412 +  (exit $ac_status); } &&
14413 +         { ac_try='test -z "$ac_c_werror_flag"
14414 +                         || test ! -s conftest.err'
14415 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14416 +  (eval $ac_try) 2>&5
14417 +  ac_status=$?
14418 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14419 +  (exit $ac_status); }; } &&
14420 +         { ac_try='test -s conftest$ac_exeext'
14421 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14422 +  (eval $ac_try) 2>&5
14423 +  ac_status=$?
14424 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14425 +  (exit $ac_status); }; }; then
14426 +  ac_cv_lib_gmpxx_main=yes
14427 + else
14428 +  echo "$as_me: failed program was:" >&5
14429 + sed 's/^/| /' conftest.$ac_ext >&5
14430  
14431 <  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
14432 <    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14433 < echo "$as_me: WARNING: *****************************************************" >&2;}
14434 <    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
14435 < echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
14436 <    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
14437 < echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
14438 <    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14439 < echo "$as_me: WARNING: *****************************************************" >&2;}
14440 <  fi
14431 > ac_cv_lib_gmpxx_main=no
14432 > fi
14433 > rm -f conftest.err conftest.$ac_objext \
14434 >      conftest$ac_exeext conftest.$ac_ext
14435 > LIBS=$ac_check_lib_save_LIBS
14436 > fi
14437 > echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
14438 > echo "${ECHO_T}$ac_cv_lib_gmpxx_main" >&6
14439 > if test $ac_cv_lib_gmpxx_main = yes; then
14440 >  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
14441 > fi
14442 >
14443 >                fi
14444 >
14445 >                if test "$cgal_have_lib" == yes; then
14446 >                        acx_cgal_found=yes
14447 >                fi
14448 >        fi
14449 >        if test "$acx_cgal_found" == yes; then
14450 >                echo "$as_me:$LINENO: checking for main in -lCore" >&5
14451 > echo $ECHO_N "checking for main in -lCore... $ECHO_C" >&6
14452 > if test "${ac_cv_lib_Core_main+set}" = set; then
14453 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14454   else
14455 <   if test "x$cgal_makefile" != xno; then
14456 <    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
14457 < echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
14458 <  fi
14459 <  CGAL_INCLDIR=
14460 <  CGAL_LIBDIR=
14461 <  CGAL_RLIBDIR=
14462 <  CGAL_DEFINES=
14463 <  CGAL_CXXFLAGS=
14464 <  CGAL_LIBS=
14455 >  ac_check_lib_save_LIBS=$LIBS
14456 > LIBS="-lCore  $LIBS"
14457 > cat >conftest.$ac_ext <<_ACEOF
14458 > /* confdefs.h.  */
14459 > _ACEOF
14460 > cat confdefs.h >>conftest.$ac_ext
14461 > cat >>conftest.$ac_ext <<_ACEOF
14462 > /* end confdefs.h.  */
14463 >
14464 >
14465 > #ifdef FC_DUMMY_MAIN
14466 > #ifndef FC_DUMMY_MAIN_EQ_F77
14467 > #  ifdef __cplusplus
14468 >     extern "C"
14469 > #  endif
14470 >   int FC_DUMMY_MAIN() { return 1; }
14471 > #endif
14472 > #endif
14473 > int
14474 > main ()
14475 > {
14476 > main ();
14477 >  ;
14478 >  return 0;
14479 > }
14480 > _ACEOF
14481 > rm -f conftest.$ac_objext conftest$ac_exeext
14482 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14483 >  (eval $ac_link) 2>conftest.er1
14484 >  ac_status=$?
14485 >  grep -v '^ *+' conftest.er1 >conftest.err
14486 >  rm -f conftest.er1
14487 >  cat conftest.err >&5
14488 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14489 >  (exit $ac_status); } &&
14490 >         { ac_try='test -z "$ac_c_werror_flag"
14491 >                         || test ! -s conftest.err'
14492 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14493 >  (eval $ac_try) 2>&5
14494 >  ac_status=$?
14495 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14496 >  (exit $ac_status); }; } &&
14497 >         { ac_try='test -s conftest$ac_exeext'
14498 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14499 >  (eval $ac_try) 2>&5
14500 >  ac_status=$?
14501 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14502 >  (exit $ac_status); }; }; then
14503 >  ac_cv_lib_Core_main=yes
14504 > else
14505 >  echo "$as_me: failed program was:" >&5
14506 > sed 's/^/| /' conftest.$ac_ext >&5
14507 >
14508 > ac_cv_lib_Core_main=no
14509   fi
14510 + rm -f conftest.err conftest.$ac_objext \
14511 +      conftest$ac_exeext conftest.$ac_ext
14512 + LIBS=$ac_check_lib_save_LIBS
14513 + fi
14514 + echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
14515 + echo "${ECHO_T}$ac_cv_lib_Core_main" >&6
14516 + if test $ac_cv_lib_Core_main = yes; then
14517 +  CGAL_LIBS="$CGAL_LIBS -lCore"
14518 + fi
14519  
14520 +        fi
14521 + fi
14522  
10379 CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
14523  
10381 CGAL_LIB_DIR=${CGAL_LIBDIR}
14524  
14525 < CGAL_RLIB_DIR=${CGAL_RLIBDIR}
14525 > echo "$as_me:$LINENO: checking CGAL" >&5
14526 > echo $ECHO_N "checking CGAL... $ECHO_C" >&6
14527 > if test "$acx_cgal_found" == yes; then
14528 >        echo "$as_me:$LINENO: result: yes" >&5
14529 > echo "${ECHO_T}yes" >&6;
14530  
14531 + else
14532 +        echo "$as_me:$LINENO: result: no" >&5
14533 + echo "${ECHO_T}no" >&6
14534  
14535 + fi
14536  
14537 + if test "$acx_cgal_found" == yes; then
14538 +        USE_CGAL=yes
14539  
14540 + cat >>confdefs.h <<\_ACEOF
14541 + #define HAVE_CGAL 1
14542 + _ACEOF
14543  
14544  
14545  
14546 +
14547 +
14548 +
14549 + fi
14550 +
14551 +
14552 +
14553 +
14554   # Check whether --enable-doxygen or --disable-doxygen was given.
14555   if test "${enable_doxygen+set}" = set; then
14556    enableval="$enable_doxygen"
# Line 10529 | Line 14692 | fi
14692  
14693  
14694  
10532 OBJEXT=".$OBJEXT"
14695  
10534 OOPSE=oopse
14696  
10536 if test "x${prefix}" = "xNONE"
10537 then
10538  OOPSE_HOME=${ac_default_prefix}/oopse
10539 else
10540  OOPSE_HOME=${prefix}/oopse
10541 fi
10542 # Check whether --enable-oopse-home or --disable-oopse-home was given.
10543 if test "${enable_oopse_home+set}" = set; then
10544  enableval="$enable_oopse_home"
10545  OOPSE_HOME="${enableval}"
10546 fi;
14697  
10548 case "x$INSTALL" in
10549   x/*) ;;
10550   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10551 esac
14698  
10553 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14699  
10555 CFLAGS=${CFLAGS-""}
10556 CXXFLAGS=${CXXFLAGS-""}
10557 CPPFLAGS=${CPPFLAGS-""}
10558 FFLAGS=${FFLAGS-""}
10559 F90FLAGS=${F90FLAGS-""}
10560 LDFLAGS=${LDFLAGS-""}
10561 DEBUG=${DEBUG-"-g"}
14700  
10563 case $debug in
10564  1)
10565     FFLAGS="$DEBUG $FFLAGS"
10566     F90FLAGS="$DEBUG $F90FLAGS"
10567     ;;
10568  *)
10569     ;;
10570 esac
14701  
14702  
14703  
14704  
14705  
14706  
14707 <
10578 <
10579 <
10580 <
10581 <
10582 <
10583 <
10584 <
10585 <
10586 <
10587 <
10588 <
10589 <          ac_config_headers="$ac_config_headers src/config.h"
10590 <
10591 <                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14707 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile scripts/filepp"
14708  
14709  
14710   cat >confcache <<\_ACEOF
# Line 10953 | Line 15069 | cat >&5 <<_CSEOF
15069   } >&5
15070   cat >&5 <<_CSEOF
15071  
15072 < This file was extended by OOPSE $as_me 2.0, which was
15072 > This file was extended by OOPSE $as_me 4.0, which was
15073   generated by GNU Autoconf 2.59.  Invocation command line was
15074  
15075    CONFIG_FILES    = $CONFIG_FILES
# Line 11016 | Line 15132 | ac_cs_version="\\
15132  
15133   cat >>$CONFIG_STATUS <<_ACEOF
15134   ac_cs_version="\\
15135 < OOPSE config.status 2.0
15135 > OOPSE config.status 4.0
15136   configured by $0, generated by GNU Autoconf 2.59,
15137    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
15138  
# Line 11121 | Line 15237 | do
15237    # Handling of arguments.
15238    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
15239    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
15240 <  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
15240 >  "src/math/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
15241    "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
15242    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
15243    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
# Line 11210 | Line 15326 | s,@LIBS@,$LIBS,;t t
15326   s,@ECHO_N@,$ECHO_N,;t t
15327   s,@ECHO_T@,$ECHO_T,;t t
15328   s,@LIBS@,$LIBS,;t t
11213 s,@PROGNAME@,$PROGNAME,;t t
11214 s,@debug@,$debug,;t t
15329   s,@build@,$build,;t t
15330   s,@build_cpu@,$build_cpu,;t t
15331   s,@build_vendor@,$build_vendor,;t t
# Line 11220 | Line 15334 | s,@host_os@,$host_os,;t t
15334   s,@host_cpu@,$host_cpu,;t t
15335   s,@host_vendor@,$host_vendor,;t t
15336   s,@host_os@,$host_os,;t t
15337 < s,@CC@,$CC,;t t
15338 < s,@CFLAGS@,$CFLAGS,;t t
15337 > s,@PROGNAME@,$PROGNAME,;t t
15338 > s,@debug@,$debug,;t t
15339 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
15340 > s,@CXX@,$CXX,;t t
15341 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15342   s,@LDFLAGS@,$LDFLAGS,;t t
15343   s,@CPPFLAGS@,$CPPFLAGS,;t t
15344 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15344 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15345   s,@EXEEXT@,$EXEEXT,;t t
15346   s,@OBJEXT@,$OBJEXT,;t t
15347 < s,@CXX@,$CXX,;t t
15348 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15349 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15347 > s,@CC@,$CC,;t t
15348 > s,@CFLAGS@,$CFLAGS,;t t
15349 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15350 > s,@FC@,$FC,;t t
15351 > s,@FCFLAGS@,$FCFLAGS,;t t
15352 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15353   s,@CPP@,$CPP,;t t
15354   s,@EGREP@,$EGREP,;t t
11235 s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11236 s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11237 s,@F90@,$F90,;t t
11238 s,@F90FLAGS@,$F90FLAGS,;t t
11239 s,@ac_ct_F90@,$ac_ct_F90,;t t
11240 s,@PREPFLAG@,$PREPFLAG,;t t
11241 s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11242 s,@F90LIBS@,$F90LIBS,;t t
11243 s,@F90_FUNC@,$F90_FUNC,;t t
11244 s,@F90_FUNC_@,$F90_FUNC_,;t t
11245 s,@MOD@,$MOD,;t t
11246 s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11247 s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11248 s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11249 s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
11250 s,@CXXCPP@,$CXXCPP,;t t
11251 s,@LIBOBJS@,$LIBOBJS,;t t
11252 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11253 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11254 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15355   s,@LN_S@,$LN_S,;t t
15356   s,@SET_MAKE@,$SET_MAKE,;t t
15357   s,@RANLIB@,$RANLIB,;t t
15358   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11259 s,@YACC@,$YACC,;t t
11260 s,@LEX@,$LEX,;t t
11261 s,@LEXLIB@,$LEXLIB,;t t
11262 s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15359   s,@PERLINTERP@,$PERLINTERP,;t t
15360   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15361 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15362 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15363 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15364   s,@AR@,$AR,;t t
15365   s,@PS@,$PS,;t t
15366 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15367 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15368 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15369 + s,@FCLIBS@,$FCLIBS,;t t
15370 + s,@FC_FUNC@,$FC_FUNC,;t t
15371 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15372 + s,@MOD@,$MOD,;t t
15373 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15374 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15375 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15376 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15377 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
15378 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
15379 + s,@ZLIB@,$ZLIB,;t t
15380 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
15381 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
15382 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
15383 + s,@QHULL_INC_DIR@,$QHULL_INC_DIR,;t t
15384 + s,@QHULL_LIB_DIR@,$QHULL_LIB_DIR,;t t
15385 + s,@QHULL@,$QHULL,;t t
15386 + s,@LIBOBJS@,$LIBOBJS,;t t
15387 + s,@POW_LIB@,$POW_LIB,;t t
15388 + s,@CXXCPP@,$CXXCPP,;t t
15389 + s,@__func__@,$__func__,;t t
15390   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15391   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15392   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
# Line 11271 | Line 15394 | s,@USE_CGAL@,$USE_CGAL,;t t
15394   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15395   s,@USE_MPI@,$USE_MPI,;t t
15396   s,@USE_CGAL@,$USE_CGAL,;t t
11274 s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
11275 s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
11276 s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
11277 s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
15397   s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15398 + s,@CGAL_LDFLAGS@,$CGAL_LDFLAGS,;t t
15399 + s,@CGAL_CPPFLAGS@,$CGAL_CPPFLAGS,;t t
15400   s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15401   s,@DOXYGEN@,$DOXYGEN,;t t
15402   s,@DOT@,$DOT,;t t
# Line 11288 | Line 15409 | s,@SUBDIRS@,$SUBDIRS,;t t
15409   s,@OOPSE@,$OOPSE,;t t
15410   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15411   s,@SUBDIRS@,$SUBDIRS,;t t
11291 s,@FFLAGS@,$FFLAGS,;t t
15412   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15413   CEOF
15414  
# Line 11530 | Line 15650 | s,@INSTALL@,$ac_INSTALL,;t t
15650    case $ac_file in
15651      make/Makefile ) chmod 0755 scripts/* ;;
15652      src/utils/Makefile ) chmod 0755 scripts/* ;;
15653 <    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15653 >    src/math/Makefile ) chmod 0755 scripts/* ;;
15654      scripts/filepp ) chmod 0755 scripts/* ;;
15655    esac
15656   done

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines