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 616 by gezelter, Tue Sep 20 22:03:35 2005 UTC vs.
Revision 973 by gezelter, Thu May 25 14:54:41 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI CXXCPP USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug USE_SINGLE_PRECISION CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
764 ac_env_LDFLAGS_set=${LDFLAGS+set}
765 ac_env_LDFLAGS_value=$LDFLAGS
766 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 ac_cv_env_LDFLAGS_value=$LDFLAGS
768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 ac_env_CPPFLAGS_value=$CPPFLAGS
770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874 +  --enable-single         compile OOPSE in single precision
875 +  --enable-float          synonym for --enable-single
876    --enable-doxygen        enable documentation generation with doxygen (auto)
877    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
878    --enable-html-docs      enable HTML generation with doxygen (yes)
879    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880  
881   Optional Packages:
882    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882  --with-zlib=DIR root directory path of zlib installation defaults to
883                    /usr/local or /usr if not found in /usr/local
884  --without-zlib to disable zlib usage completely
884    --with-perl-shebang     override what perl thinks is the way for the kernel
885                            to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891    --with-cgal-makefile=FILE  CGAL makefile that should be used
892  
893   Some influential environment variables:
894 <  CC          C compiler command
895 <  CFLAGS      C compiler flags
894 >  CXX         C++ compiler command
895 >  CXXFLAGS    C++ compiler flags
896    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
897                nonstandard directory <lib dir>
898    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
899                headers in a nonstandard directory <include dir>
900 <  CXX         C++ compiler command
901 <  CXXFLAGS    C++ compiler flags
902 <  F90         Fortran 90 compiler command
903 <  F90FLAGS    Fortran 90 compiler flags
900 >  CC          C compiler command
901 >  CFLAGS      C compiler flags
902 >  FC          Fortran compiler command
903 >  FCFLAGS     Fortran compiler flags
904    CPP         C preprocessor
905    CXXCPP      C++ preprocessor
906  
# Line 1000 | Line 1003 | if $ac_init_version; then
1003   test -n "$ac_init_help" && exit 0
1004   if $ac_init_version; then
1005    cat <<\_ACEOF
1006 < OOPSE configure 2.0
1006 > OOPSE configure 3.0
1007   generated by GNU Autoconf 2.59
1008  
1009   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1017 | running configure, to aid debugging if configure makes
1017   This file contains any messages produced by compilers while
1018   running configure, to aid debugging if configure makes a mistake.
1019  
1020 < It was created by OOPSE $as_me 2.0, which was
1020 > It was created by OOPSE $as_me 3.0, which was
1021   generated by GNU Autoconf 2.59.  Invocation command line was
1022  
1023    $ $0 $@
# Line 1376 | Line 1379 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1379   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1380  
1381  
1382 < # This file is part of Autoconf.                       -*- Autoconf -*-
1380 < # Programming languages support.
1381 < # Copyright 2000, 2001
1382 < # Free Software Foundation, Inc.
1383 < #
1384 < # This program is free software; you can redistribute it and/or modify
1385 < # it under the terms of the GNU General Public License as published by
1386 < # the Free Software Foundation; either version 2, or (at your option)
1387 < # any later version.
1388 < #
1389 < # This program is distributed in the hope that it will be useful,
1390 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 < # GNU General Public License for more details.
1393 < #
1394 < # You should have received a copy of the GNU General Public License
1395 < # along with this program; if not, write to the Free Software
1396 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 < # 02111-1307, USA.
1398 < #
1399 < # As a special exception, the Free Software Foundation gives unlimited
1400 < # permission to copy, distribute and modify the configure scripts that
1401 < # are the output of Autoconf.  You need not follow the terms of the GNU
1402 < # General Public License when using or distributing such scripts, even
1403 < # though portions of the text of Autoconf appear in them.  The GNU
1404 < # General Public License (GPL) does govern all other use of the material
1405 < # that constitutes the Autoconf program.
1406 < #
1407 < # Certain portions of the Autoconf source text are designed to be copied
1408 < # (in certain cases, depending on the input) into the output of
1409 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 < # source text consists of comments plus executable code that decides which
1411 < # of the data portions to output in any given case.  We call these
1412 < # comments and executable code the "non-data" portions.  Autoconf never
1413 < # copies any of the non-data portions into its output.
1414 < #
1415 < # This special exception to the GPL applies to versions of Autoconf
1416 < # released by the Free Software Foundation.  When you make and
1417 < # distribute a modified version of Autoconf, you may extend this special
1418 < # exception to the GPL to apply to your modified version as well, *unless*
1419 < # your modified version has the potential to copy into its output some
1420 < # of the text that was the non-data portion of the version that you started
1421 < # with.  (In other words, unless your change moves or copies text from
1422 < # the non-data portions to the data portions.)  If your modification has
1423 < # such potential, you must delete any notice of this special exception
1424 < # to the GPL from your modified version.
1425 < #
1426 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 < # many others).
1382 >          ac_config_headers="$ac_config_headers src/config.h"
1383  
1384  
1430 # Table of Contents:
1431 #
1432 # 1. Language selection
1433 #    and routines to produce programs in a given language.
1434 #  a. Fortran 77 (to be moved from aclang.m4)
1435 #  b. Fortran 90
1436 #  c. Fortran 95
1437 #
1438 # 2. Producing programs in a given language.
1439 #  a. Fortran 77 (to be moved from aclang.m4)
1440 #  b. Fortran 90
1441 #  c. Fortran 95
1442 #
1443 # 3. Looking for a compiler
1444 #    And possibly the associated preprocessor.
1445 #  a. Fortran 77 (to be moved from aclang.m4)
1446 #  b. Fortran 90
1447 #  c. Fortran 95
1448 #
1449 # 4. Compilers' characteristics.
1450 #  a. Fortran 77 (to be moved from aclang.m4)
1451 #  b. Fortran 90
1452 #  c. Fortran 95
1385  
1454 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 # ---------------------------------------------------------------------------
1456 #
1457 # Processing the elements of a list is tedious in shell programming,
1458 # as lists tend to be implemented as space delimited strings.
1459 #
1460 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 # if ELEMENT is a member of LIST, otherwise it executes
1462 # ACTION-IF-NOT-FOUND.
1463 # _AC_LIST_MEMBER_IF
1386  
1387  
1388  
1467 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 # -------------------------------------------------
1469 #
1470 # Specifying options to the compiler (whether it be the C, C++ or
1471 # Fortran 77 compiler) that are meant for the linker is compiler
1472 # dependent.  This macro lets you give options to the compiler that
1473 # are meant for the linker in a portable, compiler-independent way.
1474 #
1475 # This macro take two arguments, a list of linker options that the
1476 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 # appended to the shell variable in a compiler-dependent way.
1479 #
1480 # For example, if the selected language is C, then this:
1481 #
1482 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 #
1484 # will expand into this if the selected C compiler is gcc:
1485 #
1486 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 #
1488 # otherwise, it will expand into this:
1489 #
1490 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 #
1492 # You are encouraged to add support for compilers that this macro
1493 # doesn't currently support.
1494 # FIXME: Get rid of this macro.
1495 # _AC_LINKER_OPTION
1389  
1390  
1391  
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1392  
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1393  
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1394  
1395  
1396  
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1397  
1398  
1399  
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1400  
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1401  
1402  
1403  
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1404  
1405  
1406  
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1407  
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1408  
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1541
1542
1543
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1546
1547
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1550
1551
1552
1553 # ------------------------ #
1554 # 2c. Fortran 95 sources.  #
1555 # ------------------------ #
1556
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1559
1560
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1563
1564
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1567
1568
1569
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1573
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1409  
1410  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1411  
1412  
1413  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1414  
1415  
1416  
1592 # AC_PROG_F90([COMPILERS...])
1593 # ---------------------------
1594 # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 # for.
1596 #
1597 # Compilers are ordered by
1598 #  1. F90, F95
1599 #  2. Good/tested native compilers, bad/untested native compilers
1600 #
1601 # pgf90 is the Portland Group F90 compilers.
1602 # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1603 # lf95 is the Lahey-Fujitsu compiler.
1604 # epcf90 is the "Edinburgh Portable Compiler" F90.
1605 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1606 # AC_PROG_F90
1417  
1418  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1419  
1420  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1421  
1422  
1423  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1424  
1425  
1426  
1627 # AC_PROG_F95([COMPILERS...])
1628 # ---------------------------
1629 # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 # for.
1427   #
1632 # Compilers are ordered by
1633 #  1. Good/tested native compilers, bad/untested native compilers
1428   #
1429 < # xlf95 is the IBM (AIX) F95 compiler.
1636 < # lf95 is the Lahey-Fujitsu compiler.
1637 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1638 < # AC_PROG_F95
1429 > #
1430  
1431  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1432  
1433  
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1434  
1435  
1436 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1437 < # -------------------------------------------------
1653 < # Link a trivial Fortran program, compiling with a verbose output FLAG
1654 < # (which default value, $ac_cv_prog_f90_v, is computed by
1655 < # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1656 < # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1657 < # so that any link flags that are echoed by the compiler appear as
1658 < # space-separated items.
1659 < # _AC_PROG_F90_V_OUTPUT
1660 <
1661 <
1662 < # _AC_PROG_F90_V
1663 < # --------------
1436 > # AC_F90_MODULE_NAMES
1437 > # -------------------
1438   #
1439 < # Determine the flag that causes the Fortran 90 compiler to print
1666 < # information of library and object files (normally -v)
1667 < # Needed for AC_F90_LIBRARY_FLAGS
1668 < # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1669 < # _AC_PROG_F90_V
1670 <
1671 <
1672 < # AC_F90_LIBRARY_LDFLAGS
1673 < # ----------------------
1439 > # Figure out how the Fortran 90 compiler constructs module file names
1440   #
1441 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 < # intrinsic and run-time libraries that are required to successfully
1677 < # link a Fortran 90 program or shared library.  The output variable
1678 < # F90LIBS is set to these flags.
1679 < #
1680 < # This macro is intended to be used in those situations when it is
1681 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 < # program or shared library.
1683 < #
1684 < # For example, if object files from a C++ and Fortran 90 compiler must
1685 < # be linked together, then the C++ compiler/linker must be used for
1686 < # linking (since special C++-ish things need to happen at link time
1687 < # like calling global constructors, instantiating templates, enabling
1688 < # exception support, etc.).
1689 < #
1690 < # However, the Fortran 90 intrinsic and run-time libraries must be
1691 < # linked in as well, but the C++ compiler/linker doesn't know how to
1692 < # add these Fortran 90 libraries.  Hence, the macro
1693 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 < # libraries.
1695 < #
1696 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 < # AC_F90_LIBRARY_LDFLAGS
1441 > # AC_F90_MODULE_NAMES
1442  
1443  
1700 # _AC_F90_NAME_MANGLING
1701 # ---------------------
1702 # Test for the name mangling scheme used by the Fortran 90 compiler.
1703 #
1704 # Sets ac_cv_f90_mangling. The value contains three fields, separated
1705 # by commas:
1706 #
1707 # lower case / upper case:
1708 #    case translation of the Fortan 90 symbols
1709 # underscore / no underscore:
1710 #    whether the compiler appends "_" to symbol names
1711 # extra underscore / no extra underscore:
1712 #    whether the compiler appends an extra "_" to symbol names already
1713 #    containing at least one underscore
1714 #
1715 # _AC_F90_NAME_MANGLING
1444  
1717 # The replacement is empty.
1718
1719
1720
1721 # AC_F90_WRAPPERS
1722 # ---------------
1723 # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1724 # properly mangle the names of C identifiers, and C identifiers with
1725 # underscores, respectively, so that they match the name mangling
1726 # scheme used by the Fortran 90 compiler.
1727 # AC_F90_WRAPPERS
1728
1729
1730 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1731 # ------------------------------------
1732 # For a Fortran subroutine of given NAME, define a shell variable
1733 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1734 # argument is not supplied, it defaults to NAME.
1735 # AC_F90_FUNC
1445  
1446  
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1447  
1448  
1743 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1744 # -------------------------------------------------
1745 # Link a trivial Fortran program, compiling with a verbose output FLAG
1746 # (which default value, $ac_cv_prog_f95_v, is computed by
1747 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1748 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1749 # so that any link flags that are echoed by the compiler appear as
1750 # space-separated items.
1751 # _AC_PROG_F95_V_OUTPUT
1449  
1450  
1754 # _AC_PROG_F95_V
1755 # --------------
1756 #
1757 # Determine the flag that causes the Fortran 95 compiler to print
1758 # information of library and object files (normally -v)
1759 # Needed for AC_F95_LIBRARY_FLAGS
1760 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 # _AC_PROG_F95_V
1451  
1452  
1764 # AC_F95_LIBRARY_LDFLAGS
1765 # ----------------------
1766 #
1767 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 # intrinsic and run-time libraries that are required to successfully
1769 # link a Fortran 95 program or shared library.  The output variable
1770 # F95LIBS is set to these flags.
1771 #
1772 # This macro is intended to be used in those situations when it is
1773 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 # program or shared library.
1775 #
1776 # For example, if object files from a C++ and Fortran 95 compiler must
1777 # be linked together, then the C++ compiler/linker must be used for
1778 # linking (since special C++-ish things need to happen at link time
1779 # like calling global constructors, instantiating templates, enabling
1780 # exception support, etc.).
1781 #
1782 # However, the Fortran 95 intrinsic and run-time libraries must be
1783 # linked in as well, but the C++ compiler/linker doesn't know how to
1784 # add these Fortran 95 libraries.  Hence, the macro
1785 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 # libraries.
1787 #
1788 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 # AC_F95_LIBRARY_LDFLAGS
1453  
1454  
1792 # _AC_F95_NAME_MANGLING
1793 # ---------------------
1794 # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 #
1796 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 # by commas:
1798 #
1799 # lower case / upper case:
1800 #    case translation of the Fortan 95 symbols
1801 # underscore / no underscore:
1802 #    whether the compiler appends "_" to symbol names
1803 # extra underscore / no extra underscore:
1804 #    whether the compiler appends an extra "_" to symbol names already
1805 #    containing at least one underscore
1806 #
1807 # _AC_F95_NAME_MANGLING
1455  
1809 # The replacement is empty.
1456  
1457  
1458  
1813 # AC_F95_WRAPPERS
1814 # ---------------
1815 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816 # properly mangle the names of C identifiers, and C identifiers with
1817 # underscores, respectively, so that they match the name mangling
1818 # scheme used by the Fortran 95 compiler.
1819 # AC_F95_WRAPPERS
1459  
1460  
1822 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823 # ------------------------------------
1824 # For a Fortran subroutine of given NAME, define a shell variable
1825 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826 # argument is not supplied, it defaults to NAME.
1827 # AC_F95_FUNC
1461  
1829 # AC_F90_MODULE_NAMES
1830 # -------------------
1831 #
1832 # Figure out how the Fortran 90 compiler constructs module file names
1833 #
1834 # AC_F90_MODULE_NAMES
1462  
1463  
1464  
# Line 1885 | Line 1512 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1512  
1513  
1514  
1888 #
1889 #
1890 #
1515  
1516  
1517  
# Line 1896 | Line 1520 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1520  
1521  
1522  
1899 # set program name
1900 PROGNAME="oopse"
1523  
1524  
1903 # there are two ways to do debugging.  One with the --enable-debug flag
1904 # and one using the DEBUG environment variable
1525  
1906 debug=0
1907 # Check whether --enable-debug or --disable-debug was given.
1908 if test "${enable_debug+set}" = set; then
1909  enableval="$enable_debug"
1910  debug=1
1911 fi;
1912 if test "${DEBUG}"; then
1526  
1914 cat >>confdefs.h <<\_ACEOF
1915 #define debug 1
1916 _ACEOF
1527  
1918  msg="$msg, debug mode"
1919 fi
1528  
1529  
1530   # who am i
# Line 1977 | Line 1585 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1585  
1586  
1587  
1588 < ac_ext=c
1589 < ac_cpp='$CPP $CPPFLAGS'
1590 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1591 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1592 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1588 > # set program name
1589 > PROGNAME="oopse"
1590 >
1591 >
1592 >
1593 >
1594 > OBJEXT=".$OBJEXT"
1595 >
1596 > OOPSE=oopse
1597 >
1598 > if test "x${prefix}" = "xNONE"
1599 > then
1600 >  OOPSE_HOME=${ac_default_prefix}/oopse
1601 > else
1602 >  OOPSE_HOME=${prefix}/oopse
1603 > fi
1604 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1605 > if test "${enable_oopse_home+set}" = set; then
1606 >  enableval="$enable_oopse_home"
1607 >  OOPSE_HOME="${enableval}"
1608 > fi;
1609 >
1610 > # there are two ways to do debugging.  One with the --enable-debug flag
1611 > # and one using the DEBUG environment variable
1612 >
1613 > debug=0
1614 > # Check whether --enable-debug or --disable-debug was given.
1615 > if test "${enable_debug+set}" = set; then
1616 >  enableval="$enable_debug"
1617 >  debug=1
1618 > fi;
1619 > if test "${DEBUG}"; then
1620 >
1621 > cat >>confdefs.h <<\_ACEOF
1622 > #define debug 1
1623 > _ACEOF
1624 >
1625 >  msg="$msg, debug mode"
1626 > fi
1627 >
1628 >
1629 > # Check whether --enable-single or --disable-single was given.
1630 > if test "${enable_single+set}" = set; then
1631 >  enableval="$enable_single"
1632 >  ok=$enableval
1633 > else
1634 >  ok=no
1635 > fi;
1636 > # Check whether --enable-float or --disable-float was given.
1637 > if test "${enable_float+set}" = set; then
1638 >  enableval="$enable_float"
1639 >  ok=$enableval
1640 > fi;
1641 > if test "$ok" = "yes"; then
1642 >
1643 > cat >>confdefs.h <<\_ACEOF
1644 > #define SINGLE_PRECISION 1
1645 > _ACEOF
1646 >
1647 >        USE_SINGLE_PRECISION=yes
1648 >
1649 > fi
1650 >
1651 > # Checks for programs.
1652 > ac_ext=cc
1653 > ac_cpp='$CXXCPP $CPPFLAGS'
1654 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1655 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1656 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1657   if test -n "$ac_tool_prefix"; then
1658 <  for ac_prog in icc xlc gcc cc
1658 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1659    do
1660      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1661   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1662   echo "$as_me:$LINENO: checking for $ac_word" >&5
1663   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1664 < if test "${ac_cv_prog_CC+set}" = set; then
1664 > if test "${ac_cv_prog_CXX+set}" = set; then
1665    echo $ECHO_N "(cached) $ECHO_C" >&6
1666   else
1667 <  if test -n "$CC"; then
1668 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1667 >  if test -n "$CXX"; then
1668 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1669   else
1670   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1671   for as_dir in $PATH
# Line 2002 | Line 1674 | do
1674    test -z "$as_dir" && as_dir=.
1675    for ac_exec_ext in '' $ac_executable_extensions; do
1676    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1677 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1677 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1678      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1679      break 2
1680    fi
# Line 2011 | Line 1683 | fi
1683  
1684   fi
1685   fi
1686 < CC=$ac_cv_prog_CC
1687 < if test -n "$CC"; then
1688 <  echo "$as_me:$LINENO: result: $CC" >&5
1689 < echo "${ECHO_T}$CC" >&6
1686 > CXX=$ac_cv_prog_CXX
1687 > if test -n "$CXX"; then
1688 >  echo "$as_me:$LINENO: result: $CXX" >&5
1689 > echo "${ECHO_T}$CXX" >&6
1690   else
1691    echo "$as_me:$LINENO: result: no" >&5
1692   echo "${ECHO_T}no" >&6
1693   fi
1694  
1695 <    test -n "$CC" && break
1695 >    test -n "$CXX" && break
1696    done
1697   fi
1698 < if test -z "$CC"; then
1699 <  ac_ct_CC=$CC
1700 <  for ac_prog in icc xlc gcc cc
1698 > if test -z "$CXX"; then
1699 >  ac_ct_CXX=$CXX
1700 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1701   do
1702    # Extract the first word of "$ac_prog", so it can be a program name with args.
1703   set dummy $ac_prog; ac_word=$2
1704   echo "$as_me:$LINENO: checking for $ac_word" >&5
1705   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1706 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1706 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1707    echo $ECHO_N "(cached) $ECHO_C" >&6
1708   else
1709 <  if test -n "$ac_ct_CC"; then
1710 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1709 >  if test -n "$ac_ct_CXX"; then
1710 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1711   else
1712   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1713   for as_dir in $PATH
# Line 2044 | Line 1716 | do
1716    test -z "$as_dir" && as_dir=.
1717    for ac_exec_ext in '' $ac_executable_extensions; do
1718    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1719 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1719 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1720      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1721      break 2
1722    fi
# Line 2053 | Line 1725 | fi
1725  
1726   fi
1727   fi
1728 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1729 < if test -n "$ac_ct_CC"; then
1730 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1731 < echo "${ECHO_T}$ac_ct_CC" >&6
1728 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1729 > if test -n "$ac_ct_CXX"; then
1730 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1731 > echo "${ECHO_T}$ac_ct_CXX" >&6
1732   else
1733    echo "$as_me:$LINENO: result: no" >&5
1734   echo "${ECHO_T}no" >&6
1735   fi
1736  
1737 <  test -n "$ac_ct_CC" && break
1737 >  test -n "$ac_ct_CXX" && break
1738   done
1739 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1740  
1741 <  CC=$ac_ct_CC
1741 >  CXX=$ac_ct_CXX
1742   fi
1743  
1744  
2072 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2073 See \`config.log' for more details." >&5
2074 echo "$as_me: error: no acceptable C compiler found in \$PATH
2075 See \`config.log' for more details." >&2;}
2076   { (exit 1); exit 1; }; }
2077
1745   # Provide some information about the compiler.
1746   echo "$as_me:$LINENO:" \
1747 <     "checking for C compiler version" >&5
1747 >     "checking for C++ compiler version" >&5
1748   ac_compiler=`set X $ac_compile; echo $2`
1749   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1750    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2115 | Line 1782 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1782   # Try to create an executable without -o first, disregard a.out.
1783   # It will help us diagnose broken compilers, and finding out an intuition
1784   # of exeext.
1785 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1786 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1785 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1786 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1787   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1788   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1789    (eval $ac_link_default) 2>&5
# Line 2159 | Line 1826 | sed 's/^/| /' conftest.$ac_ext >&5
1826    echo "$as_me: failed program was:" >&5
1827   sed 's/^/| /' conftest.$ac_ext >&5
1828  
1829 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1829 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1830   See \`config.log' for more details." >&5
1831 < echo "$as_me: error: C compiler cannot create executables
1831 > echo "$as_me: error: C++ compiler cannot create executables
1832   See \`config.log' for more details." >&2;}
1833     { (exit 77); exit 77; }; }
1834   fi
# Line 2172 | Line 1839 | echo "${ECHO_T}$ac_file" >&6
1839  
1840   # Check the compiler produces executables we can run.  If not, either
1841   # the compiler is broken, or we cross compile.
1842 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1843 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1842 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1843 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1844   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1845   # If not cross compiling, check that we can run a simple program.
1846   if test "$cross_compiling" != yes; then
# Line 2188 | Line 1855 | if test "$cross_compiling" != yes; then
1855      if test "$cross_compiling" = maybe; then
1856          cross_compiling=yes
1857      else
1858 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1858 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1859   If you meant to cross compile, use \`--host'.
1860   See \`config.log' for more details." >&5
1861 < echo "$as_me: error: cannot run C compiled programs.
1861 > echo "$as_me: error: cannot run C++ compiled programs.
1862   If you meant to cross compile, use \`--host'.
1863   See \`config.log' for more details." >&2;}
1864     { (exit 1); exit 1; }; }
# Line 2296 | Line 1963 | ac_objext=$OBJEXT
1963   echo "${ECHO_T}$ac_cv_objext" >&6
1964   OBJEXT=$ac_cv_objext
1965   ac_objext=$OBJEXT
1966 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1967 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1968 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1969 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1970 + else
1971 +  cat >conftest.$ac_ext <<_ACEOF
1972 + /* confdefs.h.  */
1973 + _ACEOF
1974 + cat confdefs.h >>conftest.$ac_ext
1975 + cat >>conftest.$ac_ext <<_ACEOF
1976 + /* end confdefs.h.  */
1977 +
1978 + int
1979 + main ()
1980 + {
1981 + #ifndef __GNUC__
1982 +       choke me
1983 + #endif
1984 +
1985 +  ;
1986 +  return 0;
1987 + }
1988 + _ACEOF
1989 + rm -f conftest.$ac_objext
1990 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1991 +  (eval $ac_compile) 2>conftest.er1
1992 +  ac_status=$?
1993 +  grep -v '^ *+' conftest.er1 >conftest.err
1994 +  rm -f conftest.er1
1995 +  cat conftest.err >&5
1996 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1997 +  (exit $ac_status); } &&
1998 +         { ac_try='test -z "$ac_cxx_werror_flag"
1999 +                         || test ! -s conftest.err'
2000 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2001 +  (eval $ac_try) 2>&5
2002 +  ac_status=$?
2003 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2004 +  (exit $ac_status); }; } &&
2005 +         { ac_try='test -s conftest.$ac_objext'
2006 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2007 +  (eval $ac_try) 2>&5
2008 +  ac_status=$?
2009 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2010 +  (exit $ac_status); }; }; then
2011 +  ac_compiler_gnu=yes
2012 + else
2013 +  echo "$as_me: failed program was:" >&5
2014 + sed 's/^/| /' conftest.$ac_ext >&5
2015 +
2016 + ac_compiler_gnu=no
2017 + fi
2018 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2019 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2020 +
2021 + fi
2022 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2023 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2024 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2025 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2026 + ac_save_CXXFLAGS=$CXXFLAGS
2027 + CXXFLAGS="-g"
2028 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2029 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2030 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2031 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2032 + else
2033 +  cat >conftest.$ac_ext <<_ACEOF
2034 + /* confdefs.h.  */
2035 + _ACEOF
2036 + cat confdefs.h >>conftest.$ac_ext
2037 + cat >>conftest.$ac_ext <<_ACEOF
2038 + /* end confdefs.h.  */
2039 +
2040 + int
2041 + main ()
2042 + {
2043 +
2044 +  ;
2045 +  return 0;
2046 + }
2047 + _ACEOF
2048 + rm -f conftest.$ac_objext
2049 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2050 +  (eval $ac_compile) 2>conftest.er1
2051 +  ac_status=$?
2052 +  grep -v '^ *+' conftest.er1 >conftest.err
2053 +  rm -f conftest.er1
2054 +  cat conftest.err >&5
2055 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2056 +  (exit $ac_status); } &&
2057 +         { ac_try='test -z "$ac_cxx_werror_flag"
2058 +                         || test ! -s conftest.err'
2059 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2060 +  (eval $ac_try) 2>&5
2061 +  ac_status=$?
2062 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2063 +  (exit $ac_status); }; } &&
2064 +         { ac_try='test -s conftest.$ac_objext'
2065 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2066 +  (eval $ac_try) 2>&5
2067 +  ac_status=$?
2068 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2069 +  (exit $ac_status); }; }; then
2070 +  ac_cv_prog_cxx_g=yes
2071 + else
2072 +  echo "$as_me: failed program was:" >&5
2073 + sed 's/^/| /' conftest.$ac_ext >&5
2074 +
2075 + ac_cv_prog_cxx_g=no
2076 + fi
2077 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2078 + fi
2079 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2080 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2081 + if test "$ac_test_CXXFLAGS" = set; then
2082 +  CXXFLAGS=$ac_save_CXXFLAGS
2083 + elif test $ac_cv_prog_cxx_g = yes; then
2084 +  if test "$GXX" = yes; then
2085 +    CXXFLAGS="-g -O2"
2086 +  else
2087 +    CXXFLAGS="-g"
2088 +  fi
2089 + else
2090 +  if test "$GXX" = yes; then
2091 +    CXXFLAGS="-O2"
2092 +  else
2093 +    CXXFLAGS=
2094 +  fi
2095 + fi
2096 + for ac_declaration in \
2097 +   '' \
2098 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2099 +   'extern "C" void std::exit (int); using std::exit;' \
2100 +   'extern "C" void exit (int) throw ();' \
2101 +   'extern "C" void exit (int);' \
2102 +   'void exit (int);'
2103 + do
2104 +  cat >conftest.$ac_ext <<_ACEOF
2105 + /* confdefs.h.  */
2106 + _ACEOF
2107 + cat confdefs.h >>conftest.$ac_ext
2108 + cat >>conftest.$ac_ext <<_ACEOF
2109 + /* end confdefs.h.  */
2110 + $ac_declaration
2111 + #include <stdlib.h>
2112 + int
2113 + main ()
2114 + {
2115 + exit (42);
2116 +  ;
2117 +  return 0;
2118 + }
2119 + _ACEOF
2120 + rm -f conftest.$ac_objext
2121 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2122 +  (eval $ac_compile) 2>conftest.er1
2123 +  ac_status=$?
2124 +  grep -v '^ *+' conftest.er1 >conftest.err
2125 +  rm -f conftest.er1
2126 +  cat conftest.err >&5
2127 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2128 +  (exit $ac_status); } &&
2129 +         { ac_try='test -z "$ac_cxx_werror_flag"
2130 +                         || test ! -s conftest.err'
2131 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2132 +  (eval $ac_try) 2>&5
2133 +  ac_status=$?
2134 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2135 +  (exit $ac_status); }; } &&
2136 +         { ac_try='test -s conftest.$ac_objext'
2137 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2138 +  (eval $ac_try) 2>&5
2139 +  ac_status=$?
2140 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2141 +  (exit $ac_status); }; }; then
2142 +  :
2143 + else
2144 +  echo "$as_me: failed program was:" >&5
2145 + sed 's/^/| /' conftest.$ac_ext >&5
2146 +
2147 + continue
2148 + fi
2149 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2150 +  cat >conftest.$ac_ext <<_ACEOF
2151 + /* confdefs.h.  */
2152 + _ACEOF
2153 + cat confdefs.h >>conftest.$ac_ext
2154 + cat >>conftest.$ac_ext <<_ACEOF
2155 + /* end confdefs.h.  */
2156 + $ac_declaration
2157 + int
2158 + main ()
2159 + {
2160 + exit (42);
2161 +  ;
2162 +  return 0;
2163 + }
2164 + _ACEOF
2165 + rm -f conftest.$ac_objext
2166 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2167 +  (eval $ac_compile) 2>conftest.er1
2168 +  ac_status=$?
2169 +  grep -v '^ *+' conftest.er1 >conftest.err
2170 +  rm -f conftest.er1
2171 +  cat conftest.err >&5
2172 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2173 +  (exit $ac_status); } &&
2174 +         { ac_try='test -z "$ac_cxx_werror_flag"
2175 +                         || test ! -s conftest.err'
2176 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2177 +  (eval $ac_try) 2>&5
2178 +  ac_status=$?
2179 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2180 +  (exit $ac_status); }; } &&
2181 +         { ac_try='test -s conftest.$ac_objext'
2182 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2183 +  (eval $ac_try) 2>&5
2184 +  ac_status=$?
2185 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2186 +  (exit $ac_status); }; }; then
2187 +  break
2188 + else
2189 +  echo "$as_me: failed program was:" >&5
2190 + sed 's/^/| /' conftest.$ac_ext >&5
2191 +
2192 + fi
2193 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2194 + done
2195 + rm -f conftest*
2196 + if test -n "$ac_declaration"; then
2197 +  echo '#ifdef __cplusplus' >>confdefs.h
2198 +  echo $ac_declaration      >>confdefs.h
2199 +  echo '#endif'             >>confdefs.h
2200 + fi
2201 +
2202 + ac_ext=c
2203 + ac_cpp='$CPP $CPPFLAGS'
2204 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2205 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2206 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2207 +
2208 + ac_ext=c
2209 + ac_cpp='$CPP $CPPFLAGS'
2210 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2211 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2212 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2213 + if test -n "$ac_tool_prefix"; then
2214 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2215 +  do
2216 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2217 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2218 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2219 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2220 + if test "${ac_cv_prog_CC+set}" = set; then
2221 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2222 + else
2223 +  if test -n "$CC"; then
2224 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2225 + else
2226 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2227 + for as_dir in $PATH
2228 + do
2229 +  IFS=$as_save_IFS
2230 +  test -z "$as_dir" && as_dir=.
2231 +  for ac_exec_ext in '' $ac_executable_extensions; do
2232 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2233 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2234 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2235 +    break 2
2236 +  fi
2237 + done
2238 + done
2239 +
2240 + fi
2241 + fi
2242 + CC=$ac_cv_prog_CC
2243 + if test -n "$CC"; then
2244 +  echo "$as_me:$LINENO: result: $CC" >&5
2245 + echo "${ECHO_T}$CC" >&6
2246 + else
2247 +  echo "$as_me:$LINENO: result: no" >&5
2248 + echo "${ECHO_T}no" >&6
2249 + fi
2250 +
2251 +    test -n "$CC" && break
2252 +  done
2253 + fi
2254 + if test -z "$CC"; then
2255 +  ac_ct_CC=$CC
2256 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2257 + do
2258 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2259 + set dummy $ac_prog; ac_word=$2
2260 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2261 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2262 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2263 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2264 + else
2265 +  if test -n "$ac_ct_CC"; then
2266 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2267 + else
2268 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2269 + for as_dir in $PATH
2270 + do
2271 +  IFS=$as_save_IFS
2272 +  test -z "$as_dir" && as_dir=.
2273 +  for ac_exec_ext in '' $ac_executable_extensions; do
2274 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2275 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2276 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2277 +    break 2
2278 +  fi
2279 + done
2280 + done
2281 +
2282 + fi
2283 + fi
2284 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2285 + if test -n "$ac_ct_CC"; then
2286 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2287 + echo "${ECHO_T}$ac_ct_CC" >&6
2288 + else
2289 +  echo "$as_me:$LINENO: result: no" >&5
2290 + echo "${ECHO_T}no" >&6
2291 + fi
2292 +
2293 +  test -n "$ac_ct_CC" && break
2294 + done
2295 +
2296 +  CC=$ac_ct_CC
2297 + fi
2298 +
2299 +
2300 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2301 + See \`config.log' for more details." >&5
2302 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2303 + See \`config.log' for more details." >&2;}
2304 +   { (exit 1); exit 1; }; }
2305 +
2306 + # Provide some information about the compiler.
2307 + echo "$as_me:$LINENO:" \
2308 +     "checking for C compiler version" >&5
2309 + ac_compiler=`set X $ac_compile; echo $2`
2310 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2311 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2312 +  ac_status=$?
2313 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2314 +  (exit $ac_status); }
2315 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2316 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2317 +  ac_status=$?
2318 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2319 +  (exit $ac_status); }
2320 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2321 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2322 +  ac_status=$?
2323 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2324 +  (exit $ac_status); }
2325 +
2326   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2327   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2328   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2690 | Line 2717 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2717   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2718   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2719  
2720 <
2721 < ac_ext=cc
2722 < ac_cpp='$CXXCPP $CPPFLAGS'
2723 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2697 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2698 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2720 > ac_ext=${FC_SRCEXT-f}
2721 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2722 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2723 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2724   if test -n "$ac_tool_prefix"; then
2725 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2725 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2726    do
2727      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2728   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2729   echo "$as_me:$LINENO: checking for $ac_word" >&5
2730   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2731 < if test "${ac_cv_prog_CXX+set}" = set; then
2731 > if test "${ac_cv_prog_FC+set}" = set; then
2732    echo $ECHO_N "(cached) $ECHO_C" >&6
2733   else
2734 <  if test -n "$CXX"; then
2735 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2734 >  if test -n "$FC"; then
2735 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2736   else
2737   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2738   for as_dir in $PATH
# Line 2716 | Line 2741 | do
2741    test -z "$as_dir" && as_dir=.
2742    for ac_exec_ext in '' $ac_executable_extensions; do
2743    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2744 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2744 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2745      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2746      break 2
2747    fi
# Line 2725 | Line 2750 | fi
2750  
2751   fi
2752   fi
2753 < CXX=$ac_cv_prog_CXX
2754 < if test -n "$CXX"; then
2755 <  echo "$as_me:$LINENO: result: $CXX" >&5
2756 < echo "${ECHO_T}$CXX" >&6
2753 > FC=$ac_cv_prog_FC
2754 > if test -n "$FC"; then
2755 >  echo "$as_me:$LINENO: result: $FC" >&5
2756 > echo "${ECHO_T}$FC" >&6
2757   else
2758    echo "$as_me:$LINENO: result: no" >&5
2759   echo "${ECHO_T}no" >&6
2760   fi
2761  
2762 <    test -n "$CXX" && break
2762 >    test -n "$FC" && break
2763    done
2764   fi
2765 < if test -z "$CXX"; then
2766 <  ac_ct_CXX=$CXX
2767 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2765 > if test -z "$FC"; then
2766 >  ac_ct_FC=$FC
2767 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2768   do
2769    # Extract the first word of "$ac_prog", so it can be a program name with args.
2770   set dummy $ac_prog; ac_word=$2
2771   echo "$as_me:$LINENO: checking for $ac_word" >&5
2772   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2773 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2773 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2774    echo $ECHO_N "(cached) $ECHO_C" >&6
2775   else
2776 <  if test -n "$ac_ct_CXX"; then
2777 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2776 >  if test -n "$ac_ct_FC"; then
2777 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2778   else
2779   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2780   for as_dir in $PATH
# Line 2758 | Line 2783 | do
2783    test -z "$as_dir" && as_dir=.
2784    for ac_exec_ext in '' $ac_executable_extensions; do
2785    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2786 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2786 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2787      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2788      break 2
2789    fi
# Line 2767 | Line 2792 | fi
2792  
2793   fi
2794   fi
2795 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2796 < if test -n "$ac_ct_CXX"; then
2797 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2798 < echo "${ECHO_T}$ac_ct_CXX" >&6
2795 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2796 > if test -n "$ac_ct_FC"; then
2797 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2798 > echo "${ECHO_T}$ac_ct_FC" >&6
2799   else
2800    echo "$as_me:$LINENO: result: no" >&5
2801   echo "${ECHO_T}no" >&6
2802   fi
2803  
2804 <  test -n "$ac_ct_CXX" && break
2804 >  test -n "$ac_ct_FC" && break
2805   done
2781 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2806  
2807 <  CXX=$ac_ct_CXX
2807 >  FC=$ac_ct_FC
2808   fi
2809  
2810  
2811   # Provide some information about the compiler.
2812 < echo "$as_me:$LINENO:" \
2813 <     "checking for C++ compiler version" >&5
2812 > echo "$as_me:2812:" \
2813 >     "checking for Fortran compiler version" >&5
2814   ac_compiler=`set X $ac_compile; echo $2`
2815   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2816    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2803 | Line 2827 | ac_compiler=`set X $ac_compile; echo $2`
2827    ac_status=$?
2828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2829    (exit $ac_status); }
2830 + rm -f a.out
2831  
2832 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2833 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2834 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2832 > # If we don't use `.F' as extension, the preprocessor is not run on the
2833 > # input file.  (Note that this only needs to work for GNU compilers.)
2834 > ac_save_ext=$ac_ext
2835 > ac_ext=F
2836 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2837 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2838 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2839    echo $ECHO_N "(cached) $ECHO_C" >&6
2840   else
2841    cat >conftest.$ac_ext <<_ACEOF
2842 < /* confdefs.h.  */
2814 < _ACEOF
2815 < cat confdefs.h >>conftest.$ac_ext
2816 < cat >>conftest.$ac_ext <<_ACEOF
2817 < /* end confdefs.h.  */
2818 <
2819 < int
2820 < main ()
2821 < {
2842 >      program main
2843   #ifndef __GNUC__
2844         choke me
2845   #endif
2846  
2847 <  ;
2827 <  return 0;
2828 < }
2847 >      end
2848   _ACEOF
2849   rm -f conftest.$ac_objext
2850   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2836 | Line 2855 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2855    cat conftest.err >&5
2856    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2857    (exit $ac_status); } &&
2858 <         { ac_try='test -z "$ac_cxx_werror_flag"
2858 >         { ac_try='test -z "$ac_fc_werror_flag"
2859                           || test ! -s conftest.err'
2860    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2861    (eval $ac_try) 2>&5
# Line 2857 | Line 2876 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2876   ac_compiler_gnu=no
2877   fi
2878   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2879 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2879 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2880  
2881   fi
2882 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2883 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2884 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2885 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2886 < ac_save_CXXFLAGS=$CXXFLAGS
2887 < CXXFLAGS="-g"
2888 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2889 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2890 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2882 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2883 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2884 > ac_ext=$ac_save_ext
2885 > ac_test_FFLAGS=${FCFLAGS+set}
2886 > ac_save_FFLAGS=$FCFLAGS
2887 > FCFLAGS=
2888 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2889 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2890 > if test "${ac_cv_prog_fc_g+set}" = set; then
2891    echo $ECHO_N "(cached) $ECHO_C" >&6
2892   else
2893 <  cat >conftest.$ac_ext <<_ACEOF
2894 < /* confdefs.h.  */
2895 < _ACEOF
2877 < cat confdefs.h >>conftest.$ac_ext
2878 < cat >>conftest.$ac_ext <<_ACEOF
2879 < /* end confdefs.h.  */
2893 >  FCFLAGS=-g
2894 > cat >conftest.$ac_ext <<_ACEOF
2895 >      program main
2896  
2897 < int
2882 < main ()
2883 < {
2884 <
2885 <  ;
2886 <  return 0;
2887 < }
2897 >      end
2898   _ACEOF
2899   rm -f conftest.$ac_objext
2900   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2895 | Line 2905 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2905    cat conftest.err >&5
2906    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2907    (exit $ac_status); } &&
2908 <         { ac_try='test -z "$ac_cxx_werror_flag"
2908 >         { ac_try='test -z "$ac_fc_werror_flag"
2909                           || test ! -s conftest.err'
2910    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2911    (eval $ac_try) 2>&5
# Line 2908 | Line 2918 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2918    ac_status=$?
2919    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920    (exit $ac_status); }; }; then
2921 <  ac_cv_prog_cxx_g=yes
2921 >  ac_cv_prog_fc_g=yes
2922   else
2923    echo "$as_me: failed program was:" >&5
2924   sed 's/^/| /' conftest.$ac_ext >&5
2925  
2926 < ac_cv_prog_cxx_g=no
2926 > ac_cv_prog_fc_g=no
2927   fi
2928   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2929 +
2930   fi
2931 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2932 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2933 < if test "$ac_test_CXXFLAGS" = set; then
2934 <  CXXFLAGS=$ac_save_CXXFLAGS
2935 < elif test $ac_cv_prog_cxx_g = yes; then
2936 <  if test "$GXX" = yes; then
2937 <    CXXFLAGS="-g -O2"
2931 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2932 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2933 > if test "$ac_test_FFLAGS" = set; then
2934 >  FCFLAGS=$ac_save_FFLAGS
2935 > elif test $ac_cv_prog_fc_g = yes; then
2936 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2937 >    FCFLAGS="-g -O2"
2938    else
2939 <    CXXFLAGS="-g"
2939 >    FCFLAGS="-g"
2940    fi
2941   else
2942 <  if test "$GXX" = yes; then
2943 <    CXXFLAGS="-O2"
2942 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2943 >    FCFLAGS="-O2"
2944    else
2945 <    CXXFLAGS=
2945 >    FCFLAGS=
2946    fi
2947   fi
2948 < for ac_declaration in \
2949 <   '' \
2950 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2951 <   'extern "C" void std::exit (int); using std::exit;' \
2952 <   'extern "C" void exit (int) throw ();' \
2953 <   'extern "C" void exit (int);' \
2954 <   'void exit (int);'
2948 >
2949 > ac_ext=c
2950 > ac_cpp='$CPP $CPPFLAGS'
2951 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2952 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2953 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2954 >
2955 > ac_ext=c
2956 > ac_cpp='$CPP $CPPFLAGS'
2957 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2958 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2959 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2960 > echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2961 > echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2962 > # On Suns, sometimes $CPP names a directory.
2963 > if test -n "$CPP" && test -d "$CPP"; then
2964 >  CPP=
2965 > fi
2966 > if test -z "$CPP"; then
2967 >  if test "${ac_cv_prog_CPP+set}" = set; then
2968 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2969 > else
2970 >      # Double quotes because CPP needs to be expanded
2971 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2972 >    do
2973 >      ac_preproc_ok=false
2974 > for ac_c_preproc_warn_flag in '' yes
2975   do
2976 +  # Use a header file that comes with gcc, so configuring glibc
2977 +  # with a fresh cross-compiler works.
2978 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2979 +  # <limits.h> exists even on freestanding compilers.
2980 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2981 +  # not just through cpp. "Syntax error" is here to catch this case.
2982    cat >conftest.$ac_ext <<_ACEOF
2983   /* confdefs.h.  */
2984   _ACEOF
2985   cat confdefs.h >>conftest.$ac_ext
2986   cat >>conftest.$ac_ext <<_ACEOF
2987   /* end confdefs.h.  */
2988 < $ac_declaration
2989 < #include <stdlib.h>
2990 < int
2991 < main ()
2992 < {
2993 < exit (42);
2957 <  ;
2958 <  return 0;
2959 < }
2988 > #ifdef __STDC__
2989 > # include <limits.h>
2990 > #else
2991 > # include <assert.h>
2992 > #endif
2993 >                     Syntax error
2994   _ACEOF
2995 < rm -f conftest.$ac_objext
2996 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2963 <  (eval $ac_compile) 2>conftest.er1
2995 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2996 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2997    ac_status=$?
2998    grep -v '^ *+' conftest.er1 >conftest.err
2999    rm -f conftest.er1
3000    cat conftest.err >&5
3001    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3002 <  (exit $ac_status); } &&
3003 <         { ac_try='test -z "$ac_cxx_werror_flag"
3004 <                         || test ! -s conftest.err'
3005 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3006 <  (eval $ac_try) 2>&5
3007 <  ac_status=$?
3008 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3009 <  (exit $ac_status); }; } &&
3010 <         { ac_try='test -s conftest.$ac_objext'
3011 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3012 <  (eval $ac_try) 2>&5
2980 <  ac_status=$?
2981 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2982 <  (exit $ac_status); }; }; then
3002 >  (exit $ac_status); } >/dev/null; then
3003 >  if test -s conftest.err; then
3004 >    ac_cpp_err=$ac_c_preproc_warn_flag
3005 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3006 >  else
3007 >    ac_cpp_err=
3008 >  fi
3009 > else
3010 >  ac_cpp_err=yes
3011 > fi
3012 > if test -z "$ac_cpp_err"; then
3013    :
3014   else
3015    echo "$as_me: failed program was:" >&5
3016   sed 's/^/| /' conftest.$ac_ext >&5
3017  
3018 +  # Broken: fails on valid input.
3019   continue
3020   fi
3021 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3021 > rm -f conftest.err conftest.$ac_ext
3022 >
3023 >  # OK, works on sane cases.  Now check whether non-existent headers
3024 >  # can be detected and how.
3025    cat >conftest.$ac_ext <<_ACEOF
3026   /* confdefs.h.  */
3027   _ACEOF
3028   cat confdefs.h >>conftest.$ac_ext
3029   cat >>conftest.$ac_ext <<_ACEOF
3030   /* end confdefs.h.  */
3031 < $ac_declaration
2998 < int
2999 < main ()
3000 < {
3001 < exit (42);
3002 <  ;
3003 <  return 0;
3004 < }
3031 > #include <ac_nonexistent.h>
3032   _ACEOF
3033 < rm -f conftest.$ac_objext
3034 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3008 <  (eval $ac_compile) 2>conftest.er1
3033 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3034 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3035    ac_status=$?
3036    grep -v '^ *+' conftest.er1 >conftest.err
3037    rm -f conftest.er1
3038    cat conftest.err >&5
3039    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3040 <  (exit $ac_status); } &&
3041 <         { ac_try='test -z "$ac_cxx_werror_flag"
3042 <                         || test ! -s conftest.err'
3043 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3044 <  (eval $ac_try) 2>&5
3040 >  (exit $ac_status); } >/dev/null; then
3041 >  if test -s conftest.err; then
3042 >    ac_cpp_err=$ac_c_preproc_warn_flag
3043 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3044 >  else
3045 >    ac_cpp_err=
3046 >  fi
3047 > else
3048 >  ac_cpp_err=yes
3049 > fi
3050 > if test -z "$ac_cpp_err"; then
3051 >  # Broken: success on invalid input.
3052 > continue
3053 > else
3054 >  echo "$as_me: failed program was:" >&5
3055 > sed 's/^/| /' conftest.$ac_ext >&5
3056 >
3057 >  # Passes both tests.
3058 > ac_preproc_ok=:
3059 > break
3060 > fi
3061 > rm -f conftest.err conftest.$ac_ext
3062 >
3063 > done
3064 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3065 > rm -f conftest.err conftest.$ac_ext
3066 > if $ac_preproc_ok; then
3067 >  break
3068 > fi
3069 >
3070 >    done
3071 >    ac_cv_prog_CPP=$CPP
3072 >
3073 > fi
3074 >  CPP=$ac_cv_prog_CPP
3075 > else
3076 >  ac_cv_prog_CPP=$CPP
3077 > fi
3078 > echo "$as_me:$LINENO: result: $CPP" >&5
3079 > echo "${ECHO_T}$CPP" >&6
3080 > ac_preproc_ok=false
3081 > for ac_c_preproc_warn_flag in '' yes
3082 > do
3083 >  # Use a header file that comes with gcc, so configuring glibc
3084 >  # with a fresh cross-compiler works.
3085 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3086 >  # <limits.h> exists even on freestanding compilers.
3087 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3088 >  # not just through cpp. "Syntax error" is here to catch this case.
3089 >  cat >conftest.$ac_ext <<_ACEOF
3090 > /* confdefs.h.  */
3091 > _ACEOF
3092 > cat confdefs.h >>conftest.$ac_ext
3093 > cat >>conftest.$ac_ext <<_ACEOF
3094 > /* end confdefs.h.  */
3095 > #ifdef __STDC__
3096 > # include <limits.h>
3097 > #else
3098 > # include <assert.h>
3099 > #endif
3100 >                     Syntax error
3101 > _ACEOF
3102 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3103 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3104    ac_status=$?
3105 +  grep -v '^ *+' conftest.er1 >conftest.err
3106 +  rm -f conftest.er1
3107 +  cat conftest.err >&5
3108    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3109 <  (exit $ac_status); }; } &&
3110 <         { ac_try='test -s conftest.$ac_objext'
3111 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3112 <  (eval $ac_try) 2>&5
3109 >  (exit $ac_status); } >/dev/null; then
3110 >  if test -s conftest.err; then
3111 >    ac_cpp_err=$ac_c_preproc_warn_flag
3112 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3113 >  else
3114 >    ac_cpp_err=
3115 >  fi
3116 > else
3117 >  ac_cpp_err=yes
3118 > fi
3119 > if test -z "$ac_cpp_err"; then
3120 >  :
3121 > else
3122 >  echo "$as_me: failed program was:" >&5
3123 > sed 's/^/| /' conftest.$ac_ext >&5
3124 >
3125 >  # Broken: fails on valid input.
3126 > continue
3127 > fi
3128 > rm -f conftest.err conftest.$ac_ext
3129 >
3130 >  # OK, works on sane cases.  Now check whether non-existent headers
3131 >  # can be detected and how.
3132 >  cat >conftest.$ac_ext <<_ACEOF
3133 > /* confdefs.h.  */
3134 > _ACEOF
3135 > cat confdefs.h >>conftest.$ac_ext
3136 > cat >>conftest.$ac_ext <<_ACEOF
3137 > /* end confdefs.h.  */
3138 > #include <ac_nonexistent.h>
3139 > _ACEOF
3140 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3141 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3142    ac_status=$?
3143 +  grep -v '^ *+' conftest.er1 >conftest.err
3144 +  rm -f conftest.er1
3145 +  cat conftest.err >&5
3146    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3147 <  (exit $ac_status); }; }; then
3148 <  break
3147 >  (exit $ac_status); } >/dev/null; then
3148 >  if test -s conftest.err; then
3149 >    ac_cpp_err=$ac_c_preproc_warn_flag
3150 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3151 >  else
3152 >    ac_cpp_err=
3153 >  fi
3154   else
3155 +  ac_cpp_err=yes
3156 + fi
3157 + if test -z "$ac_cpp_err"; then
3158 +  # Broken: success on invalid input.
3159 + continue
3160 + else
3161    echo "$as_me: failed program was:" >&5
3162   sed 's/^/| /' conftest.$ac_ext >&5
3163  
3164 +  # Passes both tests.
3165 + ac_preproc_ok=:
3166 + break
3167   fi
3168 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3168 > rm -f conftest.err conftest.$ac_ext
3169 >
3170   done
3171 < rm -f conftest*
3172 < if test -n "$ac_declaration"; then
3173 <  echo '#ifdef __cplusplus' >>confdefs.h
3174 <  echo $ac_declaration      >>confdefs.h
3175 <  echo '#endif'             >>confdefs.h
3171 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3172 > rm -f conftest.err conftest.$ac_ext
3173 > if $ac_preproc_ok; then
3174 >  :
3175 > else
3176 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3177 > See \`config.log' for more details." >&5
3178 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3179 > See \`config.log' for more details." >&2;}
3180 >   { (exit 1); exit 1; }; }
3181   fi
3182  
3183   ac_ext=c
# Line 3046 | Line 3186 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3186   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3187   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3188  
3189 + echo "$as_me:$LINENO: checking for egrep" >&5
3190 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3191 + if test "${ac_cv_prog_egrep+set}" = set; then
3192 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3193 + else
3194 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3195 +    then ac_cv_prog_egrep='grep -E'
3196 +    else ac_cv_prog_egrep='egrep'
3197 +    fi
3198 + fi
3199 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3200 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3201 + EGREP=$ac_cv_prog_egrep
3202  
3203 < OOPSE_TEMPLATE_FLAGS=""
3204 < if test $ac_cv_cxx_compiler_gnu = no; then
3205 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3206 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3207 <  echo 'void f(){}' > conftest.cc
3208 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3056 <    echo "$as_me:$LINENO: result: yes" >&5
3203 >
3204 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3205 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3206 > LN_S=$as_ln_s
3207 > if test "$LN_S" = "ln -s"; then
3208 >  echo "$as_me:$LINENO: result: yes" >&5
3209   echo "${ECHO_T}yes" >&6
3210 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3211 <  else
3212 <    echo "$as_me:$LINENO: result: no" >&5
3210 > else
3211 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3212 > echo "${ECHO_T}no, using $LN_S" >&6
3213 > fi
3214 >
3215 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3216 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3217 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3218 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3219 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3220 > else
3221 >  cat >conftest.make <<\_ACEOF
3222 > all:
3223 >        @echo 'ac_maketemp="$(MAKE)"'
3224 > _ACEOF
3225 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3226 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3227 > if test -n "$ac_maketemp"; then
3228 >  eval ac_cv_prog_make_${ac_make}_set=yes
3229 > else
3230 >  eval ac_cv_prog_make_${ac_make}_set=no
3231 > fi
3232 > rm -f conftest.make
3233 > fi
3234 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3235 >  echo "$as_me:$LINENO: result: yes" >&5
3236 > echo "${ECHO_T}yes" >&6
3237 >  SET_MAKE=
3238 > else
3239 >  echo "$as_me:$LINENO: result: no" >&5
3240   echo "${ECHO_T}no" >&6
3241 +  SET_MAKE="MAKE=${MAKE-make}"
3242 + fi
3243 +
3244 + if test -n "$ac_tool_prefix"; then
3245 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3246 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3247 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3248 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3249 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3250 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3251 + else
3252 +  if test -n "$RANLIB"; then
3253 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3254 + else
3255 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3256 + for as_dir in $PATH
3257 + do
3258 +  IFS=$as_save_IFS
3259 +  test -z "$as_dir" && as_dir=.
3260 +  for ac_exec_ext in '' $ac_executable_extensions; do
3261 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3262 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3263 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3264 +    break 2
3265    fi
3266 <  rm -f conftest*
3267 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3268 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3269 <  echo 'void f(){}' > conftest.cc
3270 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3271 <    echo "$as_me:$LINENO: result: yes" >&5
3272 < echo "${ECHO_T}yes" >&6
3273 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3274 <  else
3275 <    echo "$as_me:$LINENO: result: no" >&5
3266 > done
3267 > done
3268 >
3269 > fi
3270 > fi
3271 > RANLIB=$ac_cv_prog_RANLIB
3272 > if test -n "$RANLIB"; then
3273 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3274 > echo "${ECHO_T}$RANLIB" >&6
3275 > else
3276 >  echo "$as_me:$LINENO: result: no" >&5
3277   echo "${ECHO_T}no" >&6
3278 + fi
3279 +
3280 + fi
3281 + if test -z "$ac_cv_prog_RANLIB"; then
3282 +  ac_ct_RANLIB=$RANLIB
3283 +  # Extract the first word of "ranlib", so it can be a program name with args.
3284 + set dummy ranlib; ac_word=$2
3285 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3286 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3287 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3288 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3289 + else
3290 +  if test -n "$ac_ct_RANLIB"; then
3291 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3292 + else
3293 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3294 + for as_dir in $PATH
3295 + do
3296 +  IFS=$as_save_IFS
3297 +  test -z "$as_dir" && as_dir=.
3298 +  for ac_exec_ext in '' $ac_executable_extensions; do
3299 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3300 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3301 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3302 +    break 2
3303    fi
3304 <  rm -f conftest*
3305 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3306 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3307 <  echo 'void f(){}' > conftest.cc
3308 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3309 <    echo "$as_me:$LINENO: result: yes" >&5
3310 < echo "${ECHO_T}yes" >&6
3311 <    OOPSE_TEMPLATE_FLAGS="-pto"
3312 <  else
3313 <    echo "$as_me:$LINENO: result: no" >&5
3304 > done
3305 > done
3306 >
3307 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3308 > fi
3309 > fi
3310 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3311 > if test -n "$ac_ct_RANLIB"; then
3312 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3313 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3314 > else
3315 >  echo "$as_me:$LINENO: result: no" >&5
3316   echo "${ECHO_T}no" >&6
3317 + fi
3318 +
3319 +  RANLIB=$ac_ct_RANLIB
3320 + else
3321 +  RANLIB="$ac_cv_prog_RANLIB"
3322 + fi
3323 +
3324 +
3325 +   # Extract the first word of "perl", so it can be a program name with args.
3326 + set dummy perl; ac_word=$2
3327 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3328 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3329 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3330 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3331 + else
3332 +  case $PERLINTERP in
3333 +  [\\/]* | ?:[\\/]*)
3334 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3335 +  ;;
3336 +  *)
3337 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3338 + for as_dir in $PATH
3339 + do
3340 +  IFS=$as_save_IFS
3341 +  test -z "$as_dir" && as_dir=.
3342 +  for ac_exec_ext in '' $ac_executable_extensions; do
3343 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3344 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3345 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3346 +    break 2
3347    fi
3348 <  rm -f conftest*
3349 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3089 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3090 <  echo 'void f(){}' > conftest.cc
3091 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3092 <    echo "$as_me:$LINENO: result: yes" >&5
3093 < echo "${ECHO_T}yes" >&6
3348 > done
3349 > done
3350  
3351 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3352 +  ;;
3353 + esac
3354 + fi
3355 + PERLINTERP=$ac_cv_path_PERLINTERP
3356  
3357 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3358 <  else
3359 <    echo "$as_me:$LINENO: result: no" >&5
3357 > if test -n "$PERLINTERP"; then
3358 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3359 > echo "${ECHO_T}$PERLINTERP" >&6
3360 > else
3361 >  echo "$as_me:$LINENO: result: no" >&5
3362   echo "${ECHO_T}no" >&6
3363 + fi
3364 +
3365 +   ac_cv_path_perlinterp="$PERLINTERP"
3366 +   _sHpB='#!'
3367 +
3368 +
3369 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3370 + if test "${with_perl_shebang+set}" = set; then
3371 +  withval="$with_perl_shebang"
3372 +  opt_perl_shebang="$withval"
3373 + else
3374 +                opt_perl_shebang="not_set"
3375 + fi;
3376 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3377 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3378 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3379 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3380 + else
3381 +   case "$opt_perl_shebang" in
3382 +                      not_set  ) ax_cv_opt_perl_shebang=''
3383 +                               ;;
3384 +                         *     )
3385 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3386 +                    esac
3387 +
3388 + fi
3389 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3390 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3391 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3392 +     then
3393 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3394 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3395 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3396 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3397 +
3398 + # Automatic detection of sharpbang formula starts here
3399 +     else
3400 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3401 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3402 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3403 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3404 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3405 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3406 + else
3407 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3408 +        if test "x$_somian_kspb_perl" == x
3409 +          then _somian_ksbp_warn_empty='durnit'
3410 +          else
3411 +          case "A$_somian_kspb_perl" in
3412 +                 A#!*perl* )
3413 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3414 +                        ;;
3415 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3416 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3417 +          esac
3418 +        fi
3419 +
3420 + fi
3421 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3422 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3423 + # The above prints Checking ... result message to user.
3424 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3425 +
3426 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3427 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3428 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3429 +    fi
3430 + # Inform user after printing result value
3431 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3432 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3433 + echo "$as_me: Maybe Not good -" >&6;}
3434 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3435 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3436 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3437 + echo "$as_me: OK Good result - " >&6;}
3438 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3439 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3440 +    fi
3441    fi
3442 +
3443 + # Find a good install program.  We prefer a C program (faster),
3444 + # so one script is as good as another.  But avoid the broken or
3445 + # incompatible versions:
3446 + # SysV /etc/install, /usr/sbin/install
3447 + # SunOS /usr/etc/install
3448 + # IRIX /sbin/install
3449 + # AIX /bin/install
3450 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3451 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3452 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3453 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3454 + # OS/2's system install, which has a completely different semantic
3455 + # ./install, which can be erroneously created by make from ./install.sh.
3456 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3457 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3458 + if test -z "$INSTALL"; then
3459 + if test "${ac_cv_path_install+set}" = set; then
3460 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3461 + else
3462 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3463 + for as_dir in $PATH
3464 + do
3465 +  IFS=$as_save_IFS
3466 +  test -z "$as_dir" && as_dir=.
3467 +  # Account for people who put trailing slashes in PATH elements.
3468 + case $as_dir/ in
3469 +  ./ | .// | /cC/* | \
3470 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3471 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3472 +  /usr/ucb/* ) ;;
3473 +  *)
3474 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3475 +    # Don't use installbsd from OSF since it installs stuff as root
3476 +    # by default.
3477 +    for ac_prog in ginstall scoinst install; do
3478 +      for ac_exec_ext in '' $ac_executable_extensions; do
3479 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3480 +          if test $ac_prog = install &&
3481 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3482 +            # AIX install.  It has an incompatible calling convention.
3483 +            :
3484 +          elif test $ac_prog = install &&
3485 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3486 +            # program-specific install script used by HP pwplus--don't use.
3487 +            :
3488 +          else
3489 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3490 +            break 3
3491 +          fi
3492 +        fi
3493 +      done
3494 +    done
3495 +    ;;
3496 + esac
3497 + done
3498 +
3499 +
3500   fi
3501 +  if test "${ac_cv_path_install+set}" = set; then
3502 +    INSTALL=$ac_cv_path_install
3503 +  else
3504 +    # As a last resort, use the slow shell script.  We don't cache a
3505 +    # path for INSTALL within a source directory, because that will
3506 +    # break other packages using the cache if that directory is
3507 +    # removed, or if the path is relative.
3508 +    INSTALL=$ac_install_sh
3509 +  fi
3510 + fi
3511 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3512 + echo "${ECHO_T}$INSTALL" >&6
3513  
3514 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3515 + # It thinks the first close brace ends the variable substitution.
3516 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3517  
3518 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3519  
3520 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3521  
3522 < ac_ext=f90
3523 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3524 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3525 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3526 < if test -n "$ac_tool_prefix"; then
3527 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3528 <  do
3113 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3114 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3522 > case "x$INSTALL" in
3523 >   x/*) ;;
3524 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3525 > esac
3526 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3527 > # Extract the first word of "ar", so it can be a program name with args.
3528 > set dummy ar; ac_word=$2
3529   echo "$as_me:$LINENO: checking for $ac_word" >&5
3530   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3531 < if test "${ac_cv_prog_F90+set}" = set; then
3531 > if test "${ac_cv_prog_AR+set}" = set; then
3532    echo $ECHO_N "(cached) $ECHO_C" >&6
3533   else
3534 <  if test -n "$F90"; then
3535 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3534 >  if test -n "$AR"; then
3535 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3536   else
3537   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3538   for as_dir in $PATH
# Line 3127 | Line 3541 | do
3541    test -z "$as_dir" && as_dir=.
3542    for ac_exec_ext in '' $ac_executable_extensions; do
3543    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3544 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3544 >    ac_cv_prog_AR="ar"
3545      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3546      break 2
3547    fi
3548   done
3549   done
3550  
3551 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3552   fi
3553   fi
3554 < F90=$ac_cv_prog_F90
3555 < if test -n "$F90"; then
3556 <  echo "$as_me:$LINENO: result: $F90" >&5
3557 < echo "${ECHO_T}$F90" >&6
3554 > AR=$ac_cv_prog_AR
3555 > if test -n "$AR"; then
3556 >  echo "$as_me:$LINENO: result: $AR" >&5
3557 > echo "${ECHO_T}$AR" >&6
3558   else
3559    echo "$as_me:$LINENO: result: no" >&5
3560   echo "${ECHO_T}no" >&6
3561   fi
3562  
3563 <    test -n "$F90" && break
3564 <  done
3563 > if test "$AR" = "NONE"; then
3564 >  cat >confcache <<\_ACEOF
3565 > # This file is a shell script that caches the results of configure
3566 > # tests run on this system so they can be shared between configure
3567 > # scripts and configure runs, see configure's option --config-cache.
3568 > # It is not useful on other systems.  If it contains results you don't
3569 > # want to keep, you may remove or edit it.
3570 > #
3571 > # config.status only pays attention to the cache file if you give it
3572 > # the --recheck option to rerun configure.
3573 > #
3574 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3575 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3576 > # following values.
3577 >
3578 > _ACEOF
3579 >
3580 > # The following way of writing the cache mishandles newlines in values,
3581 > # but we know of no workaround that is simple, portable, and efficient.
3582 > # So, don't put newlines in cache variables' values.
3583 > # Ultrix sh set writes to stderr and can't be redirected directly,
3584 > # and sets the high bit in the cache file unless we assign to the vars.
3585 > {
3586 >  (set) 2>&1 |
3587 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3588 >    *ac_space=\ *)
3589 >      # `set' does not quote correctly, so add quotes (double-quote
3590 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3591 >      sed -n \
3592 >        "s/'/'\\\\''/g;
3593 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3594 >      ;;
3595 >    *)
3596 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3597 >      sed -n \
3598 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3599 >      ;;
3600 >    esac;
3601 > } |
3602 >  sed '
3603 >     t clear
3604 >     : clear
3605 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3606 >     t end
3607 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3608 >     : end' >>confcache
3609 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3610 >  if test -w $cache_file; then
3611 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3612 >    cat confcache >$cache_file
3613 >  else
3614 >    echo "not updating unwritable cache $cache_file"
3615 >  fi
3616   fi
3617 < if test -z "$F90"; then
3618 <  ac_ct_F90=$F90
3619 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3620 < do
3621 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3156 < set dummy $ac_prog; ac_word=$2
3617 > rm -f confcache
3618 >  exit 1
3619 > fi
3620 > # Extract the first word of "ps", so it can be a program name with args.
3621 > set dummy ps; ac_word=$2
3622   echo "$as_me:$LINENO: checking for $ac_word" >&5
3623   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3624 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3624 > if test "${ac_cv_path_PS+set}" = set; then
3625    echo $ECHO_N "(cached) $ECHO_C" >&6
3626   else
3627 <  if test -n "$ac_ct_F90"; then
3628 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3629 < else
3630 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3627 >  case $PS in
3628 >  [\\/]* | ?:[\\/]*)
3629 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3630 >  ;;
3631 >  *)
3632 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3633   for as_dir in $PATH
3634   do
3635    IFS=$as_save_IFS
3636    test -z "$as_dir" && as_dir=.
3637    for ac_exec_ext in '' $ac_executable_extensions; do
3638    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3639 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3639 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3640      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3641      break 2
3642    fi
3643   done
3644   done
3645  
3646 +  ;;
3647 + esac
3648   fi
3649 < fi
3650 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3651 < if test -n "$ac_ct_F90"; then
3652 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3653 < echo "${ECHO_T}$ac_ct_F90" >&6
3649 > PS=$ac_cv_path_PS
3650 >
3651 > if test -n "$PS"; then
3652 >  echo "$as_me:$LINENO: result: $PS" >&5
3653 > echo "${ECHO_T}$PS" >&6
3654   else
3655    echo "$as_me:$LINENO: result: no" >&5
3656   echo "${ECHO_T}no" >&6
3657   fi
3658  
3659 <  test -n "$ac_ct_F90" && break
3660 < done
3659 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3660 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3661 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3662 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3663 > else
3664  
3665 <  F90=$ac_ct_F90
3665 >        if $PS ax -o rss > /dev/null 2>&1; then
3666 >                ac_cv_prog_ps_ax=yes
3667 >        else
3668 >                ac_cv_prog_ps_ax=no
3669 >        fi
3670 >        if $PS -ef -o rss > /dev/null 2>&1; then
3671 >                ac_cv_prog_ps_ef=yes
3672 >        else
3673 >                ac_cv_prog_ps_ef=no
3674 >        fi
3675 >        if test "$ac_cv_prog_ps_ax" = yes; then
3676 >                ac_cv_prog_ps_syntax=BSD
3677 >        else
3678 >                if test "$ac_cv_prog_ps_ef" = yes; then
3679 >                        ac_cv_prog_ps_syntax=POSIX
3680 >                else
3681 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3682 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3683 >   { (exit 1); exit 1; }; }
3684 >                fi
3685 >        fi
3686 >
3687   fi
3688 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3689 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3690  
3691 + cat >>confdefs.h <<_ACEOF
3692 + #define PSCOMMAND $PS
3693 + _ACEOF
3694  
3695 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3696 < # input file.
3697 < ac_save_ext=$ac_ext
3698 < ac_ext=F90
3699 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3700 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3203 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3204 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3695 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3696 >
3697 > cat >>confdefs.h <<\_ACEOF
3698 > #define PSTYPE_IS_BSD 1
3699 > _ACEOF
3700 >
3701   else
3702 <  cat >conftest.$ac_ext <<_ACEOF
3702 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3703  
3704 < program main
3704 > cat >>confdefs.h <<\_ACEOF
3705 > #define PSTYPE_IS_POSIX 1
3706 > _ACEOF
3707  
3708 < #ifndef __GNUC__
3709 <       choke me
3710 < #endif
3708 >   else
3709 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3710 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3711 >   { (exit 1); exit 1; }; }
3712 >   fi
3713 > fi
3714  
3715 < end program main
3715 > ac_ext=${FC_SRCEXT-f}
3716 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3717 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3718 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3719  
3720 +
3721 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3722 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3723 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3724 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3725 + else
3726 +  ac_ext=F90
3727 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3728 + FCFLAGS_SRCEXT=""
3729 + ac_cv_fc_srcext_F90=unknown
3730 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3731 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3732 +  cat >conftest.$ac_ext <<_ACEOF
3733 +      program main
3734 +
3735 +      end
3736   _ACEOF
3737   rm -f conftest.$ac_objext
3738   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3223 | Line 3743 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3743    cat conftest.err >&5
3744    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745    (exit $ac_status); } &&
3746 <         { ac_try='test -z "$ac_f90_werror_flag"
3746 >         { ac_try='test -z "$ac_fc_werror_flag"
3747                           || test ! -s conftest.err'
3748    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3749    (eval $ac_try) 2>&5
# Line 3236 | Line 3756 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3756    ac_status=$?
3757    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758    (exit $ac_status); }; }; then
3759 <  ac_compiler_gnu=yes
3759 >  ac_cv_fc_srcext_F90=$ac_flag; break
3760   else
3761    echo "$as_me: failed program was:" >&5
3762   sed 's/^/| /' conftest.$ac_ext >&5
3763  
3244 ac_compiler_gnu=no
3764   fi
3765   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3766 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3766 > done
3767 > rm -f conftest.$ac_objext conftest.F90
3768 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3769  
3770   fi
3771 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3772 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3773 < ac_ext=$ac_save_ext
3774 < G95=`test $ac_compiler_gnu = yes && echo yes`
3775 < ac_ext=c
3776 < ac_cpp='$CPP $CPPFLAGS'
3777 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3778 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3779 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3771 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3772 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3773 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3774 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3775 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3776 >   { (exit 1); exit 1; }; }
3777 > else
3778 >  FC_SRCEXT=F90
3779 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3780 >    FCFLAGS_SRCEXT=""
3781 >    FCFLAGS_F90=""
3782 >  else
3783 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3784 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3785 >  fi
3786  
3787  
3788 + fi
3789  
3790  
3791  
3792 +
3793 +
3794   # Try to determine native compiler flags that allow us to use F90 suffix
3795   # for preprocessed f90 source.
3796  
# Line 3268 | Line 3798 | if test "$ac_test_PREPFLAG" != "set"; then
3798    PREPFLAG=""
3799    case "${host_cpu}-${host_os}" in
3800  
3801 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3801 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3802                      PREPFLAG="-fpp1 "
3803                  fi;;
3804 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3804 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3805                      PREPFLAG="-qsuffix=cpp=F90 "
3806                  fi;;
3807    *darwin*)
3808 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3808 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3809                  PREPFLAG="-qsuffix=cpp=F90 "
3810          fi;;
3811    esac
# Line 3290 | Line 3820 | echo $ECHO_N "checking to make sure F90 preprocessor f
3820   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3821  
3822  
3823 <  ac_ext=f90
3824 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3825 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3826 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3823 >  ac_ext=${FC_SRCEXT-f}
3824 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3825 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3826 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3827  
3828    ac_save_ext=$ac_ext
3829    ac_ext=F90
3830 <  ac_save_F90FLAGS=$F90FLAGS
3830 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3831  
3832    if test "$PREPFLAG"; then
3833 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3833 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3834   fi
3835  
3836      cat >conftest.$ac_ext <<_ACEOF
3837  
3838  
3839 < program main
3310 <
3839 > program conftest
3840    integer :: i
3841    i = 1
3842 + end program conftest
3843  
3314
3315 end program main
3316
3844   _ACEOF
3845   rm -f conftest.$ac_objext
3846   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3324 | Line 3851 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3851    cat conftest.err >&5
3852    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853    (exit $ac_status); } &&
3854 <         { ac_try='test -z "$ac_f90_werror_flag"
3854 >         { ac_try='test -z "$ac_fc_werror_flag"
3855                           || test ! -s conftest.err'
3856    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3857    (eval $ac_try) 2>&5
# Line 3346 | Line 3873 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3873   fi
3874   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3875  
3876 <  F90FLAGS=$ac_save_F90FLAGS
3876 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3877    ac_ext=$ac_save_ext
3878 <  ac_ext=c
3879 < ac_cpp='$CPP $CPPFLAGS'
3880 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3881 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3355 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3878 >  ac_ext=${FC_SRCEXT-f}
3879 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3880 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3881 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3882  
3883  
3884    if test "$prepflagworks" = 1; then
3885      echo "$as_me:$LINENO: result: yes" >&5
3886   echo "${ECHO_T}yes" >&6
3887 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3888  
3889    else
3890      echo "$as_me:$LINENO: result: no" >&5
# Line 3379 | Line 3906 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3906    PREPDEFFLAG=""
3907    case "${host_cpu}-${host_os}" in
3908  
3909 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3909 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3910                      PREPDEFFLAG=" "
3911                  fi;;
3912 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3912 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3913                      PREPDEFFLAG="-WF,"
3914                  fi;;
3915    *darwin*)
3916 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3917 <                PREPDEFFLAG="-WF,"
3918 <        fi;;
3919 <  esac
3920 <
3921 <  if test -z "$PREPDEFFLAG"; then
3922 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3923 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3924 <        PREPDEFFLAG=" "
3925 <  fi
3926 <
3927 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3928 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3929 <
3930 <
3931 <  ac_ext=f90
3932 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3933 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3934 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3935 <
3936 <  ac_save_ext=$ac_ext
3937 <  ac_ext=F90
3938 <  ac_save_F90FLAGS=$F90FLAGS
3939 <
3940 <  if test "$PREPDEFFLAG"; then
3941 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3942 < fi
3943 <
3944 <    cat >conftest.$ac_ext <<_ACEOF
3945 <
3946 <
3947 < program main
3948 <
3949 <  integer :: i
3950 < #ifdef TEST
3951 <  i = 1
3952 < #else
3953 <  choke me
3954 < #endif
3955 <
3956 <
3957 < end program main
3958 <
3959 < _ACEOF
3960 < rm -f conftest.$ac_objext
3961 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3962 <  (eval $ac_compile) 2>conftest.er1
3963 <  ac_status=$?
3964 <  grep -v '^ *+' conftest.er1 >conftest.err
3965 <  rm -f conftest.er1
3966 <  cat conftest.err >&5
3967 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3968 <  (exit $ac_status); } &&
3969 <         { ac_try='test -z "$ac_f90_werror_flag"
3970 <                         || test ! -s conftest.err'
3971 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3972 <  (eval $ac_try) 2>&5
3973 <  ac_status=$?
3974 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3975 <  (exit $ac_status); }; } &&
3976 <         { ac_try='test -s conftest.$ac_objext'
3977 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3978 <  (eval $ac_try) 2>&5
3979 <  ac_status=$?
3980 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3981 <  (exit $ac_status); }; }; then
3982 <  prepdefflagworks=1
3983 < else
3984 <  echo "$as_me: failed program was:" >&5
3985 < sed 's/^/| /' conftest.$ac_ext >&5
3986 <
3987 < prepdefflagworks=0
3988 < fi
3989 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3990 <
3991 <  F90FLAGS=$ac_save_F90FLAGS
3992 <  ac_ext=$ac_save_ext
3993 <  ac_ext=c
3994 < ac_cpp='$CPP $CPPFLAGS'
3995 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3996 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3997 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3998 <
3999 <
4000 <
4001 <  if test "$prepdefflagworks" = 1; then
4002 <    echo "$as_me:$LINENO: result: yes" >&5
4003 < echo "${ECHO_T}yes" >&6
4004 <
4005 <  else
4006 <    echo "$as_me:$LINENO: result: no" >&5
4007 < echo "${ECHO_T}no" >&6
4008 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4009 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4010 <   { (exit 1); exit 1; }; }
4011 <  fi
4012 < fi
4013 <
4014 < ac_ext=f90
4015 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4016 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4017 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4018 <
4019 <
4020 <
4021 < ac_ext=f90
4022 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4023 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4024 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4025 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
4026 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
4027 < if test "${ac_cv_prog_f90_v+set}" = set; then
4028 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4029 < else
4030 <
4031 < cat >conftest.$ac_ext <<_ACEOF
4032 <
4033 < program main
4034 <
4035 <
4036 < end program main
4037 <
4038 < _ACEOF
4039 < rm -f conftest.$ac_objext
4040 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4041 <  (eval $ac_compile) 2>conftest.er1
4042 <  ac_status=$?
4043 <  grep -v '^ *+' conftest.er1 >conftest.err
4044 <  rm -f conftest.er1
4045 <  cat conftest.err >&5
4046 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4047 <  (exit $ac_status); } &&
4048 <         { ac_try='test -z "$ac_f90_werror_flag"
4049 <                         || test ! -s conftest.err'
4050 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4051 <  (eval $ac_try) 2>&5
4052 <  ac_status=$?
4053 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4054 <  (exit $ac_status); }; } &&
4055 <         { ac_try='test -s conftest.$ac_objext'
4056 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4057 <  (eval $ac_try) 2>&5
4058 <  ac_status=$?
4059 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4060 <  (exit $ac_status); }; }; then
4061 <  ac_cv_prog_f90_v=
4062 < # Try some options frequently used verbose output
4063 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4064 <  ac_ext=f90
4065 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4066 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4067 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4068 <
4069 < cat >conftest.$ac_ext <<_ACEOF
4070 <
4071 < program main
4072 <
4073 <
4074 < end program main
4075 <
4076 < _ACEOF
4077 <
4078 < # Compile and link our simple test program by passing a flag (argument
4079 < # 1 to this macro) to the Fortran 90 compiler in order to get
4080 < # "verbose" output that we can then parse for the Fortran 90 linker
4081 < # flags.
4082 < ac_save_F90FLAGS=$F90FLAGS
4083 < F90FLAGS="$F90FLAGS $ac_verb"
4084 <
4085 < (eval echo $as_me:3558: \"$ac_link\") >&5
4086 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4087 < echo "$ac_f90_v_output" >&5
4088 < F90FLAGS=$ac_save_F90FLAGS
4089 <
4090 < rm -f conftest.*
4091 < ac_ext=f90
4092 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4093 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4094 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4095 <
4096 < # If we are using xlf then replace all the commas with spaces.
4097 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4098 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4099 < fi
4100 <
4101 < # If we are using Cray Fortran then delete quotes.
4102 < # Use "\"" instead of '"' for font-lock-mode.
4103 < # FIXME: a more general fix for quoted arguments with spaces?
4104 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4105 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4106 < fi
4107 <  # look for -l* and *.a constructs in the output
4108 <  for ac_arg in $ac_f90_v_output; do
4109 <     case $ac_arg in
4110 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4111 <          ac_cv_prog_f90_v=$ac_verb
4112 <          break 2 ;;
4113 <     esac
4114 <  done
4115 < done
4116 < if test -z "$ac_cv_prog_f90_v"; then
4117 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4118 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4119 < fi
4120 < else
4121 <  echo "$as_me: failed program was:" >&5
4122 < sed 's/^/| /' conftest.$ac_ext >&5
4123 <
4124 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4125 < echo "$as_me: WARNING: compilation failed" >&2;}
4126 < fi
4127 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4128 <
4129 < fi
4130 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4131 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4132 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4133 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4134 < if test "${ac_cv_flibs+set}" = set; then
4135 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4136 < else
4137 <  if test "x$F90LIBS" != "x"; then
4138 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4139 < else
4140 <
4141 < ac_ext=f90
4142 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4143 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4144 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4145 <
4146 < cat >conftest.$ac_ext <<_ACEOF
4147 <
4148 < program main
4149 <
4150 <
4151 < end program main
4152 <
4153 < _ACEOF
4154 <
4155 < # Compile and link our simple test program by passing a flag (argument
4156 < # 1 to this macro) to the Fortran 90 compiler in order to get
4157 < # "verbose" output that we can then parse for the Fortran 90 linker
4158 < # flags.
4159 < ac_save_F90FLAGS=$F90FLAGS
4160 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4161 <
4162 < (eval echo $as_me:3635: \"$ac_link\") >&5
4163 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4164 < echo "$ac_f90_v_output" >&5
4165 < F90FLAGS=$ac_save_F90FLAGS
4166 <
4167 < rm -f conftest.*
4168 < ac_ext=f90
4169 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4170 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4171 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4172 <
4173 < # If we are using xlf then replace all the commas with spaces.
4174 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4175 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4176 < fi
4177 <
4178 < # If we are using Cray Fortran then delete quotes.
4179 < # Use "\"" instead of '"' for font-lock-mode.
4180 < # FIXME: a more general fix for quoted arguments with spaces?
4181 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4182 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4183 < fi
4184 <
4185 < ac_cv_f90libs=
4186 <
4187 < # Save positional arguments (if any)
4188 < ac_save_positional="$@"
4189 <
4190 < set X $ac_f90_v_output
4191 < while test $# != 1; do
4192 <  shift
4193 <  ac_arg=$1
4194 <  case $ac_arg in
4195 <        [\\/]*.a | ?:[\\/]*.a)
4196 <            ac_exists=false
4197 <  for ac_i in $ac_cv_f90libs; do
4198 <    if test x"$ac_arg" = x"$ac_i"; then
4199 <      ac_exists=true
4200 <      break
4201 <    fi
4202 <  done
4203 <
4204 <  if test x"$ac_exists" = xtrue; then
4205 <  :
4206 < else
4207 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4208 < fi
4209 <
4210 <          ;;
4211 <        -bI:*)
4212 <            ac_exists=false
4213 <  for ac_i in $ac_cv_f90libs; do
4214 <    if test x"$ac_arg" = x"$ac_i"; then
4215 <      ac_exists=true
4216 <      break
4217 <    fi
4218 <  done
4219 <
4220 <  if test x"$ac_exists" = xtrue; then
4221 <  :
4222 < else
4223 <  if test "$ac_compiler_gnu" = yes; then
4224 <  for ac_link_opt in $ac_arg; do
4225 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4226 <  done
4227 < else
4228 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4229 < fi
4230 < fi
4231 <
4232 <          ;;
4233 <          # Ignore these flags.
4234 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4235 <          ;;
4236 <        -lkernel32)
4237 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4238 <          ;;
4239 <        -[LRuY])
4240 <          # These flags, when seen by themselves, take an argument.
4241 <          # We remove the space between option and argument and re-iterate
4242 <          # unless we find an empty arg or a new option (starting with -)
4243 <          case $2 in
4244 <             "" | -*);;
4245 <             *)
4246 <                ac_arg="$ac_arg$2"
4247 <
4248 <                shift; shift
4249 <                set X $ac_arg "$@"
4250 <                ;;
4251 <          esac
4252 <          ;;
4253 <        -YP,*)
4254 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4255 <              ac_exists=false
4256 <  for ac_i in $ac_cv_f90libs; do
4257 <    if test x"$ac_j" = x"$ac_i"; then
4258 <      ac_exists=true
4259 <      break
4260 <    fi
4261 <  done
4262 <
4263 <  if test x"$ac_exists" = xtrue; then
4264 <  :
4265 < else
4266 <  ac_arg="$ac_arg $ac_j"
4267 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4268 < fi
4269 <
4270 <          done
4271 <          ;;
4272 <        -[lLR]*)
4273 <            ac_exists=false
4274 <  for ac_i in $ac_cv_f90libs; do
4275 <    if test x"$ac_arg" = x"$ac_i"; then
4276 <      ac_exists=true
4277 <      break
4278 <    fi
4279 <  done
4280 <
4281 <  if test x"$ac_exists" = xtrue; then
4282 <  :
4283 < else
4284 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4285 < fi
4286 <
4287 <          ;;
4288 <          # Ignore everything else.
4289 <  esac
4290 < done
4291 < # restore positional arguments
4292 < set X $ac_save_positional; shift
4293 <
4294 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
4295 < # then we insist that the "run path" must be an absolute path (i.e. it
4296 < # must begin with a "/").
4297 < case `(uname -sr) 2>/dev/null` in
4298 <   "SunOS 5"*)
4299 <      ac_ld_run_path=`echo $ac_f90_v_output |
4300 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4301 <      test "x$ac_ld_run_path" != x &&
4302 <
4303 <        if test "$ac_compiler_gnu" = yes; then
4304 <  for ac_link_opt in $ac_ld_run_path; do
4305 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4306 <  done
4307 < else
4308 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4309 < fi
4310 <      ;;
4311 < esac
4312 < fi # test "x$F90LIBS" = "x"
4313 <
4314 < fi
4315 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4316 < echo "${ECHO_T}$ac_cv_flibs" >&6
4317 < F90LIBS="$ac_cv_f90libs"
4318 <
4319 < ac_ext=f90
4320 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4321 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4322 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4323 <
4324 <
4325 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4326 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4327 < if test "${ac_cv_f90_mangling+set}" = set; then
4328 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4329 < else
4330 <  ac_ext=f90
4331 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4332 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4333 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4334 < cat >conftest.$ac_ext <<_ACEOF
4335 < subroutine foobar()
4336 < return
4337 < end
4338 < subroutine foo_bar()
4339 < return
4340 < end
4341 < _ACEOF
4342 < rm -f conftest.$ac_objext
4343 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4344 <  (eval $ac_compile) 2>conftest.er1
4345 <  ac_status=$?
4346 <  grep -v '^ *+' conftest.er1 >conftest.err
4347 <  rm -f conftest.er1
4348 <  cat conftest.err >&5
4349 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4350 <  (exit $ac_status); } &&
4351 <         { ac_try='test -z "$ac_f90_werror_flag"
4352 <                         || test ! -s conftest.err'
4353 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4354 <  (eval $ac_try) 2>&5
4355 <  ac_status=$?
4356 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4357 <  (exit $ac_status); }; } &&
4358 <         { ac_try='test -s conftest.$ac_objext'
4359 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4360 <  (eval $ac_try) 2>&5
4361 <  ac_status=$?
4362 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4363 <  (exit $ac_status); }; }; then
4364 <  mv conftest.$ac_objext cf90_test.$ac_objext
4365 <
4366 <  ac_ext=c
4367 < ac_cpp='$CPP $CPPFLAGS'
4368 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4369 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4370 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4371 <
4372 <  ac_save_LIBS=$LIBS
4373 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4374 <
4375 <  ac_success=no
4376 <  for ac_foobar in foobar FOOBAR; do
4377 <    for ac_underscore in "" "_"; do
4378 <      ac_func="$ac_foobar$ac_underscore"
4379 <      cat >conftest.$ac_ext <<_ACEOF
4380 < /* confdefs.h.  */
4381 < _ACEOF
4382 < cat confdefs.h >>conftest.$ac_ext
4383 < cat >>conftest.$ac_ext <<_ACEOF
4384 < /* end confdefs.h.  */
4385 <
4386 < /* Override any gcc2 internal prototype to avoid an error.  */
4387 < #ifdef __cplusplus
4388 < extern "C"
4389 < #endif
4390 < /* We use char because int might match the return type of a gcc2
4391 <   builtin and then its argument prototype would still apply.  */
4392 < char $ac_func ();
4393 < int
4394 < main ()
4395 < {
4396 < $ac_func ();
3916 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3917 >                PREPDEFFLAG="-WF,"
3918 >        fi;;
3919 >  esac
3920 >
3921 >  if test -z "$PREPDEFFLAG"; then
3922 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3923 > echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3924 >        PREPDEFFLAG=" "
3925 >  fi
3926 >
3927 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3928 > echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3929 >
3930 >
3931 >  ac_ext=${FC_SRCEXT-f}
3932 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3933 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3934 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3935 >
3936 >  ac_save_ext=$ac_ext
3937 >  ac_ext=F90
3938 >  ac_save_FCFLAGS=$FCFLAGS
3939 >
3940 >  if test "$PREPDEFFLAG"; then
3941 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3942 > fi
3943 >
3944 >    cat >conftest.$ac_ext <<_ACEOF
3945 >
3946 >
3947 > program conftest
3948 >  integer :: i
3949 > #ifdef TEST
3950 >  i = 1
3951 > #else
3952 >  choke me
3953 > #endif
3954 > end program conftest
3955 >
3956 > _ACEOF
3957 > rm -f conftest.$ac_objext
3958 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959 >  (eval $ac_compile) 2>conftest.er1
3960 >  ac_status=$?
3961 >  grep -v '^ *+' conftest.er1 >conftest.err
3962 >  rm -f conftest.er1
3963 >  cat conftest.err >&5
3964 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965 >  (exit $ac_status); } &&
3966 >         { ac_try='test -z "$ac_fc_werror_flag"
3967 >                         || test ! -s conftest.err'
3968 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969 >  (eval $ac_try) 2>&5
3970 >  ac_status=$?
3971 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972 >  (exit $ac_status); }; } &&
3973 >         { ac_try='test -s conftest.$ac_objext'
3974 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975 >  (eval $ac_try) 2>&5
3976 >  ac_status=$?
3977 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978 >  (exit $ac_status); }; }; then
3979 >  prepdefflagworks=1
3980 > else
3981 >  echo "$as_me: failed program was:" >&5
3982 > sed 's/^/| /' conftest.$ac_ext >&5
3983 >
3984 > prepdefflagworks=0
3985 > fi
3986 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3987 >
3988 >  FCFLAGS=$ac_save_FCFLAGS
3989 >  ac_ext=$ac_save_ext
3990 >  ac_ext=${FC_SRCEXT-f}
3991 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3992 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3993 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3994 >
3995 >
3996 >  if test "$prepdefflagworks" = 1; then
3997 >    echo "$as_me:$LINENO: result: yes" >&5
3998 > echo "${ECHO_T}yes" >&6
3999 >
4000 >  else
4001 >    echo "$as_me:$LINENO: result: no" >&5
4002 > echo "${ECHO_T}no" >&6
4003 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4004 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4005 >   { (exit 1); exit 1; }; }
4006 >  fi
4007 > fi
4008 >
4009 > ac_ext=${FC_SRCEXT-f}
4010 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4011 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4012 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4013 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4014 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4015 > if test "${ac_cv_prog_fc_v+set}" = set; then
4016 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4017 > else
4018 >  cat >conftest.$ac_ext <<_ACEOF
4019 >      program main
4020 >
4021 >      end
4022 > _ACEOF
4023 > rm -f conftest.$ac_objext
4024 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4025 >  (eval $ac_compile) 2>conftest.er1
4026 >  ac_status=$?
4027 >  grep -v '^ *+' conftest.er1 >conftest.err
4028 >  rm -f conftest.er1
4029 >  cat conftest.err >&5
4030 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031 >  (exit $ac_status); } &&
4032 >         { ac_try='test -z "$ac_fc_werror_flag"
4033 >                         || test ! -s conftest.err'
4034 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4035 >  (eval $ac_try) 2>&5
4036 >  ac_status=$?
4037 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4038 >  (exit $ac_status); }; } &&
4039 >         { ac_try='test -s conftest.$ac_objext'
4040 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4041 >  (eval $ac_try) 2>&5
4042 >  ac_status=$?
4043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044 >  (exit $ac_status); }; }; then
4045 >  ac_cv_prog_fc_v=
4046 > # Try some options frequently used verbose output
4047 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4048 >  cat >conftest.$ac_ext <<_ACEOF
4049 >      program main
4050 >
4051 >      end
4052 > _ACEOF
4053 >
4054 > # Compile and link our simple test program by passing a flag (argument
4055 > # 1 to this macro) to the Fortran compiler in order to get
4056 > # "verbose" output that we can then parse for the Fortran linker
4057 > # flags.
4058 > ac_save_FFLAGS=$FCFLAGS
4059 > FCFLAGS="$FCFLAGS $ac_verb"
4060 > (eval echo $as_me:4060: \"$ac_link\") >&5
4061 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4062 > echo "$ac_fc_v_output" >&5
4063 > FCFLAGS=$ac_save_FFLAGS
4064 >
4065 > rm -f conftest*
4066 >
4067 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4068 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4069 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4070 > ac_fc_v_output="`echo $ac_fc_v_output |
4071 >        grep 'LPATH is:' |
4072 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4073 >
4074 > case $ac_fc_v_output in
4075 >  # If we are using xlf then replace all the commas with spaces.
4076 >  *xlfentry*)
4077 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4078 >
4079 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4080 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4081 >  *mGLOB_options_string*)
4082 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4083 >
4084 >  # If we are using Cray Fortran then delete quotes.
4085 >  # Use "\"" instead of '"' for font-lock-mode.
4086 >  # FIXME: a more general fix for quoted arguments with spaces?
4087 >  *cft90*)
4088 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4089 > esac
4090 >
4091 >
4092 >  # look for -l* and *.a constructs in the output
4093 >  for ac_arg in $ac_fc_v_output; do
4094 >     case $ac_arg in
4095 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4096 >          ac_cv_prog_fc_v=$ac_verb
4097 >          break 2 ;;
4098 >     esac
4099 >  done
4100 > done
4101 > if test -z "$ac_cv_prog_fc_v"; then
4102 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4103 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4104 > fi
4105 > else
4106 >  echo "$as_me: failed program was:" >&5
4107 > sed 's/^/| /' conftest.$ac_ext >&5
4108 >
4109 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4110 > echo "$as_me: WARNING: compilation failed" >&2;}
4111 > fi
4112 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4113 >
4114 > fi
4115 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4116 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4117 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4118 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4119 > if test "${ac_cv_fc_libs+set}" = set; then
4120 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4121 > else
4122 >  if test "x$FCLIBS" != "x"; then
4123 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4124 > else
4125 >
4126 > cat >conftest.$ac_ext <<_ACEOF
4127 >      program main
4128 >
4129 >      end
4130 > _ACEOF
4131 >
4132 > # Compile and link our simple test program by passing a flag (argument
4133 > # 1 to this macro) to the Fortran compiler in order to get
4134 > # "verbose" output that we can then parse for the Fortran linker
4135 > # flags.
4136 > ac_save_FFLAGS=$FCFLAGS
4137 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4138 > (eval echo $as_me:4138: \"$ac_link\") >&5
4139 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4140 > echo "$ac_fc_v_output" >&5
4141 > FCFLAGS=$ac_save_FFLAGS
4142 >
4143 > rm -f conftest*
4144 >
4145 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4146 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4147 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4148 > ac_fc_v_output="`echo $ac_fc_v_output |
4149 >        grep 'LPATH is:' |
4150 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4151 >
4152 > case $ac_fc_v_output in
4153 >  # If we are using xlf then replace all the commas with spaces.
4154 >  *xlfentry*)
4155 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4156 >
4157 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4158 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4159 >  *mGLOB_options_string*)
4160 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4161 >
4162 >  # If we are using Cray Fortran then delete quotes.
4163 >  # Use "\"" instead of '"' for font-lock-mode.
4164 >  # FIXME: a more general fix for quoted arguments with spaces?
4165 >  *cft90*)
4166 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4167 > esac
4168 >
4169 >
4170 >
4171 > ac_cv_fc_libs=
4172 >
4173 > # Save positional arguments (if any)
4174 > ac_save_positional="$@"
4175 >
4176 > set X $ac_fc_v_output
4177 > while test $# != 1; do
4178 >  shift
4179 >  ac_arg=$1
4180 >  case $ac_arg in
4181 >        [\\/]*.a | ?:[\\/]*.a)
4182 >            ac_exists=false
4183 >  for ac_i in $ac_cv_fc_libs; do
4184 >    if test x"$ac_arg" = x"$ac_i"; then
4185 >      ac_exists=true
4186 >      break
4187 >    fi
4188 >  done
4189 >
4190 >  if test x"$ac_exists" = xtrue; then
4191 >  :
4192 > else
4193 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4194 > fi
4195 >
4196 >          ;;
4197 >        -bI:*)
4198 >            ac_exists=false
4199 >  for ac_i in $ac_cv_fc_libs; do
4200 >    if test x"$ac_arg" = x"$ac_i"; then
4201 >      ac_exists=true
4202 >      break
4203 >    fi
4204 >  done
4205 >
4206 >  if test x"$ac_exists" = xtrue; then
4207 >  :
4208 > else
4209 >  if test "$ac_compiler_gnu" = yes; then
4210 >  for ac_link_opt in $ac_arg; do
4211 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4212 >  done
4213 > else
4214 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4215 > fi
4216 > fi
4217 >
4218 >          ;;
4219 >          # Ignore these flags.
4220 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4221 >          ;;
4222 >        -lkernel32)
4223 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4224 >          ;;
4225 >        -[LRuY])
4226 >          # These flags, when seen by themselves, take an argument.
4227 >          # We remove the space between option and argument and re-iterate
4228 >          # unless we find an empty arg or a new option (starting with -)
4229 >          case $2 in
4230 >             "" | -*);;
4231 >             *)
4232 >                ac_arg="$ac_arg$2"
4233 >                shift; shift
4234 >                set X $ac_arg "$@"
4235 >                ;;
4236 >          esac
4237 >          ;;
4238 >        -YP,*)
4239 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4240 >              ac_exists=false
4241 >  for ac_i in $ac_cv_fc_libs; do
4242 >    if test x"$ac_j" = x"$ac_i"; then
4243 >      ac_exists=true
4244 >      break
4245 >    fi
4246 >  done
4247 >
4248 >  if test x"$ac_exists" = xtrue; then
4249 >  :
4250 > else
4251 >  ac_arg="$ac_arg $ac_j"
4252 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4253 > fi
4254 >
4255 >          done
4256 >          ;;
4257 >        -[lLR]*)
4258 >            ac_exists=false
4259 >  for ac_i in $ac_cv_fc_libs; do
4260 >    if test x"$ac_arg" = x"$ac_i"; then
4261 >      ac_exists=true
4262 >      break
4263 >    fi
4264 >  done
4265 >
4266 >  if test x"$ac_exists" = xtrue; then
4267 >  :
4268 > else
4269 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4270 > fi
4271 >
4272 >          ;;
4273 >          # Ignore everything else.
4274 >  esac
4275 > done
4276 > # restore positional arguments
4277 > set X $ac_save_positional; shift
4278 >
4279 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
4280 > # then we insist that the "run path" must be an absolute path (i.e. it
4281 > # must begin with a "/").
4282 > case `(uname -sr) 2>/dev/null` in
4283 >   "SunOS 5"*)
4284 >      ac_ld_run_path=`echo $ac_fc_v_output |
4285 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4286 >      test "x$ac_ld_run_path" != x &&
4287 >        if test "$ac_compiler_gnu" = yes; then
4288 >  for ac_link_opt in $ac_ld_run_path; do
4289 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4290 >  done
4291 > else
4292 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4293 > fi
4294 >      ;;
4295 > esac
4296 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4297 >
4298 > fi
4299 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4300 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4301 > FCLIBS="$ac_cv_fc_libs"
4302 >
4303 >
4304 > ac_ext=${FC_SRCEXT-f}
4305 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4306 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4307 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4308 >
4309 >
4310 > ac_ext=${FC_SRCEXT-f}
4311 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4312 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4313 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4314 >
4315 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4316 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4317 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4318 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4319 > else
4320 >  ac_fc_dm_save_LIBS=$LIBS
4321 > LIBS="$LIBS $FCLIBS"
4322 > ac_fortran_dm_var=FC_DUMMY_MAIN
4323 > ac_ext=c
4324 > ac_cpp='$CPP $CPPFLAGS'
4325 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4326 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4327 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4328 >
4329 > # First, try linking without a dummy main:
4330 > cat >conftest.$ac_ext <<_ACEOF
4331 > /* confdefs.h.  */
4332 > _ACEOF
4333 > cat confdefs.h >>conftest.$ac_ext
4334 > cat >>conftest.$ac_ext <<_ACEOF
4335 > /* end confdefs.h.  */
4336 >
4337 > #ifdef FC_DUMMY_MAIN
4338 > #ifndef FC_DUMMY_MAIN_EQ_F77
4339 > #  ifdef __cplusplus
4340 >     extern "C"
4341 > #  endif
4342 >   int FC_DUMMY_MAIN() { return 1; }
4343 > #endif
4344 > #endif
4345 > int
4346 > main ()
4347 > {
4348 >
4349 >  ;
4350 >  return 0;
4351 > }
4352 > _ACEOF
4353 > rm -f conftest.$ac_objext conftest$ac_exeext
4354 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4355 >  (eval $ac_link) 2>conftest.er1
4356 >  ac_status=$?
4357 >  grep -v '^ *+' conftest.er1 >conftest.err
4358 >  rm -f conftest.er1
4359 >  cat conftest.err >&5
4360 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4361 >  (exit $ac_status); } &&
4362 >         { ac_try='test -z "$ac_c_werror_flag"
4363 >                         || test ! -s conftest.err'
4364 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4365 >  (eval $ac_try) 2>&5
4366 >  ac_status=$?
4367 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4368 >  (exit $ac_status); }; } &&
4369 >         { ac_try='test -s conftest$ac_exeext'
4370 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4371 >  (eval $ac_try) 2>&5
4372 >  ac_status=$?
4373 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4374 >  (exit $ac_status); }; }; then
4375 >  ac_cv_fortran_dummy_main=none
4376 > else
4377 >  echo "$as_me: failed program was:" >&5
4378 > sed 's/^/| /' conftest.$ac_ext >&5
4379 >
4380 > ac_cv_fortran_dummy_main=unknown
4381 > fi
4382 > rm -f conftest.err conftest.$ac_objext \
4383 >      conftest$ac_exeext conftest.$ac_ext
4384 >
4385 > if test $ac_cv_fortran_dummy_main = unknown; then
4386 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4387 >     cat >conftest.$ac_ext <<_ACEOF
4388 > /* confdefs.h.  */
4389 > _ACEOF
4390 > cat confdefs.h >>conftest.$ac_ext
4391 > cat >>conftest.$ac_ext <<_ACEOF
4392 > /* end confdefs.h.  */
4393 > #define $ac_fortran_dm_var $ac_func
4394 > #ifdef FC_DUMMY_MAIN
4395 > #ifndef FC_DUMMY_MAIN_EQ_F77
4396 > #  ifdef __cplusplus
4397 >     extern "C"
4398 > #  endif
4399 >   int FC_DUMMY_MAIN() { return 1; }
4400 > #endif
4401 > #endif
4402 > int
4403 > main ()
4404 > {
4405 >
4406 >  ;
4407 >  return 0;
4408 > }
4409 > _ACEOF
4410 > rm -f conftest.$ac_objext conftest$ac_exeext
4411 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4412 >  (eval $ac_link) 2>conftest.er1
4413 >  ac_status=$?
4414 >  grep -v '^ *+' conftest.er1 >conftest.err
4415 >  rm -f conftest.er1
4416 >  cat conftest.err >&5
4417 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4418 >  (exit $ac_status); } &&
4419 >         { ac_try='test -z "$ac_c_werror_flag"
4420 >                         || test ! -s conftest.err'
4421 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4422 >  (eval $ac_try) 2>&5
4423 >  ac_status=$?
4424 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4425 >  (exit $ac_status); }; } &&
4426 >         { ac_try='test -s conftest$ac_exeext'
4427 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4428 >  (eval $ac_try) 2>&5
4429 >  ac_status=$?
4430 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4431 >  (exit $ac_status); }; }; then
4432 >  ac_cv_fortran_dummy_main=$ac_func; break
4433 > else
4434 >  echo "$as_me: failed program was:" >&5
4435 > sed 's/^/| /' conftest.$ac_ext >&5
4436 >
4437 > fi
4438 > rm -f conftest.err conftest.$ac_objext \
4439 >      conftest$ac_exeext conftest.$ac_ext
4440 >   done
4441 > fi
4442 > ac_ext=${FC_SRCEXT-f}
4443 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4444 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4445 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4446 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4447 > rm -f conftest*
4448 > LIBS=$ac_fc_dm_save_LIBS
4449 >
4450 > fi
4451 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4452 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4453 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4454 > if test "$FC_DUMMY_MAIN" != unknown; then
4455 >  if test $FC_DUMMY_MAIN != none; then
4456 >
4457 > cat >>confdefs.h <<_ACEOF
4458 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4459 > _ACEOF
4460 >
4461 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4462 >
4463 > cat >>confdefs.h <<\_ACEOF
4464 > #define FC_DUMMY_MAIN_EQ_F77 1
4465 > _ACEOF
4466 >
4467 >  fi
4468 > fi
4469 > else
4470 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4471 > See \`config.log' for more details." >&5
4472 > echo "$as_me: error: linking to Fortran libraries from C fails
4473 > See \`config.log' for more details." >&2;}
4474 >   { (exit 1); exit 1; }; }
4475 > fi
4476 >
4477 >
4478 > ac_ext=${FC_SRCEXT-f}
4479 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4480 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4481 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4482 >
4483 > ac_ext=${FC_SRCEXT-f}
4484 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4485 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4486 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4487 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4488 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4489 > if test "${ac_cv_fc_mangling+set}" = set; then
4490 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4491 > else
4492 >  cat >conftest.$ac_ext <<_ACEOF
4493 >      subroutine foobar()
4494 >      return
4495 >      end
4496 >      subroutine foo_bar()
4497 >      return
4498 >      end
4499 > _ACEOF
4500 > rm -f conftest.$ac_objext
4501 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4502 >  (eval $ac_compile) 2>conftest.er1
4503 >  ac_status=$?
4504 >  grep -v '^ *+' conftest.er1 >conftest.err
4505 >  rm -f conftest.er1
4506 >  cat conftest.err >&5
4507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508 >  (exit $ac_status); } &&
4509 >         { ac_try='test -z "$ac_fc_werror_flag"
4510 >                         || test ! -s conftest.err'
4511 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512 >  (eval $ac_try) 2>&5
4513 >  ac_status=$?
4514 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515 >  (exit $ac_status); }; } &&
4516 >         { ac_try='test -s conftest.$ac_objext'
4517 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518 >  (eval $ac_try) 2>&5
4519 >  ac_status=$?
4520 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521 >  (exit $ac_status); }; }; then
4522 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4523 >
4524 >  ac_save_LIBS=$LIBS
4525 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4526 >
4527 >  ac_ext=c
4528 > ac_cpp='$CPP $CPPFLAGS'
4529 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4530 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4531 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4532 >  ac_success=no
4533 >  for ac_foobar in foobar FOOBAR; do
4534 >    for ac_underscore in "" "_"; do
4535 >      ac_func="$ac_foobar$ac_underscore"
4536 >      cat >conftest.$ac_ext <<_ACEOF
4537 > /* confdefs.h.  */
4538 > _ACEOF
4539 > cat confdefs.h >>conftest.$ac_ext
4540 > cat >>conftest.$ac_ext <<_ACEOF
4541 > /* end confdefs.h.  */
4542 >
4543 > /* Override any gcc2 internal prototype to avoid an error.  */
4544 > #ifdef __cplusplus
4545 > extern "C"
4546 > #endif
4547 > /* We use char because int might match the return type of a gcc2
4548 >   builtin and then its argument prototype would still apply.  */
4549 > char $ac_func ();
4550 > #ifdef FC_DUMMY_MAIN
4551 > #ifndef FC_DUMMY_MAIN_EQ_F77
4552 > #  ifdef __cplusplus
4553 >     extern "C"
4554 > #  endif
4555 >   int FC_DUMMY_MAIN() { return 1; }
4556 > #endif
4557 > #endif
4558 > int
4559 > main ()
4560 > {
4561 > $ac_func ();
4562 >  ;
4563 >  return 0;
4564 > }
4565 > _ACEOF
4566 > rm -f conftest.$ac_objext conftest$ac_exeext
4567 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4568 >  (eval $ac_link) 2>conftest.er1
4569 >  ac_status=$?
4570 >  grep -v '^ *+' conftest.er1 >conftest.err
4571 >  rm -f conftest.er1
4572 >  cat conftest.err >&5
4573 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4574 >  (exit $ac_status); } &&
4575 >         { ac_try='test -z "$ac_c_werror_flag"
4576 >                         || test ! -s conftest.err'
4577 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4578 >  (eval $ac_try) 2>&5
4579 >  ac_status=$?
4580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4581 >  (exit $ac_status); }; } &&
4582 >         { ac_try='test -s conftest$ac_exeext'
4583 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4584 >  (eval $ac_try) 2>&5
4585 >  ac_status=$?
4586 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4587 >  (exit $ac_status); }; }; then
4588 >  ac_success=yes; break 2
4589 > else
4590 >  echo "$as_me: failed program was:" >&5
4591 > sed 's/^/| /' conftest.$ac_ext >&5
4592 >
4593 > fi
4594 > rm -f conftest.err conftest.$ac_objext \
4595 >      conftest$ac_exeext conftest.$ac_ext
4596 >    done
4597 >  done
4598 >  ac_ext=${FC_SRCEXT-f}
4599 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4600 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4601 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4602 >
4603 >  if test "$ac_success" = "yes"; then
4604 >     case $ac_foobar in
4605 >        foobar)
4606 >           ac_case=lower
4607 >           ac_foo_bar=foo_bar
4608 >           ;;
4609 >        FOOBAR)
4610 >           ac_case=upper
4611 >           ac_foo_bar=FOO_BAR
4612 >           ;;
4613 >     esac
4614 >
4615 >     ac_ext=c
4616 > ac_cpp='$CPP $CPPFLAGS'
4617 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4618 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4619 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4620 >     ac_success_extra=no
4621 >     for ac_extra in "" "_"; do
4622 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4623 >        cat >conftest.$ac_ext <<_ACEOF
4624 > /* confdefs.h.  */
4625 > _ACEOF
4626 > cat confdefs.h >>conftest.$ac_ext
4627 > cat >>conftest.$ac_ext <<_ACEOF
4628 > /* end confdefs.h.  */
4629 >
4630 > /* Override any gcc2 internal prototype to avoid an error.  */
4631 > #ifdef __cplusplus
4632 > extern "C"
4633 > #endif
4634 > /* We use char because int might match the return type of a gcc2
4635 >   builtin and then its argument prototype would still apply.  */
4636 > char $ac_func ();
4637 > #ifdef FC_DUMMY_MAIN
4638 > #ifndef FC_DUMMY_MAIN_EQ_F77
4639 > #  ifdef __cplusplus
4640 >     extern "C"
4641 > #  endif
4642 >   int FC_DUMMY_MAIN() { return 1; }
4643 > #endif
4644 > #endif
4645 > int
4646 > main ()
4647 > {
4648 > $ac_func ();
4649 >  ;
4650 >  return 0;
4651 > }
4652 > _ACEOF
4653 > rm -f conftest.$ac_objext conftest$ac_exeext
4654 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4655 >  (eval $ac_link) 2>conftest.er1
4656 >  ac_status=$?
4657 >  grep -v '^ *+' conftest.er1 >conftest.err
4658 >  rm -f conftest.er1
4659 >  cat conftest.err >&5
4660 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4661 >  (exit $ac_status); } &&
4662 >         { ac_try='test -z "$ac_c_werror_flag"
4663 >                         || test ! -s conftest.err'
4664 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4665 >  (eval $ac_try) 2>&5
4666 >  ac_status=$?
4667 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4668 >  (exit $ac_status); }; } &&
4669 >         { ac_try='test -s conftest$ac_exeext'
4670 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4671 >  (eval $ac_try) 2>&5
4672 >  ac_status=$?
4673 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4674 >  (exit $ac_status); }; }; then
4675 >  ac_success_extra=yes; break
4676 > else
4677 >  echo "$as_me: failed program was:" >&5
4678 > sed 's/^/| /' conftest.$ac_ext >&5
4679 >
4680 > fi
4681 > rm -f conftest.err conftest.$ac_objext \
4682 >      conftest$ac_exeext conftest.$ac_ext
4683 >     done
4684 >     ac_ext=${FC_SRCEXT-f}
4685 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4686 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4687 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4688 >
4689 >     if test "$ac_success_extra" = "yes"; then
4690 >        ac_cv_fc_mangling="$ac_case case"
4691 >        if test -z "$ac_underscore"; then
4692 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4693 >        else
4694 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4695 >        fi
4696 >        if test -z "$ac_extra"; then
4697 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4698 >        else
4699 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4700 >        fi
4701 >      else
4702 >        ac_cv_fc_mangling="unknown"
4703 >      fi
4704 >  else
4705 >     ac_cv_fc_mangling="unknown"
4706 >  fi
4707 >
4708 >  LIBS=$ac_save_LIBS
4709 >  rm -f cfortran_test* conftest*
4710 > else
4711 >  echo "$as_me: failed program was:" >&5
4712 > sed 's/^/| /' conftest.$ac_ext >&5
4713 >
4714 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4715 > See \`config.log' for more details." >&5
4716 > echo "$as_me: error: cannot compile a simple Fortran program
4717 > See \`config.log' for more details." >&2;}
4718 >   { (exit 1); exit 1; }; }
4719 > fi
4720 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4721 >
4722 > fi
4723 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4724 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4725 >
4726 > ac_ext=${FC_SRCEXT-f}
4727 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4728 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4729 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4730 >
4731 > ac_ext=${FC_SRCEXT-f}
4732 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4733 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4734 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4735 >
4736 >
4737 > case $ac_cv_fc_mangling in
4738 >  "lower case, no underscore, no extra underscore")
4739 >          cat >>confdefs.h <<\_ACEOF
4740 > #define FC_FUNC(name,NAME) name
4741 > _ACEOF
4742 >
4743 >          cat >>confdefs.h <<\_ACEOF
4744 > #define FC_FUNC_(name,NAME) name
4745 > _ACEOF
4746 > ;;
4747 >  "lower case, no underscore, extra underscore")
4748 >          cat >>confdefs.h <<\_ACEOF
4749 > #define FC_FUNC(name,NAME) name
4750 > _ACEOF
4751 >
4752 >          cat >>confdefs.h <<\_ACEOF
4753 > #define FC_FUNC_(name,NAME) name ## _
4754 > _ACEOF
4755 > ;;
4756 >  "lower case, underscore, no extra underscore")
4757 >          cat >>confdefs.h <<\_ACEOF
4758 > #define FC_FUNC(name,NAME) name ## _
4759 > _ACEOF
4760 >
4761 >          cat >>confdefs.h <<\_ACEOF
4762 > #define FC_FUNC_(name,NAME) name ## _
4763 > _ACEOF
4764 > ;;
4765 >  "lower case, underscore, extra underscore")
4766 >          cat >>confdefs.h <<\_ACEOF
4767 > #define FC_FUNC(name,NAME) name ## _
4768 > _ACEOF
4769 >
4770 >          cat >>confdefs.h <<\_ACEOF
4771 > #define FC_FUNC_(name,NAME) name ## __
4772 > _ACEOF
4773 > ;;
4774 >  "upper case, no underscore, no extra underscore")
4775 >          cat >>confdefs.h <<\_ACEOF
4776 > #define FC_FUNC(name,NAME) NAME
4777 > _ACEOF
4778 >
4779 >          cat >>confdefs.h <<\_ACEOF
4780 > #define FC_FUNC_(name,NAME) NAME
4781 > _ACEOF
4782 > ;;
4783 >  "upper case, no underscore, extra underscore")
4784 >          cat >>confdefs.h <<\_ACEOF
4785 > #define FC_FUNC(name,NAME) NAME
4786 > _ACEOF
4787 >
4788 >          cat >>confdefs.h <<\_ACEOF
4789 > #define FC_FUNC_(name,NAME) NAME ## _
4790 > _ACEOF
4791 > ;;
4792 >  "upper case, underscore, no extra underscore")
4793 >          cat >>confdefs.h <<\_ACEOF
4794 > #define FC_FUNC(name,NAME) NAME ## _
4795 > _ACEOF
4796 >
4797 >          cat >>confdefs.h <<\_ACEOF
4798 > #define FC_FUNC_(name,NAME) NAME ## _
4799 > _ACEOF
4800 > ;;
4801 >  "upper case, underscore, extra underscore")
4802 >          cat >>confdefs.h <<\_ACEOF
4803 > #define FC_FUNC(name,NAME) NAME ## _
4804 > _ACEOF
4805 >
4806 >          cat >>confdefs.h <<\_ACEOF
4807 > #define FC_FUNC_(name,NAME) NAME ## __
4808 > _ACEOF
4809 > ;;
4810 >  *)
4811 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4812 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4813 >          ;;
4814 > esac
4815 >
4816 > ac_ext=${FC_SRCEXT-f}
4817 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4818 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4819 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4820 >
4821 >
4822 >
4823 > ac_ext=${FC_SRCEXT-f}
4824 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4825 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4826 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4827 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4828 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4829 > if test "${ac_cv_prog_fc_v+set}" = set; then
4830 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4831 > else
4832 >  cat >conftest.$ac_ext <<_ACEOF
4833 >      program main
4834 >
4835 >      end
4836 > _ACEOF
4837 > rm -f conftest.$ac_objext
4838 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4839 >  (eval $ac_compile) 2>conftest.er1
4840 >  ac_status=$?
4841 >  grep -v '^ *+' conftest.er1 >conftest.err
4842 >  rm -f conftest.er1
4843 >  cat conftest.err >&5
4844 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4845 >  (exit $ac_status); } &&
4846 >         { ac_try='test -z "$ac_fc_werror_flag"
4847 >                         || test ! -s conftest.err'
4848 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4849 >  (eval $ac_try) 2>&5
4850 >  ac_status=$?
4851 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4852 >  (exit $ac_status); }; } &&
4853 >         { ac_try='test -s conftest.$ac_objext'
4854 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4855 >  (eval $ac_try) 2>&5
4856 >  ac_status=$?
4857 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4858 >  (exit $ac_status); }; }; then
4859 >  ac_cv_prog_fc_v=
4860 > # Try some options frequently used verbose output
4861 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4862 >  cat >conftest.$ac_ext <<_ACEOF
4863 >      program main
4864 >
4865 >      end
4866 > _ACEOF
4867 >
4868 > # Compile and link our simple test program by passing a flag (argument
4869 > # 1 to this macro) to the Fortran compiler in order to get
4870 > # "verbose" output that we can then parse for the Fortran linker
4871 > # flags.
4872 > ac_save_FFLAGS=$FCFLAGS
4873 > FCFLAGS="$FCFLAGS $ac_verb"
4874 > (eval echo $as_me:4874: \"$ac_link\") >&5
4875 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4876 > echo "$ac_fc_v_output" >&5
4877 > FCFLAGS=$ac_save_FFLAGS
4878 >
4879 > rm -f conftest*
4880 >
4881 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4882 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4883 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4884 > ac_fc_v_output="`echo $ac_fc_v_output |
4885 >        grep 'LPATH is:' |
4886 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4887 >
4888 > case $ac_fc_v_output in
4889 >  # If we are using xlf then replace all the commas with spaces.
4890 >  *xlfentry*)
4891 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4892 >
4893 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4894 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4895 >  *mGLOB_options_string*)
4896 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4897 >
4898 >  # If we are using Cray Fortran then delete quotes.
4899 >  # Use "\"" instead of '"' for font-lock-mode.
4900 >  # FIXME: a more general fix for quoted arguments with spaces?
4901 >  *cft90*)
4902 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4903 > esac
4904 >
4905 >
4906 >  # look for -l* and *.a constructs in the output
4907 >  for ac_arg in $ac_fc_v_output; do
4908 >     case $ac_arg in
4909 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4910 >          ac_cv_prog_fc_v=$ac_verb
4911 >          break 2 ;;
4912 >     esac
4913 >  done
4914 > done
4915 > if test -z "$ac_cv_prog_fc_v"; then
4916 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4917 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4918 > fi
4919 > else
4920 >  echo "$as_me: failed program was:" >&5
4921 > sed 's/^/| /' conftest.$ac_ext >&5
4922 >
4923 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4924 > echo "$as_me: WARNING: compilation failed" >&2;}
4925 > fi
4926 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4927 >
4928 > fi
4929 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4930 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4931 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4932 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4933 > if test "${ac_cv_fc_libs+set}" = set; then
4934 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4935 > else
4936 >  if test "x$FCLIBS" != "x"; then
4937 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4938 > else
4939 >
4940 > cat >conftest.$ac_ext <<_ACEOF
4941 >      program main
4942 >
4943 >      end
4944 > _ACEOF
4945 >
4946 > # Compile and link our simple test program by passing a flag (argument
4947 > # 1 to this macro) to the Fortran compiler in order to get
4948 > # "verbose" output that we can then parse for the Fortran linker
4949 > # flags.
4950 > ac_save_FFLAGS=$FCFLAGS
4951 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4952 > (eval echo $as_me:4952: \"$ac_link\") >&5
4953 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4954 > echo "$ac_fc_v_output" >&5
4955 > FCFLAGS=$ac_save_FFLAGS
4956 >
4957 > rm -f conftest*
4958 >
4959 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4960 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4961 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4962 > ac_fc_v_output="`echo $ac_fc_v_output |
4963 >        grep 'LPATH is:' |
4964 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4965 >
4966 > case $ac_fc_v_output in
4967 >  # If we are using xlf then replace all the commas with spaces.
4968 >  *xlfentry*)
4969 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4970 >
4971 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4972 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4973 >  *mGLOB_options_string*)
4974 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4975 >
4976 >  # If we are using Cray Fortran then delete quotes.
4977 >  # Use "\"" instead of '"' for font-lock-mode.
4978 >  # FIXME: a more general fix for quoted arguments with spaces?
4979 >  *cft90*)
4980 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4981 > esac
4982 >
4983 >
4984 >
4985 > ac_cv_fc_libs=
4986 >
4987 > # Save positional arguments (if any)
4988 > ac_save_positional="$@"
4989 >
4990 > set X $ac_fc_v_output
4991 > while test $# != 1; do
4992 >  shift
4993 >  ac_arg=$1
4994 >  case $ac_arg in
4995 >        [\\/]*.a | ?:[\\/]*.a)
4996 >            ac_exists=false
4997 >  for ac_i in $ac_cv_fc_libs; do
4998 >    if test x"$ac_arg" = x"$ac_i"; then
4999 >      ac_exists=true
5000 >      break
5001 >    fi
5002 >  done
5003 >
5004 >  if test x"$ac_exists" = xtrue; then
5005 >  :
5006 > else
5007 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5008 > fi
5009 >
5010 >          ;;
5011 >        -bI:*)
5012 >            ac_exists=false
5013 >  for ac_i in $ac_cv_fc_libs; do
5014 >    if test x"$ac_arg" = x"$ac_i"; then
5015 >      ac_exists=true
5016 >      break
5017 >    fi
5018 >  done
5019 >
5020 >  if test x"$ac_exists" = xtrue; then
5021 >  :
5022 > else
5023 >  if test "$ac_compiler_gnu" = yes; then
5024 >  for ac_link_opt in $ac_arg; do
5025 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5026 >  done
5027 > else
5028 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5029 > fi
5030 > fi
5031 >
5032 >          ;;
5033 >          # Ignore these flags.
5034 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5035 >          ;;
5036 >        -lkernel32)
5037 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5038 >          ;;
5039 >        -[LRuY])
5040 >          # These flags, when seen by themselves, take an argument.
5041 >          # We remove the space between option and argument and re-iterate
5042 >          # unless we find an empty arg or a new option (starting with -)
5043 >          case $2 in
5044 >             "" | -*);;
5045 >             *)
5046 >                ac_arg="$ac_arg$2"
5047 >                shift; shift
5048 >                set X $ac_arg "$@"
5049 >                ;;
5050 >          esac
5051 >          ;;
5052 >        -YP,*)
5053 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5054 >              ac_exists=false
5055 >  for ac_i in $ac_cv_fc_libs; do
5056 >    if test x"$ac_j" = x"$ac_i"; then
5057 >      ac_exists=true
5058 >      break
5059 >    fi
5060 >  done
5061 >
5062 >  if test x"$ac_exists" = xtrue; then
5063 >  :
5064 > else
5065 >  ac_arg="$ac_arg $ac_j"
5066 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5067 > fi
5068 >
5069 >          done
5070 >          ;;
5071 >        -[lLR]*)
5072 >            ac_exists=false
5073 >  for ac_i in $ac_cv_fc_libs; do
5074 >    if test x"$ac_arg" = x"$ac_i"; then
5075 >      ac_exists=true
5076 >      break
5077 >    fi
5078 >  done
5079 >
5080 >  if test x"$ac_exists" = xtrue; then
5081 >  :
5082 > else
5083 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5084 > fi
5085 >
5086 >          ;;
5087 >          # Ignore everything else.
5088 >  esac
5089 > done
5090 > # restore positional arguments
5091 > set X $ac_save_positional; shift
5092 >
5093 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5094 > # then we insist that the "run path" must be an absolute path (i.e. it
5095 > # must begin with a "/").
5096 > case `(uname -sr) 2>/dev/null` in
5097 >   "SunOS 5"*)
5098 >      ac_ld_run_path=`echo $ac_fc_v_output |
5099 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5100 >      test "x$ac_ld_run_path" != x &&
5101 >        if test "$ac_compiler_gnu" = yes; then
5102 >  for ac_link_opt in $ac_ld_run_path; do
5103 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5104 >  done
5105 > else
5106 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5107 > fi
5108 >      ;;
5109 > esac
5110 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5111 >
5112 > fi
5113 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5114 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5115 > FCLIBS="$ac_cv_fc_libs"
5116 >
5117 >
5118 > ac_ext=${FC_SRCEXT-f}
5119 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5120 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5121 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5122 >
5123 >
5124 >
5125 > echo "$as_me:$LINENO: checking for module suffix" >&5
5126 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5127 > rm -f conftest*
5128 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5129 > rm -f work*
5130 > cat >conftest.$ac_ext <<EOF
5131 >        module conftest
5132 >        integer n
5133 >        parameter (n=1)
5134 >        end module conftest
5135 > EOF
5136 > # SGI and absoft compilers generates module name in upper case!
5137 > testname="conftest"
5138 > modcase="lower"
5139 > if (eval $ac_compile) 2>/dev/null ; then
5140 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5141 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5142 >    if test -z "$MOD" ; then
5143 >        MOD=`ls CONFTEST* 2>/dev/null \
5144 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5145 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5146 >        if test -n "$MOD" ; then
5147 >            testname="CONFTEST"
5148 >            modcase="upper"
5149 >        fi
5150 >    fi
5151 >    if test -z "$MOD" ; then
5152 >        echo "$as_me:$LINENO: result: unknown" >&5
5153 > echo "${ECHO_T}unknown" >&6
5154 >        # Use mod if we can't figure it out
5155 >        MOD="mod"
5156 >    else
5157 >        echo "$as_me:$LINENO: result: $MOD" >&5
5158 > echo "${ECHO_T}$MOD" >&6
5159 >    fi
5160 >    if test -s work.pcl ; then
5161 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5162 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5163 >    fi
5164 > else
5165 >    echo "$as_me:$LINENO: result: unknown" >&5
5166 > echo "${ECHO_T}unknown" >&6
5167 > fi
5168 >
5169 >
5170 >
5171 >
5172 >
5173 > # Check for module include path (some use -I, some (Solaris) use -M, some
5174 > # (absoft) use -p).
5175 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5176 > # specified, work.pcl and work.pc are created.  However, if you specify
5177 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5178 > # Use the module made above
5179 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5180 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5181 > rm -f conftest*
5182 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5183 > rm -f work*
5184 > cat >conftest.$ac_ext <<EOF
5185 >        module conftest
5186 >        integer n
5187 >        parameter (n=1)
5188 >        end module conftest
5189 > EOF
5190 > # SGI and absoft compilers generates module name in upper case!
5191 > testname="conftest"
5192 > if (eval $ac_compile) 2>/dev/null ; then
5193 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5194 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5195 >   if test -n "$mod" ; then
5196 >      testname="CONFTEST"
5197 >   fi
5198 >   madedir=0
5199 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5200 >   cp $testname.$MOD conf
5201 >   rm -f conftest* CONFTEST*
5202 >   cat >conftest1.$ac_ext <<EOF
5203 >        program main
5204 >        use conftest
5205 >        print *, n
5206 >        end
5207 > EOF
5208 >   F90_WORK_FILES_ARG=""
5209 >   F90MODINCSPEC=""
5210 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5211 >       MODDIRFLAG="-I"
5212 >       F90MODINCSPEC="-I<dir>"
5213 >       echo "$as_me:$LINENO: result: -I" >&5
5214 > echo "${ECHO_T}-I" >&6
5215 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5216 >       MODDIRFLAG="-M"
5217 >       F90MODINCSPEC="-M<dir>"
5218 >       echo "$as_me:$LINENO: result: -M" >&5
5219 > echo "${ECHO_T}-M" >&6
5220 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5221 >       MODDIRFLAG="-p"
5222 >       F90MODINCSPEC="-p<dir>"
5223 >       echo "$as_me:$LINENO: result: -p" >&5
5224 > echo "${ECHO_T}-p" >&6
5225 >   elif test -s work.pc ; then
5226 >        cp work.pc conf/mpimod.pc
5227 >        echo "mpimod.pc" > conf/mpimod.pcl
5228 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5229 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5230 >            MODDIRFLAG='-cl,mpimod.pcl'
5231 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5232 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5233 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5234 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5235 >
5236 >        else
5237 >            # The version of the Intel compiler that I have refuses to let
5238 >            # you put the "work catalog" list anywhere but the current
5239 >            # directory. For example, you cannot in
5240 >         :
5241 >        fi
5242 >   fi
5243 >   if test -z "MODDIRFLAG" ; then
5244 >       echo "$as_me:$LINENO: result: unknown" >&5
5245 > echo "${ECHO_T}unknown" >&6
5246 >   fi
5247 >
5248 >
5249 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5250 >   if test $madedir = 1 ; then rmdir conf ; fi
5251 > fi
5252 >
5253 >
5254 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5255 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5256 > if test "${ac_cv_f90_module_names+set}" = set; then
5257 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5258 > else
5259 >  ac_ext=${FC_SRCEXT-f}
5260 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5261 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5262 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5263 >
5264 > # carry out the test in a new directory, so that we don't miss anything
5265 > mkdir conftest
5266 > cd conftest
5267 > cat >conftest.$ac_ext <<_ACEOF
5268 > MODULE Bar
5269 > END MODULE Bar
5270 > _ACEOF
5271 > rm -f conftest.$ac_objext
5272 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5273 >  (eval $ac_compile) 2>conftest.er1
5274 >  ac_status=$?
5275 >  grep -v '^ *+' conftest.er1 >conftest.err
5276 >  rm -f conftest.er1
5277 >  cat conftest.err >&5
5278 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5279 >  (exit $ac_status); } &&
5280 >         { ac_try='test -z "$ac_fc_werror_flag"
5281 >                         || test ! -s conftest.err'
5282 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5283 >  (eval $ac_try) 2>&5
5284 >  ac_status=$?
5285 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5286 >  (exit $ac_status); }; } &&
5287 >         { ac_try='test -s conftest.$ac_objext'
5288 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5289 >  (eval $ac_try) 2>&5
5290 >  ac_status=$?
5291 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5292 >  (exit $ac_status); }; }; then
5293 >  ac_cv_f90_module_names=
5294 > ac_file_list=*
5295 > for ac_file in $ac_file_list; do
5296 >   case $ac_file in
5297 >      # don't care for original source and object files
5298 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5299 >          :
5300 >          ;;
5301 >      # look for new files derived from the file name
5302 >      *conftest*)
5303 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5304 >            ac_exists=false
5305 >  for ac_i in $ac_cv_f90_module_names; do
5306 >    if test x"$ac_pat" = x"$ac_i"; then
5307 >      ac_exists=true
5308 >      break
5309 >    fi
5310 >  done
5311 >
5312 >  if test x"$ac_exists" = xtrue; then
5313 >  :
5314 > else
5315 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5316 > fi
5317 >
5318 >          ;;
5319 >      # look for new files derived from the module name,
5320 >      # with different case translation schemes
5321 >      *Bar*)
5322 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5323 >            ac_exists=false
5324 >  for ac_i in $ac_cv_f90_module_names; do
5325 >    if test x"$ac_pat" = x"$ac_i"; then
5326 >      ac_exists=true
5327 >      break
5328 >    fi
5329 >  done
5330 >
5331 >  if test x"$ac_exists" = xtrue; then
5332 >  :
5333 > else
5334 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5335 > fi
5336 >
5337 >          ;;
5338 >      *bar*)
5339 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5340 >            ac_exists=false
5341 >  for ac_i in $ac_cv_f90_module_names; do
5342 >    if test x"$ac_pat" = x"$ac_i"; then
5343 >      ac_exists=true
5344 >      break
5345 >    fi
5346 >  done
5347 >
5348 >  if test x"$ac_exists" = xtrue; then
5349 >  :
5350 > else
5351 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5352 > fi
5353 >
5354 >          ;;
5355 >      *BAR*)
5356 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5357 >            ac_exists=false
5358 >  for ac_i in $ac_cv_f90_module_names; do
5359 >    if test x"$ac_pat" = x"$ac_i"; then
5360 >      ac_exists=true
5361 >      break
5362 >    fi
5363 >  done
5364 >
5365 >  if test x"$ac_exists" = xtrue; then
5366 >  :
5367 > else
5368 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5369 > fi
5370 >
5371 >          ;;
5372 >       # Other files - we have no idea how they are generated
5373 >       *)
5374 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5375 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5376 >          ;;
5377 >   esac
5378 > done
5379 > if test "x$ac_cv_f90_module_names" = "x"; then
5380 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5381 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5382 > fi
5383 >
5384 > else
5385 >  echo "$as_me: failed program was:" >&5
5386 > sed 's/^/| /' conftest.$ac_ext >&5
5387 >
5388 > ac_cv_f90_module_names=
5389 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5390 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5391 > fi
5392 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5393 > cd ..
5394 > # cleanup
5395 > rm -rf conftest
5396 > ac_ext=${FC_SRCEXT-f}
5397 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5398 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5399 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5400 >
5401 > fi
5402 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5403 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5404 >
5405 > # We now generate a shell script that will help us to figure out the correct
5406 > # module file names, using the value of ac_cv_f90_module_names
5407 >
5408 > echo "Generating shell script modnam"
5409 >
5410 > cat > scripts/modnam << EOF
5411 > #! /bin/sh
5412 > # This script is auto-generated by configure
5413 > #
5414 > usage="\\
5415 > Usage: \$0 [FILES]
5416 >
5417 > [FILES] are Fortran 90 source files.
5418 > The output is a list of module file names that the Fortran 90 compiler
5419 > generates when compiling [FILES]."
5420 >
5421 > list=
5422 > empty=
5423 >
5424 > if test \$# -eq 0; then
5425 >   echo "\$usage"; exit 0
5426 > fi
5427 >
5428 > while test \$# != 0; do
5429 >
5430 >  file=\$1
5431 >  shift
5432 >
5433 > # strip suffix
5434 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5435 >
5436 >  test ! -f \$file && continue
5437 >
5438 > # Look for module definitions and transform them to upper / lower case
5439 >  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
5440 >  upper=\`echo \$mods | tr a-z A-Z\`
5441 >  lower=\`echo \$mods | tr A-Z a-z\`
5442 >
5443 > # Here, the patterns for generating module file names were inserted by configure
5444 >  for trans in $ac_cv_f90_module_names; do
5445 >
5446 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5447 >    var=empty
5448 >    case \$pat in
5449 >       %MODULE%)
5450 >          var=upper ;;
5451 >       %Module%)
5452 >          var=mods ;;
5453 >       %module%)
5454 >          var=lower ;;
5455 >       %FILE%)
5456 >          test -n "\$mods" && var=base ;;
5457 >    esac
5458 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5459 >    list="\$list \$new"
5460 >  done
5461 > done
5462 >
5463 > echo \$list
5464 > # end of configure-generated script
5465 > EOF
5466 > chmod 755 scripts/modnam
5467 >
5468 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5469 > F90_MODULE_NAMES=empty
5470 > case $pat in
5471 >       %MODULE%)
5472 >          F90_MODULE_NAMES=UPPER ;;
5473 >       %Module%)
5474 >          F90_MODULE_NAMES=Mixed ;;
5475 >       %module%)
5476 >          F90_MODULE_NAMES=lower ;;
5477 >       *)
5478 >          F90_MODULE_NAMES=unknown ;;
5479 > esac
5480 >
5481 > ac_ext=c
5482 > ac_cpp='$CPP $CPPFLAGS'
5483 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5484 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5485 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5486 >
5487 >
5488 > ac_ext=c
5489 > ac_cpp='$CPP $CPPFLAGS'
5490 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5491 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5492 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5493 >
5494 >
5495 >
5496 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5497 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5498 > if test "${ac_cv_lib_m_asin+set}" = set; then
5499 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5500 > else
5501 >  ac_check_lib_save_LIBS=$LIBS
5502 > LIBS="-lm  $LIBS"
5503 > cat >conftest.$ac_ext <<_ACEOF
5504 > /* confdefs.h.  */
5505 > _ACEOF
5506 > cat confdefs.h >>conftest.$ac_ext
5507 > cat >>conftest.$ac_ext <<_ACEOF
5508 > /* end confdefs.h.  */
5509 >
5510 > /* Override any gcc2 internal prototype to avoid an error.  */
5511 > #ifdef __cplusplus
5512 > extern "C"
5513 > #endif
5514 > /* We use char because int might match the return type of a gcc2
5515 >   builtin and then its argument prototype would still apply.  */
5516 > char asin ();
5517 > #ifdef FC_DUMMY_MAIN
5518 > #ifndef FC_DUMMY_MAIN_EQ_F77
5519 > #  ifdef __cplusplus
5520 >     extern "C"
5521 > #  endif
5522 >   int FC_DUMMY_MAIN() { return 1; }
5523 > #endif
5524 > #endif
5525 > int
5526 > main ()
5527 > {
5528 > asin ();
5529 >  ;
5530 >  return 0;
5531 > }
5532 > _ACEOF
5533 > rm -f conftest.$ac_objext conftest$ac_exeext
5534 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5535 >  (eval $ac_link) 2>conftest.er1
5536 >  ac_status=$?
5537 >  grep -v '^ *+' conftest.er1 >conftest.err
5538 >  rm -f conftest.er1
5539 >  cat conftest.err >&5
5540 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5541 >  (exit $ac_status); } &&
5542 >         { ac_try='test -z "$ac_c_werror_flag"
5543 >                         || test ! -s conftest.err'
5544 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5545 >  (eval $ac_try) 2>&5
5546 >  ac_status=$?
5547 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5548 >  (exit $ac_status); }; } &&
5549 >         { ac_try='test -s conftest$ac_exeext'
5550 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5551 >  (eval $ac_try) 2>&5
5552 >  ac_status=$?
5553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554 >  (exit $ac_status); }; }; then
5555 >  ac_cv_lib_m_asin=yes
5556 > else
5557 >  echo "$as_me: failed program was:" >&5
5558 > sed 's/^/| /' conftest.$ac_ext >&5
5559 >
5560 > ac_cv_lib_m_asin=no
5561 > fi
5562 > rm -f conftest.err conftest.$ac_objext \
5563 >      conftest$ac_exeext conftest.$ac_ext
5564 > LIBS=$ac_check_lib_save_LIBS
5565 > fi
5566 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5567 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5568 > if test $ac_cv_lib_m_asin = yes; then
5569 >  cat >>confdefs.h <<_ACEOF
5570 > #define HAVE_LIBM 1
5571 > _ACEOF
5572 >
5573 >  LIBS="-lm $LIBS"
5574 >
5575 > else
5576 >  exit
5577 > fi
5578 >
5579 >
5580 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5581 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5582 > if test "${ac_cv_header_stdc+set}" = set; then
5583 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5584 > else
5585 >  cat >conftest.$ac_ext <<_ACEOF
5586 > /* confdefs.h.  */
5587 > _ACEOF
5588 > cat confdefs.h >>conftest.$ac_ext
5589 > cat >>conftest.$ac_ext <<_ACEOF
5590 > /* end confdefs.h.  */
5591 > #include <stdlib.h>
5592 > #include <stdarg.h>
5593 > #include <string.h>
5594 > #include <float.h>
5595 >
5596 > #ifdef FC_DUMMY_MAIN
5597 > #ifndef FC_DUMMY_MAIN_EQ_F77
5598 > #  ifdef __cplusplus
5599 >     extern "C"
5600 > #  endif
5601 >   int FC_DUMMY_MAIN() { return 1; }
5602 > #endif
5603 > #endif
5604 > int
5605 > main ()
5606 > {
5607 >
5608 >  ;
5609 >  return 0;
5610 > }
5611 > _ACEOF
5612 > rm -f conftest.$ac_objext
5613 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5614 >  (eval $ac_compile) 2>conftest.er1
5615 >  ac_status=$?
5616 >  grep -v '^ *+' conftest.er1 >conftest.err
5617 >  rm -f conftest.er1
5618 >  cat conftest.err >&5
5619 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5620 >  (exit $ac_status); } &&
5621 >         { ac_try='test -z "$ac_c_werror_flag"
5622 >                         || test ! -s conftest.err'
5623 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5624 >  (eval $ac_try) 2>&5
5625 >  ac_status=$?
5626 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5627 >  (exit $ac_status); }; } &&
5628 >         { ac_try='test -s conftest.$ac_objext'
5629 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5630 >  (eval $ac_try) 2>&5
5631 >  ac_status=$?
5632 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5633 >  (exit $ac_status); }; }; then
5634 >  ac_cv_header_stdc=yes
5635 > else
5636 >  echo "$as_me: failed program was:" >&5
5637 > sed 's/^/| /' conftest.$ac_ext >&5
5638 >
5639 > ac_cv_header_stdc=no
5640 > fi
5641 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5642 >
5643 > if test $ac_cv_header_stdc = yes; then
5644 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5645 >  cat >conftest.$ac_ext <<_ACEOF
5646 > /* confdefs.h.  */
5647 > _ACEOF
5648 > cat confdefs.h >>conftest.$ac_ext
5649 > cat >>conftest.$ac_ext <<_ACEOF
5650 > /* end confdefs.h.  */
5651 > #include <string.h>
5652 >
5653 > _ACEOF
5654 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5655 >  $EGREP "memchr" >/dev/null 2>&1; then
5656 >  :
5657 > else
5658 >  ac_cv_header_stdc=no
5659 > fi
5660 > rm -f conftest*
5661 >
5662 > fi
5663 >
5664 > if test $ac_cv_header_stdc = yes; then
5665 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5666 >  cat >conftest.$ac_ext <<_ACEOF
5667 > /* confdefs.h.  */
5668 > _ACEOF
5669 > cat confdefs.h >>conftest.$ac_ext
5670 > cat >>conftest.$ac_ext <<_ACEOF
5671 > /* end confdefs.h.  */
5672 > #include <stdlib.h>
5673 >
5674 > _ACEOF
5675 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5676 >  $EGREP "free" >/dev/null 2>&1; then
5677 >  :
5678 > else
5679 >  ac_cv_header_stdc=no
5680 > fi
5681 > rm -f conftest*
5682 >
5683 > fi
5684 >
5685 > if test $ac_cv_header_stdc = yes; then
5686 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5687 >  if test "$cross_compiling" = yes; then
5688 >  :
5689 > else
5690 >  cat >conftest.$ac_ext <<_ACEOF
5691 > /* confdefs.h.  */
5692 > _ACEOF
5693 > cat confdefs.h >>conftest.$ac_ext
5694 > cat >>conftest.$ac_ext <<_ACEOF
5695 > /* end confdefs.h.  */
5696 > #include <ctype.h>
5697 > #if ((' ' & 0x0FF) == 0x020)
5698 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5699 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5700 > #else
5701 > # define ISLOWER(c) \
5702 >                   (('a' <= (c) && (c) <= 'i') \
5703 >                     || ('j' <= (c) && (c) <= 'r') \
5704 >                     || ('s' <= (c) && (c) <= 'z'))
5705 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5706 > #endif
5707 >
5708 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5709 > int
5710 > main ()
5711 > {
5712 >  int i;
5713 >  for (i = 0; i < 256; i++)
5714 >    if (XOR (islower (i), ISLOWER (i))
5715 >        || toupper (i) != TOUPPER (i))
5716 >      exit(2);
5717 >  exit (0);
5718 > }
5719 > _ACEOF
5720 > rm -f conftest$ac_exeext
5721 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5722 >  (eval $ac_link) 2>&5
5723 >  ac_status=$?
5724 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5726 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5727 >  (eval $ac_try) 2>&5
5728 >  ac_status=$?
5729 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5730 >  (exit $ac_status); }; }; then
5731 >  :
5732 > else
5733 >  echo "$as_me: program exited with status $ac_status" >&5
5734 > echo "$as_me: failed program was:" >&5
5735 > sed 's/^/| /' conftest.$ac_ext >&5
5736 >
5737 > ( exit $ac_status )
5738 > ac_cv_header_stdc=no
5739 > fi
5740 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5741 > fi
5742 > fi
5743 > fi
5744 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5745 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5746 > if test $ac_cv_header_stdc = yes; then
5747 >
5748 > cat >>confdefs.h <<\_ACEOF
5749 > #define STDC_HEADERS 1
5750 > _ACEOF
5751 >
5752 > fi
5753 >
5754 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5755 >
5756 >
5757 >
5758 >
5759 >
5760 >
5761 >
5762 >
5763 >
5764 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5765 >                  inttypes.h stdint.h unistd.h
5766 > do
5767 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5768 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5769 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5770 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5771 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5772 > else
5773 >  cat >conftest.$ac_ext <<_ACEOF
5774 > /* confdefs.h.  */
5775 > _ACEOF
5776 > cat confdefs.h >>conftest.$ac_ext
5777 > cat >>conftest.$ac_ext <<_ACEOF
5778 > /* end confdefs.h.  */
5779 > $ac_includes_default
5780 >
5781 > #include <$ac_header>
5782 > _ACEOF
5783 > rm -f conftest.$ac_objext
5784 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5785 >  (eval $ac_compile) 2>conftest.er1
5786 >  ac_status=$?
5787 >  grep -v '^ *+' conftest.er1 >conftest.err
5788 >  rm -f conftest.er1
5789 >  cat conftest.err >&5
5790 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5791 >  (exit $ac_status); } &&
5792 >         { ac_try='test -z "$ac_c_werror_flag"
5793 >                         || test ! -s conftest.err'
5794 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5795 >  (eval $ac_try) 2>&5
5796 >  ac_status=$?
5797 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5798 >  (exit $ac_status); }; } &&
5799 >         { ac_try='test -s conftest.$ac_objext'
5800 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5801 >  (eval $ac_try) 2>&5
5802 >  ac_status=$?
5803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5804 >  (exit $ac_status); }; }; then
5805 >  eval "$as_ac_Header=yes"
5806 > else
5807 >  echo "$as_me: failed program was:" >&5
5808 > sed 's/^/| /' conftest.$ac_ext >&5
5809 >
5810 > eval "$as_ac_Header=no"
5811 > fi
5812 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5813 > fi
5814 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5815 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5816 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5817 >  cat >>confdefs.h <<_ACEOF
5818 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5819 > _ACEOF
5820 >
5821 > fi
5822 >
5823 > done
5824 >
5825 >
5826 > #
5827 > # Handle user hints
5828 > #
5829 >
5830 > # Check whether --with-zlib or --without-zlib was given.
5831 > if test "${with_zlib+set}" = set; then
5832 >  withval="$with_zlib"
5833 >  zlib_dir="$withval"
5834 > else
5835 >                zlib_dir="not_set"
5836 > fi;
5837 > if test "$zlib_dir" != "no"; then
5838 >
5839 > if test "$zlib_dir" != "not_set" ; then
5840 >  if test -d "$zlib_dir"
5841 >  then
5842 >    ZLIB_HOME="$zlib_dir"
5843 >  else
5844 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5845 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5846 >  fi
5847 > fi
5848 >
5849 > ZLIB_HOME=/usr/local
5850 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5851 > then
5852 >        ZLIB_HOME=/usr
5853 > fi
5854 >
5855 > #
5856 > # Locate zlib, if wanted
5857 > #
5858 > if test -n "${ZLIB_HOME}"
5859 > then
5860 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5861 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5862 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5863 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5864 >
5865 >
5866 >        ac_ext=c
5867 > ac_cpp='$CPP $CPPFLAGS'
5868 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5869 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5870 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5871 >
5872 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5873 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5874 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5875 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5876 > else
5877 >  ac_check_lib_save_LIBS=$LIBS
5878 > LIBS="-lz  $LIBS"
5879 > cat >conftest.$ac_ext <<_ACEOF
5880 > /* confdefs.h.  */
5881 > _ACEOF
5882 > cat confdefs.h >>conftest.$ac_ext
5883 > cat >>conftest.$ac_ext <<_ACEOF
5884 > /* end confdefs.h.  */
5885 >
5886 > /* Override any gcc2 internal prototype to avoid an error.  */
5887 > #ifdef __cplusplus
5888 > extern "C"
5889 > #endif
5890 > /* We use char because int might match the return type of a gcc2
5891 >   builtin and then its argument prototype would still apply.  */
5892 > char inflateEnd ();
5893 > #ifdef FC_DUMMY_MAIN
5894 > #ifndef FC_DUMMY_MAIN_EQ_F77
5895 > #  ifdef __cplusplus
5896 >     extern "C"
5897 > #  endif
5898 >   int FC_DUMMY_MAIN() { return 1; }
5899 > #endif
5900 > #endif
5901 > int
5902 > main ()
5903 > {
5904 > inflateEnd ();
5905 >  ;
5906 >  return 0;
5907 > }
5908 > _ACEOF
5909 > rm -f conftest.$ac_objext conftest$ac_exeext
5910 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5911 >  (eval $ac_link) 2>conftest.er1
5912 >  ac_status=$?
5913 >  grep -v '^ *+' conftest.er1 >conftest.err
5914 >  rm -f conftest.er1
5915 >  cat conftest.err >&5
5916 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5917 >  (exit $ac_status); } &&
5918 >         { ac_try='test -z "$ac_c_werror_flag"
5919 >                         || test ! -s conftest.err'
5920 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5921 >  (eval $ac_try) 2>&5
5922 >  ac_status=$?
5923 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5924 >  (exit $ac_status); }; } &&
5925 >         { ac_try='test -s conftest$ac_exeext'
5926 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5927 >  (eval $ac_try) 2>&5
5928 >  ac_status=$?
5929 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5930 >  (exit $ac_status); }; }; then
5931 >  ac_cv_lib_z_inflateEnd=yes
5932 > else
5933 >  echo "$as_me: failed program was:" >&5
5934 > sed 's/^/| /' conftest.$ac_ext >&5
5935 >
5936 > ac_cv_lib_z_inflateEnd=no
5937 > fi
5938 > rm -f conftest.err conftest.$ac_objext \
5939 >      conftest$ac_exeext conftest.$ac_ext
5940 > LIBS=$ac_check_lib_save_LIBS
5941 > fi
5942 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5943 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5944 > if test $ac_cv_lib_z_inflateEnd = yes; then
5945 >  zlib_cv_libz=yes
5946 > else
5947 >  zlib_cv_libz=no
5948 > fi
5949 >
5950 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5951 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5952 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5953 > if test "${ac_cv_header_zlib_h+set}" = set; then
5954 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5955 > fi
5956 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5957 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5958 > else
5959 >  # Is the header compilable?
5960 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5961 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5962 > cat >conftest.$ac_ext <<_ACEOF
5963 > /* confdefs.h.  */
5964 > _ACEOF
5965 > cat confdefs.h >>conftest.$ac_ext
5966 > cat >>conftest.$ac_ext <<_ACEOF
5967 > /* end confdefs.h.  */
5968 > $ac_includes_default
5969 > #include <zlib.h>
5970 > _ACEOF
5971 > rm -f conftest.$ac_objext
5972 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5973 >  (eval $ac_compile) 2>conftest.er1
5974 >  ac_status=$?
5975 >  grep -v '^ *+' conftest.er1 >conftest.err
5976 >  rm -f conftest.er1
5977 >  cat conftest.err >&5
5978 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5979 >  (exit $ac_status); } &&
5980 >         { ac_try='test -z "$ac_c_werror_flag"
5981 >                         || test ! -s conftest.err'
5982 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5983 >  (eval $ac_try) 2>&5
5984 >  ac_status=$?
5985 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5986 >  (exit $ac_status); }; } &&
5987 >         { ac_try='test -s conftest.$ac_objext'
5988 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5989 >  (eval $ac_try) 2>&5
5990 >  ac_status=$?
5991 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5992 >  (exit $ac_status); }; }; then
5993 >  ac_header_compiler=yes
5994 > else
5995 >  echo "$as_me: failed program was:" >&5
5996 > sed 's/^/| /' conftest.$ac_ext >&5
5997 >
5998 > ac_header_compiler=no
5999 > fi
6000 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6001 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6002 > echo "${ECHO_T}$ac_header_compiler" >&6
6003 >
6004 > # Is the header present?
6005 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
6006 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6007 > cat >conftest.$ac_ext <<_ACEOF
6008 > /* confdefs.h.  */
6009 > _ACEOF
6010 > cat confdefs.h >>conftest.$ac_ext
6011 > cat >>conftest.$ac_ext <<_ACEOF
6012 > /* end confdefs.h.  */
6013 > #include <zlib.h>
6014 > _ACEOF
6015 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6016 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6017 >  ac_status=$?
6018 >  grep -v '^ *+' conftest.er1 >conftest.err
6019 >  rm -f conftest.er1
6020 >  cat conftest.err >&5
6021 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6022 >  (exit $ac_status); } >/dev/null; then
6023 >  if test -s conftest.err; then
6024 >    ac_cpp_err=$ac_c_preproc_warn_flag
6025 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6026 >  else
6027 >    ac_cpp_err=
6028 >  fi
6029 > else
6030 >  ac_cpp_err=yes
6031 > fi
6032 > if test -z "$ac_cpp_err"; then
6033 >  ac_header_preproc=yes
6034 > else
6035 >  echo "$as_me: failed program was:" >&5
6036 > sed 's/^/| /' conftest.$ac_ext >&5
6037 >
6038 >  ac_header_preproc=no
6039 > fi
6040 > rm -f conftest.err conftest.$ac_ext
6041 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6042 > echo "${ECHO_T}$ac_header_preproc" >&6
6043 >
6044 > # So?  What about this header?
6045 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6046 >  yes:no: )
6047 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6048 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6049 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6050 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6051 >    ac_header_preproc=yes
6052 >    ;;
6053 >  no:yes:* )
6054 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6055 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6056 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6057 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6058 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6059 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6060 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6061 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6062 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6063 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6064 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6065 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6066 >    (
6067 >      cat <<\_ASBOX
6068 > ## ------------------------------ ##
6069 > ## Report this to gezelter@nd.edu ##
6070 > ## ------------------------------ ##
6071 > _ASBOX
6072 >    ) |
6073 >      sed "s/^/$as_me: WARNING:     /" >&2
6074 >    ;;
6075 > esac
6076 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6077 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6078 > if test "${ac_cv_header_zlib_h+set}" = set; then
6079 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6080 > else
6081 >  ac_cv_header_zlib_h=$ac_header_preproc
6082 > fi
6083 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6084 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6085 >
6086 > fi
6087 > if test $ac_cv_header_zlib_h = yes; then
6088 >  zlib_cv_zlib_h=yes
6089 > else
6090 >  zlib_cv_zlib_h=no
6091 > fi
6092 >
6093 >
6094 >        ac_ext=c
6095 > ac_cpp='$CPP $CPPFLAGS'
6096 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6097 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6098 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6099 >
6100 >
6101 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6102 >
6103 > cat >>confdefs.h <<\_ACEOF
6104 > #define HAVE_ZLIB_H 1
6105 > _ACEOF
6106 >
6107 >
6108 > cat >>confdefs.h <<\_ACEOF
6109 > #define HAVE_LIBZ 1
6110 > _ACEOF
6111 >
6112 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6113 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6114 >                ZLIB="-lz"
6115 >        else
6116 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6117 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6118 >                ZLIB_INC_DIR=
6119 >                ZLIB_LIB_DIR=
6120 >                ZLIB=
6121 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6122 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6123 >                echo "$as_me:$LINENO: result: failed" >&5
6124 > echo "${ECHO_T}failed" >&6
6125 >                echo ""
6126 >                echo "*********************************************************"
6127 >                echo "* WARNING: Could not find a working zlib installation   *"
6128 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6129 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6130 >                echo "* installation with --with-zlib=DIR                     *"
6131 >                echo "*                                                       *"
6132 >                echo "* OOPSE will still work without zlib installed.         *"
6133 >                echo "*********************************************************"
6134 >                echo ""
6135 >        fi
6136 >
6137 >
6138 >
6139 > fi
6140 > fi
6141 >
6142 > #
6143 > # Handle user hints
6144 > #
6145 >
6146 > # Check whether --with-fftw or --without-fftw was given.
6147 > if test "${with_fftw+set}" = set; then
6148 >  withval="$with_fftw"
6149 >  fftw_dir="$withval"
6150 > else
6151 >                fftw_dir="not_set"
6152 > fi;
6153 > if test "$fftw_dir" != "no"; then
6154 >
6155 > if test "$fftw_dir" != "not_set" ; then
6156 >  if test -d "$fftw_dir"
6157 >  then
6158 >    FFTW_HOME="$fftw_dir"
6159 >  else
6160 >    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6161 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6162 >  fi
6163 > fi
6164 >
6165 > FFTW_HOME=/usr/local
6166 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6167 > then
6168 >        FFTW_HOME=/usr
6169 > fi
6170 >
6171 > #
6172 > # Locate fftw, if wanted
6173 > #
6174 > if test -n "${FFTW_HOME}"
6175 > then
6176 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6177 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6178 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6179 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6180 >
6181 >
6182 >        ac_ext=c
6183 > ac_cpp='$CPP $CPPFLAGS'
6184 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6185 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6186 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6187 >
6188 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6189 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6190 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6191 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6192 > else
6193 >  ac_check_lib_save_LIBS=$LIBS
6194 > LIBS="-lfftw3  $LIBS"
6195 > cat >conftest.$ac_ext <<_ACEOF
6196 > /* confdefs.h.  */
6197 > _ACEOF
6198 > cat confdefs.h >>conftest.$ac_ext
6199 > cat >>conftest.$ac_ext <<_ACEOF
6200 > /* end confdefs.h.  */
6201 >
6202 > /* Override any gcc2 internal prototype to avoid an error.  */
6203 > #ifdef __cplusplus
6204 > extern "C"
6205 > #endif
6206 > /* We use char because int might match the return type of a gcc2
6207 >   builtin and then its argument prototype would still apply.  */
6208 > char fftw_execute ();
6209 > #ifdef FC_DUMMY_MAIN
6210 > #ifndef FC_DUMMY_MAIN_EQ_F77
6211 > #  ifdef __cplusplus
6212 >     extern "C"
6213 > #  endif
6214 >   int FC_DUMMY_MAIN() { return 1; }
6215 > #endif
6216 > #endif
6217 > int
6218 > main ()
6219 > {
6220 > fftw_execute ();
6221 >  ;
6222 >  return 0;
6223 > }
6224 > _ACEOF
6225 > rm -f conftest.$ac_objext conftest$ac_exeext
6226 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6227 >  (eval $ac_link) 2>conftest.er1
6228 >  ac_status=$?
6229 >  grep -v '^ *+' conftest.er1 >conftest.err
6230 >  rm -f conftest.er1
6231 >  cat conftest.err >&5
6232 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6233 >  (exit $ac_status); } &&
6234 >         { ac_try='test -z "$ac_c_werror_flag"
6235 >                         || test ! -s conftest.err'
6236 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6237 >  (eval $ac_try) 2>&5
6238 >  ac_status=$?
6239 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6240 >  (exit $ac_status); }; } &&
6241 >         { ac_try='test -s conftest$ac_exeext'
6242 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6243 >  (eval $ac_try) 2>&5
6244 >  ac_status=$?
6245 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6246 >  (exit $ac_status); }; }; then
6247 >  ac_cv_lib_fftw3_fftw_execute=yes
6248 > else
6249 >  echo "$as_me: failed program was:" >&5
6250 > sed 's/^/| /' conftest.$ac_ext >&5
6251 >
6252 > ac_cv_lib_fftw3_fftw_execute=no
6253 > fi
6254 > rm -f conftest.err conftest.$ac_objext \
6255 >      conftest$ac_exeext conftest.$ac_ext
6256 > LIBS=$ac_check_lib_save_LIBS
6257 > fi
6258 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6259 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6260 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6261 >  fftw_cv_libfftw3=yes
6262 > else
6263 >  fftw_cv_libfftw3=no
6264 > fi
6265 >
6266 >        if test "${ac_cv_header_fftw3_h+set}" = set; then
6267 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6268 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6269 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6270 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6271 > fi
6272 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6273 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6274 > else
6275 >  # Is the header compilable?
6276 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6277 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6278 > cat >conftest.$ac_ext <<_ACEOF
6279 > /* confdefs.h.  */
6280 > _ACEOF
6281 > cat confdefs.h >>conftest.$ac_ext
6282 > cat >>conftest.$ac_ext <<_ACEOF
6283 > /* end confdefs.h.  */
6284 > $ac_includes_default
6285 > #include <fftw3.h>
6286 > _ACEOF
6287 > rm -f conftest.$ac_objext
6288 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6289 >  (eval $ac_compile) 2>conftest.er1
6290 >  ac_status=$?
6291 >  grep -v '^ *+' conftest.er1 >conftest.err
6292 >  rm -f conftest.er1
6293 >  cat conftest.err >&5
6294 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6295 >  (exit $ac_status); } &&
6296 >         { ac_try='test -z "$ac_c_werror_flag"
6297 >                         || test ! -s conftest.err'
6298 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6299 >  (eval $ac_try) 2>&5
6300 >  ac_status=$?
6301 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6302 >  (exit $ac_status); }; } &&
6303 >         { ac_try='test -s conftest.$ac_objext'
6304 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6305 >  (eval $ac_try) 2>&5
6306 >  ac_status=$?
6307 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6308 >  (exit $ac_status); }; }; then
6309 >  ac_header_compiler=yes
6310 > else
6311 >  echo "$as_me: failed program was:" >&5
6312 > sed 's/^/| /' conftest.$ac_ext >&5
6313 >
6314 > ac_header_compiler=no
6315 > fi
6316 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6317 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6318 > echo "${ECHO_T}$ac_header_compiler" >&6
6319 >
6320 > # Is the header present?
6321 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6322 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6323 > cat >conftest.$ac_ext <<_ACEOF
6324 > /* confdefs.h.  */
6325 > _ACEOF
6326 > cat confdefs.h >>conftest.$ac_ext
6327 > cat >>conftest.$ac_ext <<_ACEOF
6328 > /* end confdefs.h.  */
6329 > #include <fftw3.h>
6330 > _ACEOF
6331 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6332 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6333 >  ac_status=$?
6334 >  grep -v '^ *+' conftest.er1 >conftest.err
6335 >  rm -f conftest.er1
6336 >  cat conftest.err >&5
6337 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6338 >  (exit $ac_status); } >/dev/null; then
6339 >  if test -s conftest.err; then
6340 >    ac_cpp_err=$ac_c_preproc_warn_flag
6341 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6342 >  else
6343 >    ac_cpp_err=
6344 >  fi
6345 > else
6346 >  ac_cpp_err=yes
6347 > fi
6348 > if test -z "$ac_cpp_err"; then
6349 >  ac_header_preproc=yes
6350 > else
6351 >  echo "$as_me: failed program was:" >&5
6352 > sed 's/^/| /' conftest.$ac_ext >&5
6353 >
6354 >  ac_header_preproc=no
6355 > fi
6356 > rm -f conftest.err conftest.$ac_ext
6357 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6358 > echo "${ECHO_T}$ac_header_preproc" >&6
6359 >
6360 > # So?  What about this header?
6361 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6362 >  yes:no: )
6363 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6364 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6365 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6366 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6367 >    ac_header_preproc=yes
6368 >    ;;
6369 >  no:yes:* )
6370 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6371 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6372 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6373 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6374 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6375 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6376 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6377 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6378 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6379 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6380 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6381 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6382 >    (
6383 >      cat <<\_ASBOX
6384 > ## ------------------------------ ##
6385 > ## Report this to gezelter@nd.edu ##
6386 > ## ------------------------------ ##
6387 > _ASBOX
6388 >    ) |
6389 >      sed "s/^/$as_me: WARNING:     /" >&2
6390 >    ;;
6391 > esac
6392 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6393 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6394 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6395 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6396 > else
6397 >  ac_cv_header_fftw3_h=$ac_header_preproc
6398 > fi
6399 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6400 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6401 >
6402 > fi
6403 > if test $ac_cv_header_fftw3_h = yes; then
6404 >  fftw_cv_fftw3_h=yes
6405 > else
6406 >  fftw_cv_fftw3_h=no
6407 > fi
6408 >
6409 >
6410 >        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6411 >        then
6412 >                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6413 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6414 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6415 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6416 > else
6417 >  ac_check_lib_save_LIBS=$LIBS
6418 > LIBS="-lfftw  $LIBS"
6419 > cat >conftest.$ac_ext <<_ACEOF
6420 > /* confdefs.h.  */
6421 > _ACEOF
6422 > cat confdefs.h >>conftest.$ac_ext
6423 > cat >>conftest.$ac_ext <<_ACEOF
6424 > /* end confdefs.h.  */
6425 >
6426 > /* Override any gcc2 internal prototype to avoid an error.  */
6427 > #ifdef __cplusplus
6428 > extern "C"
6429 > #endif
6430 > /* We use char because int might match the return type of a gcc2
6431 >   builtin and then its argument prototype would still apply.  */
6432 > char fftwnd_one ();
6433 > #ifdef FC_DUMMY_MAIN
6434 > #ifndef FC_DUMMY_MAIN_EQ_F77
6435 > #  ifdef __cplusplus
6436 >     extern "C"
6437 > #  endif
6438 >   int FC_DUMMY_MAIN() { return 1; }
6439 > #endif
6440 > #endif
6441 > int
6442 > main ()
6443 > {
6444 > fftwnd_one ();
6445 >  ;
6446 >  return 0;
6447 > }
6448 > _ACEOF
6449 > rm -f conftest.$ac_objext conftest$ac_exeext
6450 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6451 >  (eval $ac_link) 2>conftest.er1
6452 >  ac_status=$?
6453 >  grep -v '^ *+' conftest.er1 >conftest.err
6454 >  rm -f conftest.er1
6455 >  cat conftest.err >&5
6456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6457 >  (exit $ac_status); } &&
6458 >         { ac_try='test -z "$ac_c_werror_flag"
6459 >                         || test ! -s conftest.err'
6460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6461 >  (eval $ac_try) 2>&5
6462 >  ac_status=$?
6463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6464 >  (exit $ac_status); }; } &&
6465 >         { ac_try='test -s conftest$ac_exeext'
6466 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6467 >  (eval $ac_try) 2>&5
6468 >  ac_status=$?
6469 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6470 >  (exit $ac_status); }; }; then
6471 >  ac_cv_lib_fftw_fftwnd_one=yes
6472 > else
6473 >  echo "$as_me: failed program was:" >&5
6474 > sed 's/^/| /' conftest.$ac_ext >&5
6475 >
6476 > ac_cv_lib_fftw_fftwnd_one=no
6477 > fi
6478 > rm -f conftest.err conftest.$ac_objext \
6479 >      conftest$ac_exeext conftest.$ac_ext
6480 > LIBS=$ac_check_lib_save_LIBS
6481 > fi
6482 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6483 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6484 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6485 >  fftw_cv_libfftw=yes
6486 > else
6487 >  fftw_cv_libfftw=no
6488 > fi
6489 >
6490 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6491 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6492 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6493 > if test "${ac_cv_header_fftw_h+set}" = set; then
6494 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6495 > fi
6496 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6497 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6498 > else
6499 >  # Is the header compilable?
6500 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6501 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6502 > cat >conftest.$ac_ext <<_ACEOF
6503 > /* confdefs.h.  */
6504 > _ACEOF
6505 > cat confdefs.h >>conftest.$ac_ext
6506 > cat >>conftest.$ac_ext <<_ACEOF
6507 > /* end confdefs.h.  */
6508 > $ac_includes_default
6509 > #include <fftw.h>
6510 > _ACEOF
6511 > rm -f conftest.$ac_objext
6512 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6513 >  (eval $ac_compile) 2>conftest.er1
6514 >  ac_status=$?
6515 >  grep -v '^ *+' conftest.er1 >conftest.err
6516 >  rm -f conftest.er1
6517 >  cat conftest.err >&5
6518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519 >  (exit $ac_status); } &&
6520 >         { ac_try='test -z "$ac_c_werror_flag"
6521 >                         || test ! -s conftest.err'
6522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6523 >  (eval $ac_try) 2>&5
6524 >  ac_status=$?
6525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6526 >  (exit $ac_status); }; } &&
6527 >         { ac_try='test -s conftest.$ac_objext'
6528 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6529 >  (eval $ac_try) 2>&5
6530 >  ac_status=$?
6531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6532 >  (exit $ac_status); }; }; then
6533 >  ac_header_compiler=yes
6534 > else
6535 >  echo "$as_me: failed program was:" >&5
6536 > sed 's/^/| /' conftest.$ac_ext >&5
6537 >
6538 > ac_header_compiler=no
6539 > fi
6540 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6541 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6542 > echo "${ECHO_T}$ac_header_compiler" >&6
6543 >
6544 > # Is the header present?
6545 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6546 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6547 > cat >conftest.$ac_ext <<_ACEOF
6548 > /* confdefs.h.  */
6549 > _ACEOF
6550 > cat confdefs.h >>conftest.$ac_ext
6551 > cat >>conftest.$ac_ext <<_ACEOF
6552 > /* end confdefs.h.  */
6553 > #include <fftw.h>
6554 > _ACEOF
6555 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6556 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6557 >  ac_status=$?
6558 >  grep -v '^ *+' conftest.er1 >conftest.err
6559 >  rm -f conftest.er1
6560 >  cat conftest.err >&5
6561 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6562 >  (exit $ac_status); } >/dev/null; then
6563 >  if test -s conftest.err; then
6564 >    ac_cpp_err=$ac_c_preproc_warn_flag
6565 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6566 >  else
6567 >    ac_cpp_err=
6568 >  fi
6569 > else
6570 >  ac_cpp_err=yes
6571 > fi
6572 > if test -z "$ac_cpp_err"; then
6573 >  ac_header_preproc=yes
6574 > else
6575 >  echo "$as_me: failed program was:" >&5
6576 > sed 's/^/| /' conftest.$ac_ext >&5
6577 >
6578 >  ac_header_preproc=no
6579 > fi
6580 > rm -f conftest.err conftest.$ac_ext
6581 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6582 > echo "${ECHO_T}$ac_header_preproc" >&6
6583 >
6584 > # So?  What about this header?
6585 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6586 >  yes:no: )
6587 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6588 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6589 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6590 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6591 >    ac_header_preproc=yes
6592 >    ;;
6593 >  no:yes:* )
6594 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6595 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6596 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6597 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6598 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6599 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6600 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6601 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6602 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6603 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6604 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6605 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6606 >    (
6607 >      cat <<\_ASBOX
6608 > ## ------------------------------ ##
6609 > ## Report this to gezelter@nd.edu ##
6610 > ## ------------------------------ ##
6611 > _ASBOX
6612 >    ) |
6613 >      sed "s/^/$as_me: WARNING:     /" >&2
6614 >    ;;
6615 > esac
6616 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6617 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6618 > if test "${ac_cv_header_fftw_h+set}" = set; then
6619 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6620 > else
6621 >  ac_cv_header_fftw_h=$ac_header_preproc
6622 > fi
6623 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6624 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6625 >
6626 > fi
6627 > if test $ac_cv_header_fftw_h = yes; then
6628 >  fftw_cv_fftw_h=yes
6629 > else
6630 >  fftw_cv_fftw_h=no
6631 > fi
6632 >
6633 >
6634 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6635 >                then
6636 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6637 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6638 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6639 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6640 > else
6641 >  ac_check_lib_save_LIBS=$LIBS
6642 > LIBS="-ldfftw  $LIBS"
6643 > cat >conftest.$ac_ext <<_ACEOF
6644 > /* confdefs.h.  */
6645 > _ACEOF
6646 > cat confdefs.h >>conftest.$ac_ext
6647 > cat >>conftest.$ac_ext <<_ACEOF
6648 > /* end confdefs.h.  */
6649 >
6650 > /* Override any gcc2 internal prototype to avoid an error.  */
6651 > #ifdef __cplusplus
6652 > extern "C"
6653 > #endif
6654 > /* We use char because int might match the return type of a gcc2
6655 >   builtin and then its argument prototype would still apply.  */
6656 > char fftwnd_one ();
6657 > #ifdef FC_DUMMY_MAIN
6658 > #ifndef FC_DUMMY_MAIN_EQ_F77
6659 > #  ifdef __cplusplus
6660 >     extern "C"
6661 > #  endif
6662 >   int FC_DUMMY_MAIN() { return 1; }
6663 > #endif
6664 > #endif
6665 > int
6666 > main ()
6667 > {
6668 > fftwnd_one ();
6669 >  ;
6670 >  return 0;
6671 > }
6672 > _ACEOF
6673 > rm -f conftest.$ac_objext conftest$ac_exeext
6674 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6675 >  (eval $ac_link) 2>conftest.er1
6676 >  ac_status=$?
6677 >  grep -v '^ *+' conftest.er1 >conftest.err
6678 >  rm -f conftest.er1
6679 >  cat conftest.err >&5
6680 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6681 >  (exit $ac_status); } &&
6682 >         { ac_try='test -z "$ac_c_werror_flag"
6683 >                         || test ! -s conftest.err'
6684 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6685 >  (eval $ac_try) 2>&5
6686 >  ac_status=$?
6687 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6688 >  (exit $ac_status); }; } &&
6689 >         { ac_try='test -s conftest$ac_exeext'
6690 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6691 >  (eval $ac_try) 2>&5
6692 >  ac_status=$?
6693 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6694 >  (exit $ac_status); }; }; then
6695 >  ac_cv_lib_dfftw_fftwnd_one=yes
6696 > else
6697 >  echo "$as_me: failed program was:" >&5
6698 > sed 's/^/| /' conftest.$ac_ext >&5
6699 >
6700 > ac_cv_lib_dfftw_fftwnd_one=no
6701 > fi
6702 > rm -f conftest.err conftest.$ac_objext \
6703 >      conftest$ac_exeext conftest.$ac_ext
6704 > LIBS=$ac_check_lib_save_LIBS
6705 > fi
6706 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6707 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6708 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6709 >  fftw_cv_libdfftw=yes
6710 > else
6711 >  fftw_cv_libdfftw=no
6712 > fi
6713 >
6714 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6715 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6716 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6717 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6718 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6719 > fi
6720 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6721 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6722 > else
6723 >  # Is the header compilable?
6724 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6725 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6726 > cat >conftest.$ac_ext <<_ACEOF
6727 > /* confdefs.h.  */
6728 > _ACEOF
6729 > cat confdefs.h >>conftest.$ac_ext
6730 > cat >>conftest.$ac_ext <<_ACEOF
6731 > /* end confdefs.h.  */
6732 > $ac_includes_default
6733 > #include <dfftw.h>
6734 > _ACEOF
6735 > rm -f conftest.$ac_objext
6736 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6737 >  (eval $ac_compile) 2>conftest.er1
6738 >  ac_status=$?
6739 >  grep -v '^ *+' conftest.er1 >conftest.err
6740 >  rm -f conftest.er1
6741 >  cat conftest.err >&5
6742 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6743 >  (exit $ac_status); } &&
6744 >         { ac_try='test -z "$ac_c_werror_flag"
6745 >                         || test ! -s conftest.err'
6746 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6747 >  (eval $ac_try) 2>&5
6748 >  ac_status=$?
6749 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6750 >  (exit $ac_status); }; } &&
6751 >         { ac_try='test -s conftest.$ac_objext'
6752 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6753 >  (eval $ac_try) 2>&5
6754 >  ac_status=$?
6755 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6756 >  (exit $ac_status); }; }; then
6757 >  ac_header_compiler=yes
6758 > else
6759 >  echo "$as_me: failed program was:" >&5
6760 > sed 's/^/| /' conftest.$ac_ext >&5
6761 >
6762 > ac_header_compiler=no
6763 > fi
6764 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6765 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6766 > echo "${ECHO_T}$ac_header_compiler" >&6
6767 >
6768 > # Is the header present?
6769 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6770 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6771 > cat >conftest.$ac_ext <<_ACEOF
6772 > /* confdefs.h.  */
6773 > _ACEOF
6774 > cat confdefs.h >>conftest.$ac_ext
6775 > cat >>conftest.$ac_ext <<_ACEOF
6776 > /* end confdefs.h.  */
6777 > #include <dfftw.h>
6778 > _ACEOF
6779 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6780 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6781 >  ac_status=$?
6782 >  grep -v '^ *+' conftest.er1 >conftest.err
6783 >  rm -f conftest.er1
6784 >  cat conftest.err >&5
6785 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6786 >  (exit $ac_status); } >/dev/null; then
6787 >  if test -s conftest.err; then
6788 >    ac_cpp_err=$ac_c_preproc_warn_flag
6789 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6790 >  else
6791 >    ac_cpp_err=
6792 >  fi
6793 > else
6794 >  ac_cpp_err=yes
6795 > fi
6796 > if test -z "$ac_cpp_err"; then
6797 >  ac_header_preproc=yes
6798 > else
6799 >  echo "$as_me: failed program was:" >&5
6800 > sed 's/^/| /' conftest.$ac_ext >&5
6801 >
6802 >  ac_header_preproc=no
6803 > fi
6804 > rm -f conftest.err conftest.$ac_ext
6805 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6806 > echo "${ECHO_T}$ac_header_preproc" >&6
6807 >
6808 > # So?  What about this header?
6809 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6810 >  yes:no: )
6811 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6812 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6813 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6814 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6815 >    ac_header_preproc=yes
6816 >    ;;
6817 >  no:yes:* )
6818 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6819 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6820 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6821 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6822 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6823 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6824 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6825 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6826 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6827 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6828 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6829 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6830 >    (
6831 >      cat <<\_ASBOX
6832 > ## ------------------------------ ##
6833 > ## Report this to gezelter@nd.edu ##
6834 > ## ------------------------------ ##
6835 > _ASBOX
6836 >    ) |
6837 >      sed "s/^/$as_me: WARNING:     /" >&2
6838 >    ;;
6839 > esac
6840 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6841 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6842 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6843 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6844 > else
6845 >  ac_cv_header_dfftw_h=$ac_header_preproc
6846 > fi
6847 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6848 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6849 >
6850 > fi
6851 > if test $ac_cv_header_dfftw_h = yes; then
6852 >  fftw_cv_dfftw_h=yes
6853 > else
6854 >  fftw_cv_dfftw_h=no
6855 > fi
6856 >
6857 >
6858 >                fi
6859 >        fi
6860 >        ac_ext=c
6861 > ac_cpp='$CPP $CPPFLAGS'
6862 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6863 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6864 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6865 >
6866 >
6867 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6868 >        then
6869 >
6870 > cat >>confdefs.h <<\_ACEOF
6871 > #define HAVE_FFTW3_H 1
6872 > _ACEOF
6873 >
6874 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6875 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6876 >                FFTW_LIBS="-lfftw3"
6877 >        else
6878 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6879 >        then
6880 >
6881 > cat >>confdefs.h <<\_ACEOF
6882 > #define HAVE_FFTW_H 1
6883 > _ACEOF
6884 >
6885 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6886 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6887 >                FFTW_LIBS="-lfftw"
6888 >        else
6889 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6890 >        then
6891 >
6892 > cat >>confdefs.h <<\_ACEOF
6893 > #define HAVE_DFFTW_H 1
6894 > _ACEOF
6895 >
6896 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6897 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6898 >                FFTW_LIBS="-ldfftw"
6899 >        else
6900 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6901 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6902 >                FFTW_INC_DIR=
6903 >                FFTW_LIB_DIR=
6904 >                FFTW_LIBS=
6905 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6906 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6907 >                echo "$as_me:$LINENO: result: failed" >&5
6908 > echo "${ECHO_T}failed" >&6
6909 >        echo ""
6910 >        echo "*********************************************************"
6911 >        echo "* WARNING: Could not find a working FFTW installation   *"
6912 >        echo "* If you need the staticProps program to be able to     *"
6913 >        echo "* compute undulation spectra, be sure to specify a      *"
6914 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6915 >        echo "*                                                       *"
6916 >        echo "* OOPSE will still work without fftw installed.         *"
6917 >        echo "*********************************************************"
6918 >        echo ""
6919 >        fi
6920 >        fi
6921 >        fi
6922 >
6923 >
6924 >
6925 > fi
6926 > fi
6927 >
6928 >
6929 >
6930 > # Checks for header files.
6931 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6932 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6933 > if test "${ac_cv_header_stdc+set}" = set; then
6934 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6935 > else
6936 >  cat >conftest.$ac_ext <<_ACEOF
6937 > /* confdefs.h.  */
6938 > _ACEOF
6939 > cat confdefs.h >>conftest.$ac_ext
6940 > cat >>conftest.$ac_ext <<_ACEOF
6941 > /* end confdefs.h.  */
6942 > #include <stdlib.h>
6943 > #include <stdarg.h>
6944 > #include <string.h>
6945 > #include <float.h>
6946 >
6947 > #ifdef FC_DUMMY_MAIN
6948 > #ifndef FC_DUMMY_MAIN_EQ_F77
6949 > #  ifdef __cplusplus
6950 >     extern "C"
6951 > #  endif
6952 >   int FC_DUMMY_MAIN() { return 1; }
6953 > #endif
6954 > #endif
6955 > int
6956 > main ()
6957 > {
6958 >
6959 >  ;
6960 >  return 0;
6961 > }
6962 > _ACEOF
6963 > rm -f conftest.$ac_objext
6964 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6965 >  (eval $ac_compile) 2>conftest.er1
6966 >  ac_status=$?
6967 >  grep -v '^ *+' conftest.er1 >conftest.err
6968 >  rm -f conftest.er1
6969 >  cat conftest.err >&5
6970 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6971 >  (exit $ac_status); } &&
6972 >         { ac_try='test -z "$ac_c_werror_flag"
6973 >                         || test ! -s conftest.err'
6974 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6975 >  (eval $ac_try) 2>&5
6976 >  ac_status=$?
6977 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6978 >  (exit $ac_status); }; } &&
6979 >         { ac_try='test -s conftest.$ac_objext'
6980 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6981 >  (eval $ac_try) 2>&5
6982 >  ac_status=$?
6983 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6984 >  (exit $ac_status); }; }; then
6985 >  ac_cv_header_stdc=yes
6986 > else
6987 >  echo "$as_me: failed program was:" >&5
6988 > sed 's/^/| /' conftest.$ac_ext >&5
6989 >
6990 > ac_cv_header_stdc=no
6991 > fi
6992 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6993 >
6994 > if test $ac_cv_header_stdc = yes; then
6995 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6996 >  cat >conftest.$ac_ext <<_ACEOF
6997 > /* confdefs.h.  */
6998 > _ACEOF
6999 > cat confdefs.h >>conftest.$ac_ext
7000 > cat >>conftest.$ac_ext <<_ACEOF
7001 > /* end confdefs.h.  */
7002 > #include <string.h>
7003 >
7004 > _ACEOF
7005 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7006 >  $EGREP "memchr" >/dev/null 2>&1; then
7007 >  :
7008 > else
7009 >  ac_cv_header_stdc=no
7010 > fi
7011 > rm -f conftest*
7012 >
7013 > fi
7014 >
7015 > if test $ac_cv_header_stdc = yes; then
7016 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7017 >  cat >conftest.$ac_ext <<_ACEOF
7018 > /* confdefs.h.  */
7019 > _ACEOF
7020 > cat confdefs.h >>conftest.$ac_ext
7021 > cat >>conftest.$ac_ext <<_ACEOF
7022 > /* end confdefs.h.  */
7023 > #include <stdlib.h>
7024 >
7025 > _ACEOF
7026 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7027 >  $EGREP "free" >/dev/null 2>&1; then
7028 >  :
7029 > else
7030 >  ac_cv_header_stdc=no
7031 > fi
7032 > rm -f conftest*
7033 >
7034 > fi
7035 >
7036 > if test $ac_cv_header_stdc = yes; then
7037 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7038 >  if test "$cross_compiling" = yes; then
7039 >  :
7040 > else
7041 >  cat >conftest.$ac_ext <<_ACEOF
7042 > /* confdefs.h.  */
7043 > _ACEOF
7044 > cat confdefs.h >>conftest.$ac_ext
7045 > cat >>conftest.$ac_ext <<_ACEOF
7046 > /* end confdefs.h.  */
7047 > #include <ctype.h>
7048 > #if ((' ' & 0x0FF) == 0x020)
7049 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7050 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7051 > #else
7052 > # define ISLOWER(c) \
7053 >                   (('a' <= (c) && (c) <= 'i') \
7054 >                     || ('j' <= (c) && (c) <= 'r') \
7055 >                     || ('s' <= (c) && (c) <= 'z'))
7056 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7057 > #endif
7058 >
7059 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7060 > int
7061 > main ()
7062 > {
7063 >  int i;
7064 >  for (i = 0; i < 256; i++)
7065 >    if (XOR (islower (i), ISLOWER (i))
7066 >        || toupper (i) != TOUPPER (i))
7067 >      exit(2);
7068 >  exit (0);
7069 > }
7070 > _ACEOF
7071 > rm -f conftest$ac_exeext
7072 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7073 >  (eval $ac_link) 2>&5
7074 >  ac_status=$?
7075 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7076 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7077 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7078 >  (eval $ac_try) 2>&5
7079 >  ac_status=$?
7080 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7081 >  (exit $ac_status); }; }; then
7082 >  :
7083 > else
7084 >  echo "$as_me: program exited with status $ac_status" >&5
7085 > echo "$as_me: failed program was:" >&5
7086 > sed 's/^/| /' conftest.$ac_ext >&5
7087 >
7088 > ( exit $ac_status )
7089 > ac_cv_header_stdc=no
7090 > fi
7091 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7092 > fi
7093 > fi
7094 > fi
7095 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7096 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7097 > if test $ac_cv_header_stdc = yes; then
7098 >
7099 > cat >>confdefs.h <<\_ACEOF
7100 > #define STDC_HEADERS 1
7101 > _ACEOF
7102 >
7103 > fi
7104 >
7105 >
7106 >
7107 >
7108 >
7109 >
7110 >
7111 >
7112 >
7113 >
7114 >
7115 >
7116 >
7117 >
7118 >
7119 >
7120 >
7121 >
7122 >
7123 >
7124 >
7125 >
7126 >
7127 >
7128 >
7129 >
7130 > 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
7131 > do
7132 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7133 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7134 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7135 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7136 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7137 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7138 > fi
7139 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7140 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7141 > else
7142 >  # Is the header compilable?
7143 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7144 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7145 > cat >conftest.$ac_ext <<_ACEOF
7146 > /* confdefs.h.  */
7147 > _ACEOF
7148 > cat confdefs.h >>conftest.$ac_ext
7149 > cat >>conftest.$ac_ext <<_ACEOF
7150 > /* end confdefs.h.  */
7151 > $ac_includes_default
7152 > #include <$ac_header>
7153 > _ACEOF
7154 > rm -f conftest.$ac_objext
7155 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7156 >  (eval $ac_compile) 2>conftest.er1
7157 >  ac_status=$?
7158 >  grep -v '^ *+' conftest.er1 >conftest.err
7159 >  rm -f conftest.er1
7160 >  cat conftest.err >&5
7161 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7162 >  (exit $ac_status); } &&
7163 >         { ac_try='test -z "$ac_c_werror_flag"
7164 >                         || test ! -s conftest.err'
7165 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7166 >  (eval $ac_try) 2>&5
7167 >  ac_status=$?
7168 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7169 >  (exit $ac_status); }; } &&
7170 >         { ac_try='test -s conftest.$ac_objext'
7171 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7172 >  (eval $ac_try) 2>&5
7173 >  ac_status=$?
7174 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7175 >  (exit $ac_status); }; }; then
7176 >  ac_header_compiler=yes
7177 > else
7178 >  echo "$as_me: failed program was:" >&5
7179 > sed 's/^/| /' conftest.$ac_ext >&5
7180 >
7181 > ac_header_compiler=no
7182 > fi
7183 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7184 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7185 > echo "${ECHO_T}$ac_header_compiler" >&6
7186 >
7187 > # Is the header present?
7188 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7189 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7190 > cat >conftest.$ac_ext <<_ACEOF
7191 > /* confdefs.h.  */
7192 > _ACEOF
7193 > cat confdefs.h >>conftest.$ac_ext
7194 > cat >>conftest.$ac_ext <<_ACEOF
7195 > /* end confdefs.h.  */
7196 > #include <$ac_header>
7197 > _ACEOF
7198 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7199 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7200 >  ac_status=$?
7201 >  grep -v '^ *+' conftest.er1 >conftest.err
7202 >  rm -f conftest.er1
7203 >  cat conftest.err >&5
7204 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7205 >  (exit $ac_status); } >/dev/null; then
7206 >  if test -s conftest.err; then
7207 >    ac_cpp_err=$ac_c_preproc_warn_flag
7208 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7209 >  else
7210 >    ac_cpp_err=
7211 >  fi
7212 > else
7213 >  ac_cpp_err=yes
7214 > fi
7215 > if test -z "$ac_cpp_err"; then
7216 >  ac_header_preproc=yes
7217 > else
7218 >  echo "$as_me: failed program was:" >&5
7219 > sed 's/^/| /' conftest.$ac_ext >&5
7220 >
7221 >  ac_header_preproc=no
7222 > fi
7223 > rm -f conftest.err conftest.$ac_ext
7224 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7225 > echo "${ECHO_T}$ac_header_preproc" >&6
7226 >
7227 > # So?  What about this header?
7228 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7229 >  yes:no: )
7230 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7231 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7232 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7233 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7234 >    ac_header_preproc=yes
7235 >    ;;
7236 >  no:yes:* )
7237 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7238 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7239 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7240 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7241 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7242 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7243 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7244 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7245 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7246 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7247 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7248 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7249 >    (
7250 >      cat <<\_ASBOX
7251 > ## ------------------------------ ##
7252 > ## Report this to gezelter@nd.edu ##
7253 > ## ------------------------------ ##
7254 > _ASBOX
7255 >    ) |
7256 >      sed "s/^/$as_me: WARNING:     /" >&2
7257 >    ;;
7258 > esac
7259 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7260 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7261 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7262 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7263 > else
7264 >  eval "$as_ac_Header=\$ac_header_preproc"
7265 > fi
7266 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7267 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7268 >
7269 > fi
7270 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7271 >  cat >>confdefs.h <<_ACEOF
7272 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7273 > _ACEOF
7274 >
7275 > fi
7276 >
7277 > done
7278 >
7279 >
7280 > # Checks for typedefs, structures, and compiler characteristics.
7281 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7282 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7283 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7284 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7285 > else
7286 >  cat >conftest.$ac_ext <<_ACEOF
7287 > /* confdefs.h.  */
7288 > _ACEOF
7289 > cat confdefs.h >>conftest.$ac_ext
7290 > cat >>conftest.$ac_ext <<_ACEOF
7291 > /* end confdefs.h.  */
7292 >
7293 > #include <stdbool.h>
7294 > #ifndef bool
7295 > # error bool is not defined
7296 > #endif
7297 > #ifndef false
7298 > # error false is not defined
7299 > #endif
7300 > #if false
7301 > # error false is not 0
7302 > #endif
7303 > #ifndef true
7304 > # error true is not defined
7305 > #endif
7306 > #if true != 1
7307 > # error true is not 1
7308 > #endif
7309 > #ifndef __bool_true_false_are_defined
7310 > # error __bool_true_false_are_defined is not defined
7311 > #endif
7312 >
7313 >        struct s { _Bool s: 1; _Bool t; } s;
7314 >
7315 >        char a[true == 1 ? 1 : -1];
7316 >        char b[false == 0 ? 1 : -1];
7317 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7318 >        char d[(bool) -0.5 == true ? 1 : -1];
7319 >        bool e = &s;
7320 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7321 >        char g[true];
7322 >        char h[sizeof (_Bool)];
7323 >        char i[sizeof s.t];
7324 >
7325 > #ifdef FC_DUMMY_MAIN
7326 > #ifndef FC_DUMMY_MAIN_EQ_F77
7327 > #  ifdef __cplusplus
7328 >     extern "C"
7329 > #  endif
7330 >   int FC_DUMMY_MAIN() { return 1; }
7331 > #endif
7332 > #endif
7333 > int
7334 > main ()
7335 > {
7336 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7337 >  ;
7338 >  return 0;
7339 > }
7340 > _ACEOF
7341 > rm -f conftest.$ac_objext
7342 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7343 >  (eval $ac_compile) 2>conftest.er1
7344 >  ac_status=$?
7345 >  grep -v '^ *+' conftest.er1 >conftest.err
7346 >  rm -f conftest.er1
7347 >  cat conftest.err >&5
7348 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7349 >  (exit $ac_status); } &&
7350 >         { ac_try='test -z "$ac_c_werror_flag"
7351 >                         || test ! -s conftest.err'
7352 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7353 >  (eval $ac_try) 2>&5
7354 >  ac_status=$?
7355 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7356 >  (exit $ac_status); }; } &&
7357 >         { ac_try='test -s conftest.$ac_objext'
7358 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7359 >  (eval $ac_try) 2>&5
7360 >  ac_status=$?
7361 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7362 >  (exit $ac_status); }; }; then
7363 >  ac_cv_header_stdbool_h=yes
7364 > else
7365 >  echo "$as_me: failed program was:" >&5
7366 > sed 's/^/| /' conftest.$ac_ext >&5
7367 >
7368 > ac_cv_header_stdbool_h=no
7369 > fi
7370 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7371 > fi
7372 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7373 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7374 > echo "$as_me:$LINENO: checking for _Bool" >&5
7375 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7376 > if test "${ac_cv_type__Bool+set}" = set; then
7377 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7378 > else
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 > $ac_includes_default
7386 > #ifdef FC_DUMMY_MAIN
7387 > #ifndef FC_DUMMY_MAIN_EQ_F77
7388 > #  ifdef __cplusplus
7389 >     extern "C"
7390 > #  endif
7391 >   int FC_DUMMY_MAIN() { return 1; }
7392 > #endif
7393 > #endif
7394 > int
7395 > main ()
7396 > {
7397 > if ((_Bool *) 0)
7398 >  return 0;
7399 > if (sizeof (_Bool))
7400 >  return 0;
7401 >  ;
7402 >  return 0;
7403 > }
7404 > _ACEOF
7405 > rm -f conftest.$ac_objext
7406 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7407 >  (eval $ac_compile) 2>conftest.er1
7408 >  ac_status=$?
7409 >  grep -v '^ *+' conftest.er1 >conftest.err
7410 >  rm -f conftest.er1
7411 >  cat conftest.err >&5
7412 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7413 >  (exit $ac_status); } &&
7414 >         { ac_try='test -z "$ac_c_werror_flag"
7415 >                         || test ! -s conftest.err'
7416 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7417 >  (eval $ac_try) 2>&5
7418 >  ac_status=$?
7419 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7420 >  (exit $ac_status); }; } &&
7421 >         { ac_try='test -s conftest.$ac_objext'
7422 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7423 >  (eval $ac_try) 2>&5
7424 >  ac_status=$?
7425 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7426 >  (exit $ac_status); }; }; then
7427 >  ac_cv_type__Bool=yes
7428 > else
7429 >  echo "$as_me: failed program was:" >&5
7430 > sed 's/^/| /' conftest.$ac_ext >&5
7431 >
7432 > ac_cv_type__Bool=no
7433 > fi
7434 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7435 > fi
7436 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7437 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7438 > if test $ac_cv_type__Bool = yes; then
7439 >
7440 > cat >>confdefs.h <<_ACEOF
7441 > #define HAVE__BOOL 1
7442 > _ACEOF
7443 >
7444 >
7445 > fi
7446 >
7447 > if test $ac_cv_header_stdbool_h = yes; then
7448 >
7449 > cat >>confdefs.h <<\_ACEOF
7450 > #define HAVE_STDBOOL_H 1
7451 > _ACEOF
7452 >
7453 > fi
7454 >
7455 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7456 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7457 > if test "${ac_cv_c_const+set}" = set; then
7458 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7459 > else
7460 >  cat >conftest.$ac_ext <<_ACEOF
7461 > /* confdefs.h.  */
7462 > _ACEOF
7463 > cat confdefs.h >>conftest.$ac_ext
7464 > cat >>conftest.$ac_ext <<_ACEOF
7465 > /* end confdefs.h.  */
7466 >
7467 > #ifdef FC_DUMMY_MAIN
7468 > #ifndef FC_DUMMY_MAIN_EQ_F77
7469 > #  ifdef __cplusplus
7470 >     extern "C"
7471 > #  endif
7472 >   int FC_DUMMY_MAIN() { return 1; }
7473 > #endif
7474 > #endif
7475 > int
7476 > main ()
7477 > {
7478 > /* FIXME: Include the comments suggested by Paul. */
7479 > #ifndef __cplusplus
7480 >  /* Ultrix mips cc rejects this.  */
7481 >  typedef int charset[2];
7482 >  const charset x;
7483 >  /* SunOS 4.1.1 cc rejects this.  */
7484 >  char const *const *ccp;
7485 >  char **p;
7486 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7487 >  struct point {int x, y;};
7488 >  static struct point const zero = {0,0};
7489 >  /* AIX XL C 1.02.0.0 rejects this.
7490 >     It does not let you subtract one const X* pointer from another in
7491 >     an arm of an if-expression whose if-part is not a constant
7492 >     expression */
7493 >  const char *g = "string";
7494 >  ccp = &g + (g ? g-g : 0);
7495 >  /* HPUX 7.0 cc rejects these. */
7496 >  ++ccp;
7497 >  p = (char**) ccp;
7498 >  ccp = (char const *const *) p;
7499 >  { /* SCO 3.2v4 cc rejects this.  */
7500 >    char *t;
7501 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7502 >
7503 >    *t++ = 0;
7504 >  }
7505 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7506 >    int x[] = {25, 17};
7507 >    const int *foo = &x[0];
7508 >    ++foo;
7509 >  }
7510 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7511 >    typedef const int *iptr;
7512 >    iptr p = 0;
7513 >    ++p;
7514 >  }
7515 >  { /* AIX XL C 1.02.0.0 rejects this saying
7516 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7517 >    struct s { int j; const int *ap[3]; };
7518 >    struct s *b; b->j = 5;
7519 >  }
7520 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7521 >    const int foo = 10;
7522 >  }
7523 > #endif
7524 >
7525 >  ;
7526 >  return 0;
7527 > }
7528 > _ACEOF
7529 > rm -f conftest.$ac_objext
7530 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7531 >  (eval $ac_compile) 2>conftest.er1
7532 >  ac_status=$?
7533 >  grep -v '^ *+' conftest.er1 >conftest.err
7534 >  rm -f conftest.er1
7535 >  cat conftest.err >&5
7536 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7537 >  (exit $ac_status); } &&
7538 >         { ac_try='test -z "$ac_c_werror_flag"
7539 >                         || test ! -s conftest.err'
7540 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7541 >  (eval $ac_try) 2>&5
7542 >  ac_status=$?
7543 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7544 >  (exit $ac_status); }; } &&
7545 >         { ac_try='test -s conftest.$ac_objext'
7546 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7547 >  (eval $ac_try) 2>&5
7548 >  ac_status=$?
7549 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7550 >  (exit $ac_status); }; }; then
7551 >  ac_cv_c_const=yes
7552 > else
7553 >  echo "$as_me: failed program was:" >&5
7554 > sed 's/^/| /' conftest.$ac_ext >&5
7555 >
7556 > ac_cv_c_const=no
7557 > fi
7558 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7559 > fi
7560 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7561 > echo "${ECHO_T}$ac_cv_c_const" >&6
7562 > if test $ac_cv_c_const = no; then
7563 >
7564 > cat >>confdefs.h <<\_ACEOF
7565 > #define const
7566 > _ACEOF
7567 >
7568 > fi
7569 >
7570 > echo "$as_me:$LINENO: checking for inline" >&5
7571 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7572 > if test "${ac_cv_c_inline+set}" = set; then
7573 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7574 > else
7575 >  ac_cv_c_inline=no
7576 > for ac_kw in inline __inline__ __inline; do
7577 >  cat >conftest.$ac_ext <<_ACEOF
7578 > /* confdefs.h.  */
7579 > _ACEOF
7580 > cat confdefs.h >>conftest.$ac_ext
7581 > cat >>conftest.$ac_ext <<_ACEOF
7582 > /* end confdefs.h.  */
7583 > #ifndef __cplusplus
7584 > typedef int foo_t;
7585 > static $ac_kw foo_t static_foo () {return 0; }
7586 > $ac_kw foo_t foo () {return 0; }
7587 > #endif
7588 >
7589 > _ACEOF
7590 > rm -f conftest.$ac_objext
7591 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7592 >  (eval $ac_compile) 2>conftest.er1
7593 >  ac_status=$?
7594 >  grep -v '^ *+' conftest.er1 >conftest.err
7595 >  rm -f conftest.er1
7596 >  cat conftest.err >&5
7597 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7598 >  (exit $ac_status); } &&
7599 >         { ac_try='test -z "$ac_c_werror_flag"
7600 >                         || test ! -s conftest.err'
7601 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7602 >  (eval $ac_try) 2>&5
7603 >  ac_status=$?
7604 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7605 >  (exit $ac_status); }; } &&
7606 >         { ac_try='test -s conftest.$ac_objext'
7607 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7608 >  (eval $ac_try) 2>&5
7609 >  ac_status=$?
7610 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7611 >  (exit $ac_status); }; }; then
7612 >  ac_cv_c_inline=$ac_kw; break
7613 > else
7614 >  echo "$as_me: failed program was:" >&5
7615 > sed 's/^/| /' conftest.$ac_ext >&5
7616 >
7617 > fi
7618 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7619 > done
7620 >
7621 > fi
7622 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7623 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7624 >
7625 >
7626 > case $ac_cv_c_inline in
7627 >  inline | yes) ;;
7628 >  *)
7629 >    case $ac_cv_c_inline in
7630 >      no) ac_val=;;
7631 >      *) ac_val=$ac_cv_c_inline;;
7632 >    esac
7633 >    cat >>confdefs.h <<_ACEOF
7634 > #ifndef __cplusplus
7635 > #define inline $ac_val
7636 > #endif
7637 > _ACEOF
7638 >    ;;
7639 > esac
7640 >
7641 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7642 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7643 > if test "${ac_cv_c_restrict+set}" = set; then
7644 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7645 > else
7646 >  ac_cv_c_restrict=no
7647 >   # Try the official restrict keyword, then gcc's __restrict, and
7648 >   # the less common variants.
7649 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7650 >     cat >conftest.$ac_ext <<_ACEOF
7651 > /* confdefs.h.  */
7652 > _ACEOF
7653 > cat confdefs.h >>conftest.$ac_ext
7654 > cat >>conftest.$ac_ext <<_ACEOF
7655 > /* end confdefs.h.  */
7656 > float * $ac_kw x;
7657 > _ACEOF
7658 > rm -f conftest.$ac_objext
7659 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7660 >  (eval $ac_compile) 2>conftest.er1
7661 >  ac_status=$?
7662 >  grep -v '^ *+' conftest.er1 >conftest.err
7663 >  rm -f conftest.er1
7664 >  cat conftest.err >&5
7665 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7666 >  (exit $ac_status); } &&
7667 >         { ac_try='test -z "$ac_c_werror_flag"
7668 >                         || test ! -s conftest.err'
7669 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7670 >  (eval $ac_try) 2>&5
7671 >  ac_status=$?
7672 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7673 >  (exit $ac_status); }; } &&
7674 >         { ac_try='test -s conftest.$ac_objext'
7675 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7676 >  (eval $ac_try) 2>&5
7677 >  ac_status=$?
7678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7679 >  (exit $ac_status); }; }; then
7680 >  ac_cv_c_restrict=$ac_kw; break
7681 > else
7682 >  echo "$as_me: failed program was:" >&5
7683 > sed 's/^/| /' conftest.$ac_ext >&5
7684 >
7685 > fi
7686 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7687 >   done
7688 >
7689 > fi
7690 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7691 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7692 > case $ac_cv_c_restrict in
7693 >   restrict) ;;
7694 >   no)
7695 > cat >>confdefs.h <<\_ACEOF
7696 > #define restrict
7697 > _ACEOF
7698 > ;;
7699 >   *)  cat >>confdefs.h <<_ACEOF
7700 > #define restrict $ac_cv_c_restrict
7701 > _ACEOF
7702 > ;;
7703 > esac
7704 >
7705 > echo "$as_me:$LINENO: checking for size_t" >&5
7706 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7707 > if test "${ac_cv_type_size_t+set}" = set; then
7708 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7709 > else
7710 >  cat >conftest.$ac_ext <<_ACEOF
7711 > /* confdefs.h.  */
7712 > _ACEOF
7713 > cat confdefs.h >>conftest.$ac_ext
7714 > cat >>conftest.$ac_ext <<_ACEOF
7715 > /* end confdefs.h.  */
7716 > $ac_includes_default
7717 > #ifdef FC_DUMMY_MAIN
7718 > #ifndef FC_DUMMY_MAIN_EQ_F77
7719 > #  ifdef __cplusplus
7720 >     extern "C"
7721 > #  endif
7722 >   int FC_DUMMY_MAIN() { return 1; }
7723 > #endif
7724 > #endif
7725 > int
7726 > main ()
7727 > {
7728 > if ((size_t *) 0)
7729 >  return 0;
7730 > if (sizeof (size_t))
7731 >  return 0;
7732 >  ;
7733 >  return 0;
7734 > }
7735 > _ACEOF
7736 > rm -f conftest.$ac_objext
7737 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7738 >  (eval $ac_compile) 2>conftest.er1
7739 >  ac_status=$?
7740 >  grep -v '^ *+' conftest.er1 >conftest.err
7741 >  rm -f conftest.er1
7742 >  cat conftest.err >&5
7743 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7744 >  (exit $ac_status); } &&
7745 >         { ac_try='test -z "$ac_c_werror_flag"
7746 >                         || test ! -s conftest.err'
7747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7748 >  (eval $ac_try) 2>&5
7749 >  ac_status=$?
7750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7751 >  (exit $ac_status); }; } &&
7752 >         { ac_try='test -s conftest.$ac_objext'
7753 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7754 >  (eval $ac_try) 2>&5
7755 >  ac_status=$?
7756 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7757 >  (exit $ac_status); }; }; then
7758 >  ac_cv_type_size_t=yes
7759 > else
7760 >  echo "$as_me: failed program was:" >&5
7761 > sed 's/^/| /' conftest.$ac_ext >&5
7762 >
7763 > ac_cv_type_size_t=no
7764 > fi
7765 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7766 > fi
7767 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7768 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7769 > if test $ac_cv_type_size_t = yes; then
7770 >  :
7771 > else
7772 >
7773 > cat >>confdefs.h <<_ACEOF
7774 > #define size_t unsigned
7775 > _ACEOF
7776 >
7777 > fi
7778 >
7779 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7780 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7781 > if test "${ac_cv_header_time+set}" = set; then
7782 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7783 > else
7784 >  cat >conftest.$ac_ext <<_ACEOF
7785 > /* confdefs.h.  */
7786 > _ACEOF
7787 > cat confdefs.h >>conftest.$ac_ext
7788 > cat >>conftest.$ac_ext <<_ACEOF
7789 > /* end confdefs.h.  */
7790 > #include <sys/types.h>
7791 > #include <sys/time.h>
7792 > #include <time.h>
7793 >
7794 > #ifdef FC_DUMMY_MAIN
7795 > #ifndef FC_DUMMY_MAIN_EQ_F77
7796 > #  ifdef __cplusplus
7797 >     extern "C"
7798 > #  endif
7799 >   int FC_DUMMY_MAIN() { return 1; }
7800 > #endif
7801 > #endif
7802 > int
7803 > main ()
7804 > {
7805 > if ((struct tm *) 0)
7806 > return 0;
7807 >  ;
7808 >  return 0;
7809 > }
7810 > _ACEOF
7811 > rm -f conftest.$ac_objext
7812 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7813 >  (eval $ac_compile) 2>conftest.er1
7814 >  ac_status=$?
7815 >  grep -v '^ *+' conftest.er1 >conftest.err
7816 >  rm -f conftest.er1
7817 >  cat conftest.err >&5
7818 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7819 >  (exit $ac_status); } &&
7820 >         { ac_try='test -z "$ac_c_werror_flag"
7821 >                         || test ! -s conftest.err'
7822 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7823 >  (eval $ac_try) 2>&5
7824 >  ac_status=$?
7825 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7826 >  (exit $ac_status); }; } &&
7827 >         { ac_try='test -s conftest.$ac_objext'
7828 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7829 >  (eval $ac_try) 2>&5
7830 >  ac_status=$?
7831 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832 >  (exit $ac_status); }; }; then
7833 >  ac_cv_header_time=yes
7834 > else
7835 >  echo "$as_me: failed program was:" >&5
7836 > sed 's/^/| /' conftest.$ac_ext >&5
7837 >
7838 > ac_cv_header_time=no
7839 > fi
7840 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7841 > fi
7842 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7843 > echo "${ECHO_T}$ac_cv_header_time" >&6
7844 > if test $ac_cv_header_time = yes; then
7845 >
7846 > cat >>confdefs.h <<\_ACEOF
7847 > #define TIME_WITH_SYS_TIME 1
7848 > _ACEOF
7849 >
7850 > fi
7851 >
7852 > echo "$as_me:$LINENO: checking for clock_t" >&5
7853 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7854 > if test "${ac_cv_type_clock_t+set}" = set; then
7855 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7856 > else
7857 >  cat >conftest.$ac_ext <<_ACEOF
7858 > /* confdefs.h.  */
7859 > _ACEOF
7860 > cat confdefs.h >>conftest.$ac_ext
7861 > cat >>conftest.$ac_ext <<_ACEOF
7862 > /* end confdefs.h.  */
7863 > $ac_includes_default
7864 > #ifdef FC_DUMMY_MAIN
7865 > #ifndef FC_DUMMY_MAIN_EQ_F77
7866 > #  ifdef __cplusplus
7867 >     extern "C"
7868 > #  endif
7869 >   int FC_DUMMY_MAIN() { return 1; }
7870 > #endif
7871 > #endif
7872 > int
7873 > main ()
7874 > {
7875 > if ((clock_t *) 0)
7876 >  return 0;
7877 > if (sizeof (clock_t))
7878 >  return 0;
7879 >  ;
7880 >  return 0;
7881 > }
7882 > _ACEOF
7883 > rm -f conftest.$ac_objext
7884 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7885 >  (eval $ac_compile) 2>conftest.er1
7886 >  ac_status=$?
7887 >  grep -v '^ *+' conftest.er1 >conftest.err
7888 >  rm -f conftest.er1
7889 >  cat conftest.err >&5
7890 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7891 >  (exit $ac_status); } &&
7892 >         { ac_try='test -z "$ac_c_werror_flag"
7893 >                         || test ! -s conftest.err'
7894 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7895 >  (eval $ac_try) 2>&5
7896 >  ac_status=$?
7897 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7898 >  (exit $ac_status); }; } &&
7899 >         { ac_try='test -s conftest.$ac_objext'
7900 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7901 >  (eval $ac_try) 2>&5
7902 >  ac_status=$?
7903 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7904 >  (exit $ac_status); }; }; then
7905 >  ac_cv_type_clock_t=yes
7906 > else
7907 >  echo "$as_me: failed program was:" >&5
7908 > sed 's/^/| /' conftest.$ac_ext >&5
7909 >
7910 > ac_cv_type_clock_t=no
7911 > fi
7912 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7913 > fi
7914 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7915 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7916 > if test $ac_cv_type_clock_t = yes; then
7917 >
7918 > cat >>confdefs.h <<_ACEOF
7919 > #define HAVE_CLOCK_T 1
7920 > _ACEOF
7921 >
7922 >
7923 > fi
7924 >
7925 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7926 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7927 > if test "${ac_cv_c_const+set}" = set; then
7928 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7929 > else
7930 >  cat >conftest.$ac_ext <<_ACEOF
7931 > /* confdefs.h.  */
7932 > _ACEOF
7933 > cat confdefs.h >>conftest.$ac_ext
7934 > cat >>conftest.$ac_ext <<_ACEOF
7935 > /* end confdefs.h.  */
7936 >
7937 > #ifdef FC_DUMMY_MAIN
7938 > #ifndef FC_DUMMY_MAIN_EQ_F77
7939 > #  ifdef __cplusplus
7940 >     extern "C"
7941 > #  endif
7942 >   int FC_DUMMY_MAIN() { return 1; }
7943 > #endif
7944 > #endif
7945 > int
7946 > main ()
7947 > {
7948 > /* FIXME: Include the comments suggested by Paul. */
7949 > #ifndef __cplusplus
7950 >  /* Ultrix mips cc rejects this.  */
7951 >  typedef int charset[2];
7952 >  const charset x;
7953 >  /* SunOS 4.1.1 cc rejects this.  */
7954 >  char const *const *ccp;
7955 >  char **p;
7956 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7957 >  struct point {int x, y;};
7958 >  static struct point const zero = {0,0};
7959 >  /* AIX XL C 1.02.0.0 rejects this.
7960 >     It does not let you subtract one const X* pointer from another in
7961 >     an arm of an if-expression whose if-part is not a constant
7962 >     expression */
7963 >  const char *g = "string";
7964 >  ccp = &g + (g ? g-g : 0);
7965 >  /* HPUX 7.0 cc rejects these. */
7966 >  ++ccp;
7967 >  p = (char**) ccp;
7968 >  ccp = (char const *const *) p;
7969 >  { /* SCO 3.2v4 cc rejects this.  */
7970 >    char *t;
7971 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7972 >
7973 >    *t++ = 0;
7974 >  }
7975 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7976 >    int x[] = {25, 17};
7977 >    const int *foo = &x[0];
7978 >    ++foo;
7979 >  }
7980 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7981 >    typedef const int *iptr;
7982 >    iptr p = 0;
7983 >    ++p;
7984 >  }
7985 >  { /* AIX XL C 1.02.0.0 rejects this saying
7986 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7987 >    struct s { int j; const int *ap[3]; };
7988 >    struct s *b; b->j = 5;
7989 >  }
7990 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7991 >    const int foo = 10;
7992 >  }
7993 > #endif
7994 >
7995 >  ;
7996 >  return 0;
7997 > }
7998 > _ACEOF
7999 > rm -f conftest.$ac_objext
8000 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8001 >  (eval $ac_compile) 2>conftest.er1
8002 >  ac_status=$?
8003 >  grep -v '^ *+' conftest.er1 >conftest.err
8004 >  rm -f conftest.er1
8005 >  cat conftest.err >&5
8006 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8007 >  (exit $ac_status); } &&
8008 >         { ac_try='test -z "$ac_c_werror_flag"
8009 >                         || test ! -s conftest.err'
8010 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8011 >  (eval $ac_try) 2>&5
8012 >  ac_status=$?
8013 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8014 >  (exit $ac_status); }; } &&
8015 >         { ac_try='test -s conftest.$ac_objext'
8016 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8017 >  (eval $ac_try) 2>&5
8018 >  ac_status=$?
8019 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8020 >  (exit $ac_status); }; }; then
8021 >  ac_cv_c_const=yes
8022 > else
8023 >  echo "$as_me: failed program was:" >&5
8024 > sed 's/^/| /' conftest.$ac_ext >&5
8025 >
8026 > ac_cv_c_const=no
8027 > fi
8028 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8029 > fi
8030 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8031 > echo "${ECHO_T}$ac_cv_c_const" >&6
8032 > if test $ac_cv_c_const = no; then
8033 >
8034 > cat >>confdefs.h <<\_ACEOF
8035 > #define const
8036 > _ACEOF
8037 >
8038 > fi
8039 >
8040 > echo "$as_me:$LINENO: checking for inline" >&5
8041 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8042 > if test "${ac_cv_c_inline+set}" = set; then
8043 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8044 > else
8045 >  ac_cv_c_inline=no
8046 > for ac_kw in inline __inline__ __inline; do
8047 >  cat >conftest.$ac_ext <<_ACEOF
8048 > /* confdefs.h.  */
8049 > _ACEOF
8050 > cat confdefs.h >>conftest.$ac_ext
8051 > cat >>conftest.$ac_ext <<_ACEOF
8052 > /* end confdefs.h.  */
8053 > #ifndef __cplusplus
8054 > typedef int foo_t;
8055 > static $ac_kw foo_t static_foo () {return 0; }
8056 > $ac_kw foo_t foo () {return 0; }
8057 > #endif
8058 >
8059 > _ACEOF
8060 > rm -f conftest.$ac_objext
8061 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8062 >  (eval $ac_compile) 2>conftest.er1
8063 >  ac_status=$?
8064 >  grep -v '^ *+' conftest.er1 >conftest.err
8065 >  rm -f conftest.er1
8066 >  cat conftest.err >&5
8067 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8068 >  (exit $ac_status); } &&
8069 >         { ac_try='test -z "$ac_c_werror_flag"
8070 >                         || test ! -s conftest.err'
8071 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8072 >  (eval $ac_try) 2>&5
8073 >  ac_status=$?
8074 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8075 >  (exit $ac_status); }; } &&
8076 >         { ac_try='test -s conftest.$ac_objext'
8077 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8078 >  (eval $ac_try) 2>&5
8079 >  ac_status=$?
8080 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8081 >  (exit $ac_status); }; }; then
8082 >  ac_cv_c_inline=$ac_kw; break
8083 > else
8084 >  echo "$as_me: failed program was:" >&5
8085 > sed 's/^/| /' conftest.$ac_ext >&5
8086 >
8087 > fi
8088 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8089 > done
8090 >
8091 > fi
8092 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8093 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8094 >
8095 >
8096 > case $ac_cv_c_inline in
8097 >  inline | yes) ;;
8098 >  *)
8099 >    case $ac_cv_c_inline in
8100 >      no) ac_val=;;
8101 >      *) ac_val=$ac_cv_c_inline;;
8102 >    esac
8103 >    cat >>confdefs.h <<_ACEOF
8104 > #ifndef __cplusplus
8105 > #define inline $ac_val
8106 > #endif
8107 > _ACEOF
8108 >    ;;
8109 > esac
8110 >
8111 >
8112 > # Checks for library functions.
8113 >
8114 > for ac_header in stdlib.h
8115 > do
8116 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8117 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8118 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8119 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8120 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8121 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8122 > fi
8123 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8124 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8125 > else
8126 >  # Is the header compilable?
8127 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8128 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8129 > cat >conftest.$ac_ext <<_ACEOF
8130 > /* confdefs.h.  */
8131 > _ACEOF
8132 > cat confdefs.h >>conftest.$ac_ext
8133 > cat >>conftest.$ac_ext <<_ACEOF
8134 > /* end confdefs.h.  */
8135 > $ac_includes_default
8136 > #include <$ac_header>
8137 > _ACEOF
8138 > rm -f conftest.$ac_objext
8139 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8140 >  (eval $ac_compile) 2>conftest.er1
8141 >  ac_status=$?
8142 >  grep -v '^ *+' conftest.er1 >conftest.err
8143 >  rm -f conftest.er1
8144 >  cat conftest.err >&5
8145 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8146 >  (exit $ac_status); } &&
8147 >         { ac_try='test -z "$ac_c_werror_flag"
8148 >                         || test ! -s conftest.err'
8149 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8150 >  (eval $ac_try) 2>&5
8151 >  ac_status=$?
8152 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8153 >  (exit $ac_status); }; } &&
8154 >         { ac_try='test -s conftest.$ac_objext'
8155 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8156 >  (eval $ac_try) 2>&5
8157 >  ac_status=$?
8158 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8159 >  (exit $ac_status); }; }; then
8160 >  ac_header_compiler=yes
8161 > else
8162 >  echo "$as_me: failed program was:" >&5
8163 > sed 's/^/| /' conftest.$ac_ext >&5
8164 >
8165 > ac_header_compiler=no
8166 > fi
8167 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8168 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8169 > echo "${ECHO_T}$ac_header_compiler" >&6
8170 >
8171 > # Is the header present?
8172 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8173 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8174 > cat >conftest.$ac_ext <<_ACEOF
8175 > /* confdefs.h.  */
8176 > _ACEOF
8177 > cat confdefs.h >>conftest.$ac_ext
8178 > cat >>conftest.$ac_ext <<_ACEOF
8179 > /* end confdefs.h.  */
8180 > #include <$ac_header>
8181 > _ACEOF
8182 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8183 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8184 >  ac_status=$?
8185 >  grep -v '^ *+' conftest.er1 >conftest.err
8186 >  rm -f conftest.er1
8187 >  cat conftest.err >&5
8188 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8189 >  (exit $ac_status); } >/dev/null; then
8190 >  if test -s conftest.err; then
8191 >    ac_cpp_err=$ac_c_preproc_warn_flag
8192 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8193 >  else
8194 >    ac_cpp_err=
8195 >  fi
8196 > else
8197 >  ac_cpp_err=yes
8198 > fi
8199 > if test -z "$ac_cpp_err"; then
8200 >  ac_header_preproc=yes
8201 > else
8202 >  echo "$as_me: failed program was:" >&5
8203 > sed 's/^/| /' conftest.$ac_ext >&5
8204 >
8205 >  ac_header_preproc=no
8206 > fi
8207 > rm -f conftest.err conftest.$ac_ext
8208 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8209 > echo "${ECHO_T}$ac_header_preproc" >&6
8210 >
8211 > # So?  What about this header?
8212 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8213 >  yes:no: )
8214 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8215 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8216 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8217 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8218 >    ac_header_preproc=yes
8219 >    ;;
8220 >  no:yes:* )
8221 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8222 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8223 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8224 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8225 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8226 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8227 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8228 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8229 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8230 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8231 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8232 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8233 >    (
8234 >      cat <<\_ASBOX
8235 > ## ------------------------------ ##
8236 > ## Report this to gezelter@nd.edu ##
8237 > ## ------------------------------ ##
8238 > _ASBOX
8239 >    ) |
8240 >      sed "s/^/$as_me: WARNING:     /" >&2
8241 >    ;;
8242 > esac
8243 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8244 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8245 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8246 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8247 > else
8248 >  eval "$as_ac_Header=\$ac_header_preproc"
8249 > fi
8250 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8251 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8252 >
8253 > fi
8254 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8255 >  cat >>confdefs.h <<_ACEOF
8256 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8257 > _ACEOF
8258 >
8259 > fi
8260 >
8261 > done
8262 >
8263 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8264 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8265 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8266 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8267 > else
8268 >  if test "$cross_compiling" = yes; then
8269 >  ac_cv_func_malloc_0_nonnull=no
8270 > else
8271 >  cat >conftest.$ac_ext <<_ACEOF
8272 > /* confdefs.h.  */
8273 > _ACEOF
8274 > cat confdefs.h >>conftest.$ac_ext
8275 > cat >>conftest.$ac_ext <<_ACEOF
8276 > /* end confdefs.h.  */
8277 > #if STDC_HEADERS || HAVE_STDLIB_H
8278 > # include <stdlib.h>
8279 > #else
8280 > char *malloc ();
8281 > #endif
8282 >
8283 > #ifdef FC_DUMMY_MAIN
8284 > #ifndef FC_DUMMY_MAIN_EQ_F77
8285 > #  ifdef __cplusplus
8286 >     extern "C"
8287 > #  endif
8288 >   int FC_DUMMY_MAIN() { return 1; }
8289 > #endif
8290 > #endif
8291 > int
8292 > main ()
8293 > {
8294 > exit (malloc (0) ? 0 : 1);
8295 >  ;
8296 >  return 0;
8297 > }
8298 > _ACEOF
8299 > rm -f conftest$ac_exeext
8300 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8301 >  (eval $ac_link) 2>&5
8302 >  ac_status=$?
8303 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8304 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306 >  (eval $ac_try) 2>&5
8307 >  ac_status=$?
8308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309 >  (exit $ac_status); }; }; then
8310 >  ac_cv_func_malloc_0_nonnull=yes
8311 > else
8312 >  echo "$as_me: program exited with status $ac_status" >&5
8313 > echo "$as_me: failed program was:" >&5
8314 > sed 's/^/| /' conftest.$ac_ext >&5
8315 >
8316 > ( exit $ac_status )
8317 > ac_cv_func_malloc_0_nonnull=no
8318 > fi
8319 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8320 > fi
8321 > fi
8322 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8323 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8324 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8325 >
8326 > cat >>confdefs.h <<\_ACEOF
8327 > #define HAVE_MALLOC 1
8328 > _ACEOF
8329 >
8330 > else
8331 >  cat >>confdefs.h <<\_ACEOF
8332 > #define HAVE_MALLOC 0
8333 > _ACEOF
8334 >
8335 >   case $LIBOBJS in
8336 >    "malloc.$ac_objext"   | \
8337 >  *" malloc.$ac_objext"   | \
8338 >    "malloc.$ac_objext "* | \
8339 >  *" malloc.$ac_objext "* ) ;;
8340 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8341 > esac
8342 >
8343 >
8344 > cat >>confdefs.h <<\_ACEOF
8345 > #define malloc rpl_malloc
8346 > _ACEOF
8347 >
8348 > fi
8349 >
8350 >
8351 >
8352 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8353 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8354 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8355 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8356 > else
8357 >  if test "$cross_compiling" = yes; then
8358 >  ac_cv_func_memcmp_working=no
8359 > else
8360 >  cat >conftest.$ac_ext <<_ACEOF
8361 > /* confdefs.h.  */
8362 > _ACEOF
8363 > cat confdefs.h >>conftest.$ac_ext
8364 > cat >>conftest.$ac_ext <<_ACEOF
8365 > /* end confdefs.h.  */
8366 > $ac_includes_default
8367 > #ifdef FC_DUMMY_MAIN
8368 > #ifndef FC_DUMMY_MAIN_EQ_F77
8369 > #  ifdef __cplusplus
8370 >     extern "C"
8371 > #  endif
8372 >   int FC_DUMMY_MAIN() { return 1; }
8373 > #endif
8374 > #endif
8375 > int
8376 > main ()
8377 > {
8378 >
8379 >  /* Some versions of memcmp are not 8-bit clean.  */
8380 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8381 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8382 >    exit (1);
8383 >
8384 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8385 >     or more and with at least one buffer not starting on a 4-byte boundary.
8386 >     William Lewis provided this test program.   */
8387 >  {
8388 >    char foo[21];
8389 >    char bar[21];
8390 >    int i;
8391 >    for (i = 0; i < 4; i++)
8392 >      {
8393 >        char *a = foo + i;
8394 >        char *b = bar + i;
8395 >        strcpy (a, "--------01111111");
8396 >        strcpy (b, "--------10000000");
8397 >        if (memcmp (a, b, 16) >= 0)
8398 >          exit (1);
8399 >      }
8400 >    exit (0);
8401 >  }
8402 >
8403 >  ;
8404 >  return 0;
8405 > }
8406 > _ACEOF
8407 > rm -f conftest$ac_exeext
8408 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8409 >  (eval $ac_link) 2>&5
8410 >  ac_status=$?
8411 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8412 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8413 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8414 >  (eval $ac_try) 2>&5
8415 >  ac_status=$?
8416 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8417 >  (exit $ac_status); }; }; then
8418 >  ac_cv_func_memcmp_working=yes
8419 > else
8420 >  echo "$as_me: program exited with status $ac_status" >&5
8421 > echo "$as_me: failed program was:" >&5
8422 > sed 's/^/| /' conftest.$ac_ext >&5
8423 >
8424 > ( exit $ac_status )
8425 > ac_cv_func_memcmp_working=no
8426 > fi
8427 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8428 > fi
8429 > fi
8430 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8431 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8432 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8433 >    "memcmp.$ac_objext"   | \
8434 >  *" memcmp.$ac_objext"   | \
8435 >    "memcmp.$ac_objext "* | \
8436 >  *" memcmp.$ac_objext "* ) ;;
8437 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8438 > esac
8439 >
8440 >
8441 >
8442 > for ac_header in stdlib.h
8443 > do
8444 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8445 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8446 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8447 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8448 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8449 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8450 > fi
8451 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8452 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8453 > else
8454 >  # Is the header compilable?
8455 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8456 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8457 > cat >conftest.$ac_ext <<_ACEOF
8458 > /* confdefs.h.  */
8459 > _ACEOF
8460 > cat confdefs.h >>conftest.$ac_ext
8461 > cat >>conftest.$ac_ext <<_ACEOF
8462 > /* end confdefs.h.  */
8463 > $ac_includes_default
8464 > #include <$ac_header>
8465 > _ACEOF
8466 > rm -f conftest.$ac_objext
8467 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8468 >  (eval $ac_compile) 2>conftest.er1
8469 >  ac_status=$?
8470 >  grep -v '^ *+' conftest.er1 >conftest.err
8471 >  rm -f conftest.er1
8472 >  cat conftest.err >&5
8473 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8474 >  (exit $ac_status); } &&
8475 >         { ac_try='test -z "$ac_c_werror_flag"
8476 >                         || test ! -s conftest.err'
8477 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8478 >  (eval $ac_try) 2>&5
8479 >  ac_status=$?
8480 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8481 >  (exit $ac_status); }; } &&
8482 >         { ac_try='test -s conftest.$ac_objext'
8483 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8484 >  (eval $ac_try) 2>&5
8485 >  ac_status=$?
8486 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8487 >  (exit $ac_status); }; }; then
8488 >  ac_header_compiler=yes
8489 > else
8490 >  echo "$as_me: failed program was:" >&5
8491 > sed 's/^/| /' conftest.$ac_ext >&5
8492 >
8493 > ac_header_compiler=no
8494 > fi
8495 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8496 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8497 > echo "${ECHO_T}$ac_header_compiler" >&6
8498 >
8499 > # Is the header present?
8500 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8501 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8502 > cat >conftest.$ac_ext <<_ACEOF
8503 > /* confdefs.h.  */
8504 > _ACEOF
8505 > cat confdefs.h >>conftest.$ac_ext
8506 > cat >>conftest.$ac_ext <<_ACEOF
8507 > /* end confdefs.h.  */
8508 > #include <$ac_header>
8509 > _ACEOF
8510 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8511 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8512 >  ac_status=$?
8513 >  grep -v '^ *+' conftest.er1 >conftest.err
8514 >  rm -f conftest.er1
8515 >  cat conftest.err >&5
8516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8517 >  (exit $ac_status); } >/dev/null; then
8518 >  if test -s conftest.err; then
8519 >    ac_cpp_err=$ac_c_preproc_warn_flag
8520 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8521 >  else
8522 >    ac_cpp_err=
8523 >  fi
8524 > else
8525 >  ac_cpp_err=yes
8526 > fi
8527 > if test -z "$ac_cpp_err"; then
8528 >  ac_header_preproc=yes
8529 > else
8530 >  echo "$as_me: failed program was:" >&5
8531 > sed 's/^/| /' conftest.$ac_ext >&5
8532 >
8533 >  ac_header_preproc=no
8534 > fi
8535 > rm -f conftest.err conftest.$ac_ext
8536 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8537 > echo "${ECHO_T}$ac_header_preproc" >&6
8538 >
8539 > # So?  What about this header?
8540 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8541 >  yes:no: )
8542 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8543 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8544 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8545 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8546 >    ac_header_preproc=yes
8547 >    ;;
8548 >  no:yes:* )
8549 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8550 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8551 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8552 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8553 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8554 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8555 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8556 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8557 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8558 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8559 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8560 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8561 >    (
8562 >      cat <<\_ASBOX
8563 > ## ------------------------------ ##
8564 > ## Report this to gezelter@nd.edu ##
8565 > ## ------------------------------ ##
8566 > _ASBOX
8567 >    ) |
8568 >      sed "s/^/$as_me: WARNING:     /" >&2
8569 >    ;;
8570 > esac
8571 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8572 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8573 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8574 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8575 > else
8576 >  eval "$as_ac_Header=\$ac_header_preproc"
8577 > fi
8578 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8579 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8580 >
8581 > fi
8582 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8583 >  cat >>confdefs.h <<_ACEOF
8584 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8585 > _ACEOF
8586 >
8587 > fi
8588 >
8589 > done
8590 >
8591 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8592 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8593 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8594 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8595 > else
8596 >  if test "$cross_compiling" = yes; then
8597 >  ac_cv_func_realloc_0_nonnull=no
8598 > else
8599 >  cat >conftest.$ac_ext <<_ACEOF
8600 > /* confdefs.h.  */
8601 > _ACEOF
8602 > cat confdefs.h >>conftest.$ac_ext
8603 > cat >>conftest.$ac_ext <<_ACEOF
8604 > /* end confdefs.h.  */
8605 > #if STDC_HEADERS || HAVE_STDLIB_H
8606 > # include <stdlib.h>
8607 > #else
8608 > char *realloc ();
8609 > #endif
8610 >
8611 > #ifdef FC_DUMMY_MAIN
8612 > #ifndef FC_DUMMY_MAIN_EQ_F77
8613 > #  ifdef __cplusplus
8614 >     extern "C"
8615 > #  endif
8616 >   int FC_DUMMY_MAIN() { return 1; }
8617 > #endif
8618 > #endif
8619 > int
8620 > main ()
8621 > {
8622 > exit (realloc (0, 0) ? 0 : 1);
8623 >  ;
8624 >  return 0;
8625 > }
8626 > _ACEOF
8627 > rm -f conftest$ac_exeext
8628 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8629 >  (eval $ac_link) 2>&5
8630 >  ac_status=$?
8631 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8632 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8633 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8634 >  (eval $ac_try) 2>&5
8635 >  ac_status=$?
8636 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8637 >  (exit $ac_status); }; }; then
8638 >  ac_cv_func_realloc_0_nonnull=yes
8639 > else
8640 >  echo "$as_me: program exited with status $ac_status" >&5
8641 > echo "$as_me: failed program was:" >&5
8642 > sed 's/^/| /' conftest.$ac_ext >&5
8643 >
8644 > ( exit $ac_status )
8645 > ac_cv_func_realloc_0_nonnull=no
8646 > fi
8647 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8648 > fi
8649 > fi
8650 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8651 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8652 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8653 >
8654 > cat >>confdefs.h <<\_ACEOF
8655 > #define HAVE_REALLOC 1
8656 > _ACEOF
8657 >
8658 > else
8659 >  cat >>confdefs.h <<\_ACEOF
8660 > #define HAVE_REALLOC 0
8661 > _ACEOF
8662 >
8663 >   case $LIBOBJS in
8664 >    "realloc.$ac_objext"   | \
8665 >  *" realloc.$ac_objext"   | \
8666 >    "realloc.$ac_objext "* | \
8667 >  *" realloc.$ac_objext "* ) ;;
8668 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8669 > esac
8670 >
8671 >
8672 > cat >>confdefs.h <<\_ACEOF
8673 > #define realloc rpl_realloc
8674 > _ACEOF
8675 >
8676 > fi
8677 >
8678 >
8679 >
8680 >
8681 >
8682 > for ac_header in sys/select.h sys/socket.h
8683 > do
8684 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8685 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8686 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8687 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8688 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8689 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8690 > fi
8691 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8692 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8693 > else
8694 >  # Is the header compilable?
8695 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8696 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8697 > cat >conftest.$ac_ext <<_ACEOF
8698 > /* confdefs.h.  */
8699 > _ACEOF
8700 > cat confdefs.h >>conftest.$ac_ext
8701 > cat >>conftest.$ac_ext <<_ACEOF
8702 > /* end confdefs.h.  */
8703 > $ac_includes_default
8704 > #include <$ac_header>
8705 > _ACEOF
8706 > rm -f conftest.$ac_objext
8707 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8708 >  (eval $ac_compile) 2>conftest.er1
8709 >  ac_status=$?
8710 >  grep -v '^ *+' conftest.er1 >conftest.err
8711 >  rm -f conftest.er1
8712 >  cat conftest.err >&5
8713 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8714 >  (exit $ac_status); } &&
8715 >         { ac_try='test -z "$ac_c_werror_flag"
8716 >                         || test ! -s conftest.err'
8717 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8718 >  (eval $ac_try) 2>&5
8719 >  ac_status=$?
8720 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8721 >  (exit $ac_status); }; } &&
8722 >         { ac_try='test -s conftest.$ac_objext'
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); }; }; then
8728 >  ac_header_compiler=yes
8729 > else
8730 >  echo "$as_me: failed program was:" >&5
8731 > sed 's/^/| /' conftest.$ac_ext >&5
8732 >
8733 > ac_header_compiler=no
8734 > fi
8735 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8736 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8737 > echo "${ECHO_T}$ac_header_compiler" >&6
8738 >
8739 > # Is the header present?
8740 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8741 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8742 > cat >conftest.$ac_ext <<_ACEOF
8743 > /* confdefs.h.  */
8744 > _ACEOF
8745 > cat confdefs.h >>conftest.$ac_ext
8746 > cat >>conftest.$ac_ext <<_ACEOF
8747 > /* end confdefs.h.  */
8748 > #include <$ac_header>
8749 > _ACEOF
8750 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8751 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8752 >  ac_status=$?
8753 >  grep -v '^ *+' conftest.er1 >conftest.err
8754 >  rm -f conftest.er1
8755 >  cat conftest.err >&5
8756 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8757 >  (exit $ac_status); } >/dev/null; then
8758 >  if test -s conftest.err; then
8759 >    ac_cpp_err=$ac_c_preproc_warn_flag
8760 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8761 >  else
8762 >    ac_cpp_err=
8763 >  fi
8764 > else
8765 >  ac_cpp_err=yes
8766 > fi
8767 > if test -z "$ac_cpp_err"; then
8768 >  ac_header_preproc=yes
8769 > else
8770 >  echo "$as_me: failed program was:" >&5
8771 > sed 's/^/| /' conftest.$ac_ext >&5
8772 >
8773 >  ac_header_preproc=no
8774 > fi
8775 > rm -f conftest.err conftest.$ac_ext
8776 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8777 > echo "${ECHO_T}$ac_header_preproc" >&6
8778 >
8779 > # So?  What about this header?
8780 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8781 >  yes:no: )
8782 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8783 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8784 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8785 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8786 >    ac_header_preproc=yes
8787 >    ;;
8788 >  no:yes:* )
8789 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8790 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8791 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8792 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8793 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8794 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8795 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8796 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8797 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8798 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8799 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8800 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8801 >    (
8802 >      cat <<\_ASBOX
8803 > ## ------------------------------ ##
8804 > ## Report this to gezelter@nd.edu ##
8805 > ## ------------------------------ ##
8806 > _ASBOX
8807 >    ) |
8808 >      sed "s/^/$as_me: WARNING:     /" >&2
8809 >    ;;
8810 > esac
8811 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8812 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8813 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8814 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8815 > else
8816 >  eval "$as_ac_Header=\$ac_header_preproc"
8817 > fi
8818 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8819 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8820 >
8821 > fi
8822 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8823 >  cat >>confdefs.h <<_ACEOF
8824 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8825 > _ACEOF
8826 >
8827 > fi
8828 >
8829 > done
8830 >
8831 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8832 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8833 > if test "${ac_cv_func_select_args+set}" = set; then
8834 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8835 > else
8836 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8837 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8838 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8839 >   cat >conftest.$ac_ext <<_ACEOF
8840 > /* confdefs.h.  */
8841 > _ACEOF
8842 > cat confdefs.h >>conftest.$ac_ext
8843 > cat >>conftest.$ac_ext <<_ACEOF
8844 > /* end confdefs.h.  */
8845 > $ac_includes_default
8846 > #if HAVE_SYS_SELECT_H
8847 > # include <sys/select.h>
8848 > #endif
8849 > #if HAVE_SYS_SOCKET_H
8850 > # include <sys/socket.h>
8851 > #endif
8852 >
8853 > #ifdef FC_DUMMY_MAIN
8854 > #ifndef FC_DUMMY_MAIN_EQ_F77
8855 > #  ifdef __cplusplus
8856 >     extern "C"
8857 > #  endif
8858 >   int FC_DUMMY_MAIN() { return 1; }
8859 > #endif
8860 > #endif
8861 > int
8862 > main ()
8863 > {
8864 > extern int select ($ac_arg1,
8865 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8866 >                                            $ac_arg5);
8867 >  ;
8868 >  return 0;
8869 > }
8870 > _ACEOF
8871 > rm -f conftest.$ac_objext
8872 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8873 >  (eval $ac_compile) 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); } &&
8880 >         { ac_try='test -z "$ac_c_werror_flag"
8881 >                         || test ! -s conftest.err'
8882 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8883 >  (eval $ac_try) 2>&5
8884 >  ac_status=$?
8885 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8886 >  (exit $ac_status); }; } &&
8887 >         { ac_try='test -s conftest.$ac_objext'
8888 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8889 >  (eval $ac_try) 2>&5
8890 >  ac_status=$?
8891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8892 >  (exit $ac_status); }; }; then
8893 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8894 > else
8895 >  echo "$as_me: failed program was:" >&5
8896 > sed 's/^/| /' conftest.$ac_ext >&5
8897 >
8898 > fi
8899 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8900 >  done
8901 > done
8902 > done
8903 > # Provide a safe default value.
8904 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8905 >
8906 > fi
8907 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8908 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8909 > ac_save_IFS=$IFS; IFS=','
8910 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8911 > IFS=$ac_save_IFS
8912 > shift
8913 >
8914 > cat >>confdefs.h <<_ACEOF
8915 > #define SELECT_TYPE_ARG1 $1
8916 > _ACEOF
8917 >
8918 >
8919 > cat >>confdefs.h <<_ACEOF
8920 > #define SELECT_TYPE_ARG234 ($2)
8921 > _ACEOF
8922 >
8923 >
8924 > cat >>confdefs.h <<_ACEOF
8925 > #define SELECT_TYPE_ARG5 ($3)
8926 > _ACEOF
8927 >
8928 > rm -f conftest*
8929 >
8930 >
8931 > for ac_func in strftime
8932 > do
8933 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8934 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8935 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8936 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8937 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8938 > else
8939 >  cat >conftest.$ac_ext <<_ACEOF
8940 > /* confdefs.h.  */
8941 > _ACEOF
8942 > cat confdefs.h >>conftest.$ac_ext
8943 > cat >>conftest.$ac_ext <<_ACEOF
8944 > /* end confdefs.h.  */
8945 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8946 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8947 > #define $ac_func innocuous_$ac_func
8948 >
8949 > /* System header to define __stub macros and hopefully few prototypes,
8950 >    which can conflict with char $ac_func (); below.
8951 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8952 >    <limits.h> exists even on freestanding compilers.  */
8953 >
8954 > #ifdef __STDC__
8955 > # include <limits.h>
8956 > #else
8957 > # include <assert.h>
8958 > #endif
8959 >
8960 > #undef $ac_func
8961 >
8962 > /* Override any gcc2 internal prototype to avoid an error.  */
8963 > #ifdef __cplusplus
8964 > extern "C"
8965 > {
8966 > #endif
8967 > /* We use char because int might match the return type of a gcc2
8968 >   builtin and then its argument prototype would still apply.  */
8969 > char $ac_func ();
8970 > /* The GNU C library defines this for functions which it implements
8971 >    to always fail with ENOSYS.  Some functions are actually named
8972 >    something starting with __ and the normal name is an alias.  */
8973 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8974 > choke me
8975 > #else
8976 > char (*f) () = $ac_func;
8977 > #endif
8978 > #ifdef __cplusplus
8979 > }
8980 > #endif
8981 >
8982 > #ifdef FC_DUMMY_MAIN
8983 > #ifndef FC_DUMMY_MAIN_EQ_F77
8984 > #  ifdef __cplusplus
8985 >     extern "C"
8986 > #  endif
8987 >   int FC_DUMMY_MAIN() { return 1; }
8988 > #endif
8989 > #endif
8990 > int
8991 > main ()
8992 > {
8993 > return f != $ac_func;
8994 >  ;
8995 >  return 0;
8996 > }
8997 > _ACEOF
8998 > rm -f conftest.$ac_objext conftest$ac_exeext
8999 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9000 >  (eval $ac_link) 2>conftest.er1
9001 >  ac_status=$?
9002 >  grep -v '^ *+' conftest.er1 >conftest.err
9003 >  rm -f conftest.er1
9004 >  cat conftest.err >&5
9005 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9006 >  (exit $ac_status); } &&
9007 >         { ac_try='test -z "$ac_c_werror_flag"
9008 >                         || test ! -s conftest.err'
9009 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9010 >  (eval $ac_try) 2>&5
9011 >  ac_status=$?
9012 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9013 >  (exit $ac_status); }; } &&
9014 >         { ac_try='test -s conftest$ac_exeext'
9015 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9016 >  (eval $ac_try) 2>&5
9017 >  ac_status=$?
9018 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9019 >  (exit $ac_status); }; }; then
9020 >  eval "$as_ac_var=yes"
9021 > else
9022 >  echo "$as_me: failed program was:" >&5
9023 > sed 's/^/| /' conftest.$ac_ext >&5
9024 >
9025 > eval "$as_ac_var=no"
9026 > fi
9027 > rm -f conftest.err conftest.$ac_objext \
9028 >      conftest$ac_exeext conftest.$ac_ext
9029 > fi
9030 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9031 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9032 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9033 >  cat >>confdefs.h <<_ACEOF
9034 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9035 > _ACEOF
9036 >
9037 > else
9038 >  # strftime is in -lintl on SCO UNIX.
9039 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9040 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9041 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9042 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9043 > else
9044 >  ac_check_lib_save_LIBS=$LIBS
9045 > LIBS="-lintl  $LIBS"
9046 > cat >conftest.$ac_ext <<_ACEOF
9047 > /* confdefs.h.  */
9048 > _ACEOF
9049 > cat confdefs.h >>conftest.$ac_ext
9050 > cat >>conftest.$ac_ext <<_ACEOF
9051 > /* end confdefs.h.  */
9052 >
9053 > /* Override any gcc2 internal prototype to avoid an error.  */
9054 > #ifdef __cplusplus
9055 > extern "C"
9056 > #endif
9057 > /* We use char because int might match the return type of a gcc2
9058 >   builtin and then its argument prototype would still apply.  */
9059 > char strftime ();
9060 > #ifdef FC_DUMMY_MAIN
9061 > #ifndef FC_DUMMY_MAIN_EQ_F77
9062 > #  ifdef __cplusplus
9063 >     extern "C"
9064 > #  endif
9065 >   int FC_DUMMY_MAIN() { return 1; }
9066 > #endif
9067 > #endif
9068 > int
9069 > main ()
9070 > {
9071 > strftime ();
9072 >  ;
9073 >  return 0;
9074 > }
9075 > _ACEOF
9076 > rm -f conftest.$ac_objext conftest$ac_exeext
9077 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9078 >  (eval $ac_link) 2>conftest.er1
9079 >  ac_status=$?
9080 >  grep -v '^ *+' conftest.er1 >conftest.err
9081 >  rm -f conftest.er1
9082 >  cat conftest.err >&5
9083 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9084 >  (exit $ac_status); } &&
9085 >         { ac_try='test -z "$ac_c_werror_flag"
9086 >                         || test ! -s conftest.err'
9087 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9088 >  (eval $ac_try) 2>&5
9089 >  ac_status=$?
9090 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9091 >  (exit $ac_status); }; } &&
9092 >         { ac_try='test -s conftest$ac_exeext'
9093 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9094 >  (eval $ac_try) 2>&5
9095 >  ac_status=$?
9096 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9097 >  (exit $ac_status); }; }; then
9098 >  ac_cv_lib_intl_strftime=yes
9099 > else
9100 >  echo "$as_me: failed program was:" >&5
9101 > sed 's/^/| /' conftest.$ac_ext >&5
9102 >
9103 > ac_cv_lib_intl_strftime=no
9104 > fi
9105 > rm -f conftest.err conftest.$ac_objext \
9106 >      conftest$ac_exeext conftest.$ac_ext
9107 > LIBS=$ac_check_lib_save_LIBS
9108 > fi
9109 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9110 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9111 > if test $ac_cv_lib_intl_strftime = yes; then
9112 >  cat >>confdefs.h <<\_ACEOF
9113 > #define HAVE_STRFTIME 1
9114 > _ACEOF
9115 >
9116 > LIBS="-lintl $LIBS"
9117 > fi
9118 >
9119 > fi
9120 > done
9121 >
9122 > echo "$as_me:$LINENO: checking for working strtod" >&5
9123 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9124 > if test "${ac_cv_func_strtod+set}" = set; then
9125 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9126 > else
9127 >  if test "$cross_compiling" = yes; then
9128 >  ac_cv_func_strtod=no
9129 > else
9130 >  cat >conftest.$ac_ext <<_ACEOF
9131 > /* confdefs.h.  */
9132 > _ACEOF
9133 > cat confdefs.h >>conftest.$ac_ext
9134 > cat >>conftest.$ac_ext <<_ACEOF
9135 > /* end confdefs.h.  */
9136 >
9137 > double strtod ();
9138 > int
9139 > main()
9140 > {
9141 >  {
9142 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9143 >    char *string = " +69";
9144 >    char *term;
9145 >    double value;
9146 >    value = strtod (string, &term);
9147 >    if (value != 69 || term != (string + 4))
9148 >      exit (1);
9149 >  }
9150 >
9151 >  {
9152 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9153 >       terminating character under some conditions.  */
9154 >    char *string = "NaN";
9155 >    char *term;
9156 >    strtod (string, &term);
9157 >    if (term != string && *(term - 1) == 0)
9158 >      exit (1);
9159 >  }
9160 >  exit (0);
9161 > }
9162 >
9163 > _ACEOF
9164 > rm -f conftest$ac_exeext
9165 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9166 >  (eval $ac_link) 2>&5
9167 >  ac_status=$?
9168 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9169 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9170 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9171 >  (eval $ac_try) 2>&5
9172 >  ac_status=$?
9173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174 >  (exit $ac_status); }; }; then
9175 >  ac_cv_func_strtod=yes
9176 > else
9177 >  echo "$as_me: program exited with status $ac_status" >&5
9178 > echo "$as_me: failed program was:" >&5
9179 > sed 's/^/| /' conftest.$ac_ext >&5
9180 >
9181 > ( exit $ac_status )
9182 > ac_cv_func_strtod=no
9183 > fi
9184 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9185 > fi
9186 > fi
9187 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9188 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9189 > if test $ac_cv_func_strtod = no; then
9190 >  case $LIBOBJS in
9191 >    "strtod.$ac_objext"   | \
9192 >  *" strtod.$ac_objext"   | \
9193 >    "strtod.$ac_objext "* | \
9194 >  *" strtod.$ac_objext "* ) ;;
9195 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9196 > esac
9197 >
9198 > echo "$as_me:$LINENO: checking for pow" >&5
9199 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9200 > if test "${ac_cv_func_pow+set}" = set; then
9201 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9202 > else
9203 >  cat >conftest.$ac_ext <<_ACEOF
9204 > /* confdefs.h.  */
9205 > _ACEOF
9206 > cat confdefs.h >>conftest.$ac_ext
9207 > cat >>conftest.$ac_ext <<_ACEOF
9208 > /* end confdefs.h.  */
9209 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9210 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9211 > #define pow innocuous_pow
9212 >
9213 > /* System header to define __stub macros and hopefully few prototypes,
9214 >    which can conflict with char pow (); below.
9215 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9216 >    <limits.h> exists even on freestanding compilers.  */
9217 >
9218 > #ifdef __STDC__
9219 > # include <limits.h>
9220 > #else
9221 > # include <assert.h>
9222 > #endif
9223 >
9224 > #undef pow
9225 >
9226 > /* Override any gcc2 internal prototype to avoid an error.  */
9227 > #ifdef __cplusplus
9228 > extern "C"
9229 > {
9230 > #endif
9231 > /* We use char because int might match the return type of a gcc2
9232 >   builtin and then its argument prototype would still apply.  */
9233 > char pow ();
9234 > /* The GNU C library defines this for functions which it implements
9235 >    to always fail with ENOSYS.  Some functions are actually named
9236 >    something starting with __ and the normal name is an alias.  */
9237 > #if defined (__stub_pow) || defined (__stub___pow)
9238 > choke me
9239 > #else
9240 > char (*f) () = pow;
9241 > #endif
9242 > #ifdef __cplusplus
9243 > }
9244 > #endif
9245 >
9246 > #ifdef FC_DUMMY_MAIN
9247 > #ifndef FC_DUMMY_MAIN_EQ_F77
9248 > #  ifdef __cplusplus
9249 >     extern "C"
9250 > #  endif
9251 >   int FC_DUMMY_MAIN() { return 1; }
9252 > #endif
9253 > #endif
9254 > int
9255 > main ()
9256 > {
9257 > return f != pow;
9258 >  ;
9259 >  return 0;
9260 > }
9261 > _ACEOF
9262 > rm -f conftest.$ac_objext conftest$ac_exeext
9263 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9264 >  (eval $ac_link) 2>conftest.er1
9265 >  ac_status=$?
9266 >  grep -v '^ *+' conftest.er1 >conftest.err
9267 >  rm -f conftest.er1
9268 >  cat conftest.err >&5
9269 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9270 >  (exit $ac_status); } &&
9271 >         { ac_try='test -z "$ac_c_werror_flag"
9272 >                         || test ! -s conftest.err'
9273 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9274 >  (eval $ac_try) 2>&5
9275 >  ac_status=$?
9276 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9277 >  (exit $ac_status); }; } &&
9278 >         { ac_try='test -s conftest$ac_exeext'
9279 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9280 >  (eval $ac_try) 2>&5
9281 >  ac_status=$?
9282 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9283 >  (exit $ac_status); }; }; then
9284 >  ac_cv_func_pow=yes
9285 > else
9286 >  echo "$as_me: failed program was:" >&5
9287 > sed 's/^/| /' conftest.$ac_ext >&5
9288 >
9289 > ac_cv_func_pow=no
9290 > fi
9291 > rm -f conftest.err conftest.$ac_objext \
9292 >      conftest$ac_exeext conftest.$ac_ext
9293 > fi
9294 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9295 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9296 >
9297 > if test $ac_cv_func_pow = no; then
9298 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9299 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9300 > if test "${ac_cv_lib_m_pow+set}" = set; then
9301 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9302 > else
9303 >  ac_check_lib_save_LIBS=$LIBS
9304 > LIBS="-lm  $LIBS"
9305 > cat >conftest.$ac_ext <<_ACEOF
9306 > /* confdefs.h.  */
9307 > _ACEOF
9308 > cat confdefs.h >>conftest.$ac_ext
9309 > cat >>conftest.$ac_ext <<_ACEOF
9310 > /* end confdefs.h.  */
9311 >
9312 > /* Override any gcc2 internal prototype to avoid an error.  */
9313 > #ifdef __cplusplus
9314 > extern "C"
9315 > #endif
9316 > /* We use char because int might match the return type of a gcc2
9317 >   builtin and then its argument prototype would still apply.  */
9318 > char pow ();
9319 > #ifdef FC_DUMMY_MAIN
9320 > #ifndef FC_DUMMY_MAIN_EQ_F77
9321 > #  ifdef __cplusplus
9322 >     extern "C"
9323 > #  endif
9324 >   int FC_DUMMY_MAIN() { return 1; }
9325 > #endif
9326 > #endif
9327 > int
9328 > main ()
9329 > {
9330 > pow ();
9331 >  ;
9332 >  return 0;
9333 > }
9334 > _ACEOF
9335 > rm -f conftest.$ac_objext conftest$ac_exeext
9336 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9337 >  (eval $ac_link) 2>conftest.er1
9338 >  ac_status=$?
9339 >  grep -v '^ *+' conftest.er1 >conftest.err
9340 >  rm -f conftest.er1
9341 >  cat conftest.err >&5
9342 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9343 >  (exit $ac_status); } &&
9344 >         { ac_try='test -z "$ac_c_werror_flag"
9345 >                         || test ! -s conftest.err'
9346 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9347 >  (eval $ac_try) 2>&5
9348 >  ac_status=$?
9349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9350 >  (exit $ac_status); }; } &&
9351 >         { ac_try='test -s conftest$ac_exeext'
9352 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9353 >  (eval $ac_try) 2>&5
9354 >  ac_status=$?
9355 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9356 >  (exit $ac_status); }; }; then
9357 >  ac_cv_lib_m_pow=yes
9358 > else
9359 >  echo "$as_me: failed program was:" >&5
9360 > sed 's/^/| /' conftest.$ac_ext >&5
9361 >
9362 > ac_cv_lib_m_pow=no
9363 > fi
9364 > rm -f conftest.err conftest.$ac_objext \
9365 >      conftest$ac_exeext conftest.$ac_ext
9366 > LIBS=$ac_check_lib_save_LIBS
9367 > fi
9368 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9369 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9370 > if test $ac_cv_lib_m_pow = yes; then
9371 >  POW_LIB=-lm
9372 > else
9373 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9374 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9375 > fi
9376 >
9377 > fi
9378 >
9379 > fi
9380 >
9381 >
9382 >
9383 >
9384 >
9385 >
9386 >
9387 >
9388 >
9389 >
9390 >
9391 >
9392 >
9393 >
9394 >
9395 >
9396 >
9397 >
9398 >
9399 >
9400 >
9401 >
9402 >
9403 >
9404 >
9405 >
9406 >
9407 >
9408 > 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
9409 > do
9410 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9411 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9412 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9413 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9414 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9415 > else
9416 >  cat >conftest.$ac_ext <<_ACEOF
9417 > /* confdefs.h.  */
9418 > _ACEOF
9419 > cat confdefs.h >>conftest.$ac_ext
9420 > cat >>conftest.$ac_ext <<_ACEOF
9421 > /* end confdefs.h.  */
9422 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9423 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9424 > #define $ac_func innocuous_$ac_func
9425 >
9426 > /* System header to define __stub macros and hopefully few prototypes,
9427 >    which can conflict with char $ac_func (); below.
9428 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9429 >    <limits.h> exists even on freestanding compilers.  */
9430 >
9431 > #ifdef __STDC__
9432 > # include <limits.h>
9433 > #else
9434 > # include <assert.h>
9435 > #endif
9436 >
9437 > #undef $ac_func
9438 >
9439 > /* Override any gcc2 internal prototype to avoid an error.  */
9440 > #ifdef __cplusplus
9441 > extern "C"
9442 > {
9443 > #endif
9444 > /* We use char because int might match the return type of a gcc2
9445 >   builtin and then its argument prototype would still apply.  */
9446 > char $ac_func ();
9447 > /* The GNU C library defines this for functions which it implements
9448 >    to always fail with ENOSYS.  Some functions are actually named
9449 >    something starting with __ and the normal name is an alias.  */
9450 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9451 > choke me
9452 > #else
9453 > char (*f) () = $ac_func;
9454 > #endif
9455 > #ifdef __cplusplus
9456 > }
9457 > #endif
9458 >
9459 > #ifdef FC_DUMMY_MAIN
9460 > #ifndef FC_DUMMY_MAIN_EQ_F77
9461 > #  ifdef __cplusplus
9462 >     extern "C"
9463 > #  endif
9464 >   int FC_DUMMY_MAIN() { return 1; }
9465 > #endif
9466 > #endif
9467 > int
9468 > main ()
9469 > {
9470 > return f != $ac_func;
9471 >  ;
9472 >  return 0;
9473 > }
9474 > _ACEOF
9475 > rm -f conftest.$ac_objext conftest$ac_exeext
9476 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9477 >  (eval $ac_link) 2>conftest.er1
9478 >  ac_status=$?
9479 >  grep -v '^ *+' conftest.er1 >conftest.err
9480 >  rm -f conftest.er1
9481 >  cat conftest.err >&5
9482 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9483 >  (exit $ac_status); } &&
9484 >         { ac_try='test -z "$ac_c_werror_flag"
9485 >                         || test ! -s conftest.err'
9486 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9487 >  (eval $ac_try) 2>&5
9488 >  ac_status=$?
9489 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9490 >  (exit $ac_status); }; } &&
9491 >         { ac_try='test -s conftest$ac_exeext'
9492 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9493 >  (eval $ac_try) 2>&5
9494 >  ac_status=$?
9495 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9496 >  (exit $ac_status); }; }; then
9497 >  eval "$as_ac_var=yes"
9498 > else
9499 >  echo "$as_me: failed program was:" >&5
9500 > sed 's/^/| /' conftest.$ac_ext >&5
9501 >
9502 > eval "$as_ac_var=no"
9503 > fi
9504 > rm -f conftest.err conftest.$ac_objext \
9505 >      conftest$ac_exeext conftest.$ac_ext
9506 > fi
9507 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9508 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9509 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9510 >  cat >>confdefs.h <<_ACEOF
9511 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9512 > _ACEOF
9513 >
9514 > fi
9515 > done
9516 >
9517 >
9518 > # special check for _system_configuration because AIX <4.3.2 do not
9519 > # contain the `physmem' member.
9520 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9521 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9522 > cat >conftest.$ac_ext <<_ACEOF
9523 > /* confdefs.h.  */
9524 > _ACEOF
9525 > cat confdefs.h >>conftest.$ac_ext
9526 > cat >>conftest.$ac_ext <<_ACEOF
9527 > /* end confdefs.h.  */
9528 > #include <sys/systemcfg.h>
9529 > #ifdef FC_DUMMY_MAIN
9530 > #ifndef FC_DUMMY_MAIN_EQ_F77
9531 > #  ifdef __cplusplus
9532 >     extern "C"
9533 > #  endif
9534 >   int FC_DUMMY_MAIN() { return 1; }
9535 > #endif
9536 > #endif
9537 > int
9538 > main ()
9539 > {
9540 > double x = _system_configuration.physmem;
9541 >  ;
9542 >  return 0;
9543 > }
9544 > _ACEOF
9545 > rm -f conftest.$ac_objext
9546 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9547 >  (eval $ac_compile) 2>conftest.er1
9548 >  ac_status=$?
9549 >  grep -v '^ *+' conftest.er1 >conftest.err
9550 >  rm -f conftest.er1
9551 >  cat conftest.err >&5
9552 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9553 >  (exit $ac_status); } &&
9554 >         { ac_try='test -z "$ac_c_werror_flag"
9555 >                         || test ! -s conftest.err'
9556 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9557 >  (eval $ac_try) 2>&5
9558 >  ac_status=$?
9559 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9560 >  (exit $ac_status); }; } &&
9561 >         { ac_try='test -s conftest.$ac_objext'
9562 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9563 >  (eval $ac_try) 2>&5
9564 >  ac_status=$?
9565 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9566 >  (exit $ac_status); }; }; then
9567 >  echo "$as_me:$LINENO: result: yes" >&5
9568 > echo "${ECHO_T}yes" >&6
9569 >
9570 > cat >>confdefs.h <<\_ACEOF
9571 > #define HAVE__SYSTEM_CONFIGURATION 1
9572 > _ACEOF
9573 >
9574 > else
9575 >  echo "$as_me: failed program was:" >&5
9576 > sed 's/^/| /' conftest.$ac_ext >&5
9577 >
9578 > echo "$as_me:$LINENO: result: no" >&5
9579 > echo "${ECHO_T}no" >&6
9580 > fi
9581 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9582 >
9583 >  # clean out junk possibly left behind by a previous configuration
9584 >  rm -f src/getopt.h
9585 >  # Check for getopt_long support
9586 >
9587 > for ac_header in getopt.h
9588 > do
9589 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9590 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9591 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9592 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9593 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9594 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9595 > fi
9596 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9597 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9598 > else
9599 >  # Is the header compilable?
9600 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9601 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9602 > cat >conftest.$ac_ext <<_ACEOF
9603 > /* confdefs.h.  */
9604 > _ACEOF
9605 > cat confdefs.h >>conftest.$ac_ext
9606 > cat >>conftest.$ac_ext <<_ACEOF
9607 > /* end confdefs.h.  */
9608 > $ac_includes_default
9609 > #include <$ac_header>
9610 > _ACEOF
9611 > rm -f conftest.$ac_objext
9612 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9613 >  (eval $ac_compile) 2>conftest.er1
9614 >  ac_status=$?
9615 >  grep -v '^ *+' conftest.er1 >conftest.err
9616 >  rm -f conftest.er1
9617 >  cat conftest.err >&5
9618 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9619 >  (exit $ac_status); } &&
9620 >         { ac_try='test -z "$ac_c_werror_flag"
9621 >                         || test ! -s conftest.err'
9622 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9623 >  (eval $ac_try) 2>&5
9624 >  ac_status=$?
9625 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9626 >  (exit $ac_status); }; } &&
9627 >         { ac_try='test -s conftest.$ac_objext'
9628 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9629 >  (eval $ac_try) 2>&5
9630 >  ac_status=$?
9631 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9632 >  (exit $ac_status); }; }; then
9633 >  ac_header_compiler=yes
9634 > else
9635 >  echo "$as_me: failed program was:" >&5
9636 > sed 's/^/| /' conftest.$ac_ext >&5
9637 >
9638 > ac_header_compiler=no
9639 > fi
9640 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9641 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9642 > echo "${ECHO_T}$ac_header_compiler" >&6
9643 >
9644 > # Is the header present?
9645 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9646 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9647 > cat >conftest.$ac_ext <<_ACEOF
9648 > /* confdefs.h.  */
9649 > _ACEOF
9650 > cat confdefs.h >>conftest.$ac_ext
9651 > cat >>conftest.$ac_ext <<_ACEOF
9652 > /* end confdefs.h.  */
9653 > #include <$ac_header>
9654 > _ACEOF
9655 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9656 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9657 >  ac_status=$?
9658 >  grep -v '^ *+' conftest.er1 >conftest.err
9659 >  rm -f conftest.er1
9660 >  cat conftest.err >&5
9661 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9662 >  (exit $ac_status); } >/dev/null; then
9663 >  if test -s conftest.err; then
9664 >    ac_cpp_err=$ac_c_preproc_warn_flag
9665 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9666 >  else
9667 >    ac_cpp_err=
9668 >  fi
9669 > else
9670 >  ac_cpp_err=yes
9671 > fi
9672 > if test -z "$ac_cpp_err"; then
9673 >  ac_header_preproc=yes
9674 > else
9675 >  echo "$as_me: failed program was:" >&5
9676 > sed 's/^/| /' conftest.$ac_ext >&5
9677 >
9678 >  ac_header_preproc=no
9679 > fi
9680 > rm -f conftest.err conftest.$ac_ext
9681 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9682 > echo "${ECHO_T}$ac_header_preproc" >&6
9683 >
9684 > # So?  What about this header?
9685 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9686 >  yes:no: )
9687 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9688 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9689 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9690 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9691 >    ac_header_preproc=yes
9692 >    ;;
9693 >  no:yes:* )
9694 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9695 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9696 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9697 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9698 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9699 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9700 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9701 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9702 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9703 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9704 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9705 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9706 >    (
9707 >      cat <<\_ASBOX
9708 > ## ------------------------------ ##
9709 > ## Report this to gezelter@nd.edu ##
9710 > ## ------------------------------ ##
9711 > _ASBOX
9712 >    ) |
9713 >      sed "s/^/$as_me: WARNING:     /" >&2
9714 >    ;;
9715 > esac
9716 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9717 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9718 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9719 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9720 > else
9721 >  eval "$as_ac_Header=\$ac_header_preproc"
9722 > fi
9723 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9724 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9725 >
9726 > fi
9727 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9728 >  cat >>confdefs.h <<_ACEOF
9729 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9730 > _ACEOF
9731 >
9732 > fi
9733 >
9734 > done
9735 >
9736 >
9737 > for ac_func in getopt_long
9738 > do
9739 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9740 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9741 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9742 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9743 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9744 > else
9745 >  cat >conftest.$ac_ext <<_ACEOF
9746 > /* confdefs.h.  */
9747 > _ACEOF
9748 > cat confdefs.h >>conftest.$ac_ext
9749 > cat >>conftest.$ac_ext <<_ACEOF
9750 > /* end confdefs.h.  */
9751 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9752 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9753 > #define $ac_func innocuous_$ac_func
9754 >
9755 > /* System header to define __stub macros and hopefully few prototypes,
9756 >    which can conflict with char $ac_func (); below.
9757 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9758 >    <limits.h> exists even on freestanding compilers.  */
9759 >
9760 > #ifdef __STDC__
9761 > # include <limits.h>
9762 > #else
9763 > # include <assert.h>
9764 > #endif
9765 >
9766 > #undef $ac_func
9767 >
9768 > /* Override any gcc2 internal prototype to avoid an error.  */
9769 > #ifdef __cplusplus
9770 > extern "C"
9771 > {
9772 > #endif
9773 > /* We use char because int might match the return type of a gcc2
9774 >   builtin and then its argument prototype would still apply.  */
9775 > char $ac_func ();
9776 > /* The GNU C library defines this for functions which it implements
9777 >    to always fail with ENOSYS.  Some functions are actually named
9778 >    something starting with __ and the normal name is an alias.  */
9779 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9780 > choke me
9781 > #else
9782 > char (*f) () = $ac_func;
9783 > #endif
9784 > #ifdef __cplusplus
9785 > }
9786 > #endif
9787 >
9788 > #ifdef FC_DUMMY_MAIN
9789 > #ifndef FC_DUMMY_MAIN_EQ_F77
9790 > #  ifdef __cplusplus
9791 >     extern "C"
9792 > #  endif
9793 >   int FC_DUMMY_MAIN() { return 1; }
9794 > #endif
9795 > #endif
9796 > int
9797 > main ()
9798 > {
9799 > return f != $ac_func;
9800    ;
9801    return 0;
9802   }
# Line 3893 | Line 9823 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9823    ac_status=$?
9824    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9825    (exit $ac_status); }; }; then
9826 <  ac_success=yes; break 2
9826 >  eval "$as_ac_var=yes"
9827   else
9828    echo "$as_me: failed program was:" >&5
9829   sed 's/^/| /' conftest.$ac_ext >&5
9830  
9831 + eval "$as_ac_var=no"
9832   fi
9833   rm -f conftest.err conftest.$ac_objext \
9834        conftest$ac_exeext conftest.$ac_ext
9835 <    done
9836 <  done
9835 > fi
9836 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9837 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9838 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9839 >  cat >>confdefs.h <<_ACEOF
9840 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9841 > _ACEOF
9842  
9843 <  if test "$ac_success" = "yes"; then
9844 <     case $ac_foobar in
9845 <        foobar)
9846 <           ac_case=lower
9847 <           ac_foo_bar=foo_bar
9848 <           ;;
9849 <        FOOBAR)
9850 <           ac_case=upper
9851 <           ac_foo_bar=FOO_BAR
9852 <           ;;
3917 <     esac
3918 <
3919 <     ac_success_extra=no
3920 <     for ac_extra in "" "_"; do
3921 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3922 <
3923 <        cat >conftest.$ac_ext <<_ACEOF
9843 > else
9844 >  # FreeBSD has a gnugetopt library for this
9845 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9846 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9847 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9848 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9849 > else
9850 >  ac_check_lib_save_LIBS=$LIBS
9851 > LIBS="-lgnugetopt  $LIBS"
9852 > cat >conftest.$ac_ext <<_ACEOF
9853   /* confdefs.h.  */
9854   _ACEOF
9855   cat confdefs.h >>conftest.$ac_ext
# Line 3933 | Line 9862 | extern "C"
9862   #endif
9863   /* We use char because int might match the return type of a gcc2
9864     builtin and then its argument prototype would still apply.  */
9865 < char $ac_func ();
9865 > char getopt_long ();
9866 > #ifdef FC_DUMMY_MAIN
9867 > #ifndef FC_DUMMY_MAIN_EQ_F77
9868 > #  ifdef __cplusplus
9869 >     extern "C"
9870 > #  endif
9871 >   int FC_DUMMY_MAIN() { return 1; }
9872 > #endif
9873 > #endif
9874   int
9875   main ()
9876   {
9877 < $ac_func ();
9877 > getopt_long ();
9878    ;
9879    return 0;
9880   }
# Line 3964 | Line 9901 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9901    ac_status=$?
9902    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9903    (exit $ac_status); }; }; then
9904 <  ac_success_extra=yes; break
9904 >  ac_cv_lib_gnugetopt_getopt_long=yes
9905   else
9906    echo "$as_me: failed program was:" >&5
9907   sed 's/^/| /' conftest.$ac_ext >&5
9908  
9909 + ac_cv_lib_gnugetopt_getopt_long=no
9910   fi
9911   rm -f conftest.err conftest.$ac_objext \
9912        conftest$ac_exeext conftest.$ac_ext
9913 <     done
3976 <
3977 <     if test "$ac_success_extra" = "yes"; then
3978 <        ac_cv_f90_mangling="$ac_case case"
3979 <        if test -z "$ac_underscore"; then
3980 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
3981 <        else
3982 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
3983 <
3984 <        fi
3985 <        if test -z "$ac_extra"; then
3986 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3987 <        else
3988 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3989 <        fi
3990 <      else
3991 <        ac_cv_f90_mangling="unknown"
3992 <      fi
3993 <  else
3994 <     ac_cv_f90_mangling="unknown"
3995 <
3996 <  fi
3997 <
3998 <  LIBS=$ac_save_LIBS
3999 <  ac_ext=f90
4000 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4001 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4002 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4003 <  rm -f cf90_test* conftest*
4004 < else
4005 <  echo "$as_me: failed program was:" >&5
4006 < sed 's/^/| /' conftest.$ac_ext >&5
4007 <
9913 > LIBS=$ac_check_lib_save_LIBS
9914   fi
9915 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9916 < ac_ext=f90
9917 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
9918 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9919 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4014 <
4015 < fi
4016 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4017 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4018 <
4019 <
4020 <
4021 < case $ac_cv_f90_mangling in
4022 <  "lower case, no underscore, no extra underscore")
4023 <          cat >>confdefs.h <<\_ACEOF
4024 < #define F90_FUNC(name,NAME) name
9915 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9916 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9917 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9918 >  cat >>confdefs.h <<\_ACEOF
9919 > #define HAVE_GETOPT_LONG 1
9920   _ACEOF
9921  
9922 <          cat >>confdefs.h <<\_ACEOF
9923 < #define F90_FUNC_(name,NAME) name
9924 < _ACEOF
9925 < ;;
9926 <  "lower case, no underscore, extra underscore")
9927 <          cat >>confdefs.h <<\_ACEOF
9928 < #define F90_FUNC(name,NAME) name
9929 < _ACEOF
9922 > else
9923 >  # use the GNU replacement
9924 >      case $LIBOBJS in
9925 >    "getopt.$ac_objext"   | \
9926 >  *" getopt.$ac_objext"   | \
9927 >    "getopt.$ac_objext "* | \
9928 >  *" getopt.$ac_objext "* ) ;;
9929 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9930 > esac
9931  
9932 <          cat >>confdefs.h <<\_ACEOF
9933 < #define F90_FUNC_(name,NAME) name ## _
9934 < _ACEOF
9935 < ;;
9936 <  "lower case, underscore, no extra underscore")
9937 <          cat >>confdefs.h <<\_ACEOF
4042 < #define F90_FUNC(name,NAME) name ## _
4043 < _ACEOF
4044 <
4045 <          cat >>confdefs.h <<\_ACEOF
4046 < #define F90_FUNC_(name,NAME) name ## _
4047 < _ACEOF
4048 < ;;
4049 <  "lower case, underscore, extra underscore")
4050 <          cat >>confdefs.h <<\_ACEOF
4051 < #define F90_FUNC(name,NAME) name ## _
4052 < _ACEOF
4053 <
4054 <          cat >>confdefs.h <<\_ACEOF
4055 < #define F90_FUNC_(name,NAME) name ## __
4056 < _ACEOF
4057 < ;;
4058 <  "upper case, no underscore, no extra underscore")
4059 <          cat >>confdefs.h <<\_ACEOF
4060 < #define F90_FUNC(name,NAME) NAME
4061 < _ACEOF
4062 <
4063 <          cat >>confdefs.h <<\_ACEOF
4064 < #define F90_FUNC_(name,NAME) NAME
4065 < _ACEOF
4066 < ;;
4067 <  "upper case, no underscore, extra underscore")
4068 <          cat >>confdefs.h <<\_ACEOF
4069 < #define F90_FUNC(name,NAME) NAME
4070 < _ACEOF
4071 <
4072 <          cat >>confdefs.h <<\_ACEOF
4073 < #define F90_FUNC_(name,NAME) NAME ## _
4074 < _ACEOF
4075 < ;;
4076 <  "upper case, underscore, no extra underscore")
4077 <          cat >>confdefs.h <<\_ACEOF
4078 < #define F90_FUNC(name,NAME) NAME ## _
4079 < _ACEOF
4080 <
4081 <          cat >>confdefs.h <<\_ACEOF
4082 < #define F90_FUNC_(name,NAME) NAME ## _
4083 < _ACEOF
4084 < ;;
4085 <  "upper case, underscore, extra underscore")
4086 <          cat >>confdefs.h <<\_ACEOF
4087 < #define F90_FUNC(name,NAME) NAME ## _
4088 < _ACEOF
4089 <
4090 <          cat >>confdefs.h <<\_ACEOF
4091 < #define F90_FUNC_(name,NAME) NAME ## __
4092 < _ACEOF
4093 < ;;
4094 <  *)
4095 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4096 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4097 <          ;;
9932 >      case $LIBOBJS in
9933 >    "getopt1.$ac_objext"   | \
9934 >  *" getopt1.$ac_objext"   | \
9935 >    "getopt1.$ac_objext "* | \
9936 >  *" getopt1.$ac_objext "* ) ;;
9937 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9938   esac
9939  
9940 +                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9941  
4101
4102
4103
4104 echo "$as_me:$LINENO: checking for module suffix" >&5
4105 echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4106 rm -f conftest*
4107 # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4108 rm -f work*
4109 cat >conftest.f90 <<EOF
4110        module conftest
4111        integer n
4112        parameter (n=1)
4113        end module conftest
4114 EOF
4115 # SGI and absoft compilers generates module name in upper case!
4116 testname="conftest"
4117 modcase="lower"
4118 if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4119    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4120    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4121    if test -z "$MOD" ; then
4122        MOD=`ls CONFTEST* 2>/dev/null \
4123                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4124        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4125        if test -n "$MOD" ; then
4126            testname="CONFTEST"
4127            modcase="upper"
4128        fi
4129    fi
4130    if test -z "$MOD" ; then
4131        echo "$as_me:$LINENO: result: unknown" >&5
4132 echo "${ECHO_T}unknown" >&6
4133        # Use mod if we can't figure it out
4134        MOD="mod"
4135    else
4136        echo "$as_me:$LINENO: result: $MOD" >&5
4137 echo "${ECHO_T}$MOD" >&6
4138    fi
4139    if test -s work.pcl ; then
4140        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4141 echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4142    fi
4143 else
4144    echo "$as_me:$LINENO: result: unknown" >&5
4145 echo "${ECHO_T}unknown" >&6
9942   fi
9943  
9944 <
9945 <
4150 <
4151 <
4152 < # Check for module include path (some use -I, some (Solaris) use -M, some
4153 < # (absoft) use -p).
4154 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4155 < # specified, work.pcl and work.pc are created.  However, if you specify
4156 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4157 < # Use the module made above
4158 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4159 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4160 < rm -f conftest*
4161 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4162 < rm -f work*
4163 < cat >conftest.f90 <<EOF
4164 <        module conftest
4165 <        integer n
4166 <        parameter (n=1)
4167 <        end module conftest
4168 < EOF
4169 < # SGI and absoft compilers generates module name in upper case!
4170 < testname="conftest"
4171 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4172 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4173 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4174 <   if test -n "$mod" ; then
4175 <      testname="CONFTEST"
4176 <   fi
4177 <   madedir=0
4178 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4179 <   cp $testname.$MOD conf
4180 <   rm -f conftest* CONFTEST*
4181 <   cat >conftest1.f90 <<EOF
4182 <        program main
4183 <        use conftest
4184 <        print *, n
4185 <        end
4186 < EOF
4187 <   F90_WORK_FILES_ARG=""
4188 <   F90MODINCSPEC=""
4189 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4190 <       MODDIRFLAG="-I"
4191 <       F90MODINCSPEC="-I<dir>"
4192 <       echo "$as_me:$LINENO: result: -I" >&5
4193 < echo "${ECHO_T}-I" >&6
4194 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4195 <       MODDIRFLAG="-M"
4196 <       F90MODINCSPEC="-M<dir>"
4197 <       echo "$as_me:$LINENO: result: -M" >&5
4198 < echo "${ECHO_T}-M" >&6
4199 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4200 <       MODDIRFLAG="-p"
4201 <       F90MODINCSPEC="-p<dir>"
4202 <       echo "$as_me:$LINENO: result: -p" >&5
4203 < echo "${ECHO_T}-p" >&6
4204 <   elif test -s work.pc ; then
4205 <        cp work.pc conf/mpimod.pc
4206 <        echo "mpimod.pc" > conf/mpimod.pcl
4207 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4208 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4209 <            MODDIRFLAG='-cl,mpimod.pcl'
4210 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4211 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4212 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4213 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
9944 > fi
9945 > done
9946  
4215        else
4216            # The version of the Intel compiler that I have refuses to let
4217            # you put the "work catalog" list anywhere but the current
4218            # directory. For example, you cannot in
4219         :
4220        fi
4221   fi
4222   if test -z "MODDIRFLAG" ; then
4223       echo "$as_me:$LINENO: result: unknown" >&5
4224 echo "${ECHO_T}unknown" >&6
4225   fi
9947  
9948 + ac_ext=cc
9949 + ac_cpp='$CXXCPP $CPPFLAGS'
9950 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9951 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9952 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9953  
4228   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4229   if test $madedir = 1 ; then rmdir conf ; fi
4230 fi
9954  
9955 <
9956 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
9957 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4235 < if test "${ac_cv_f90_module_names+set}" = set; then
9955 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9956 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9957 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9958    echo $ECHO_N "(cached) $ECHO_C" >&6
9959   else
4238  ac_ext=f90
4239 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4240 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4241 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
9960  
9961 < # carry out the test in a new directory, so that we don't miss anything
9962 < mkdir conftest
9963 < cd conftest
9964 < cat >conftest.$ac_ext <<_ACEOF
9965 < MODULE Bar
9966 < END MODULE Bar
9961 >
9962 > ac_ext=cc
9963 > ac_cpp='$CXXCPP $CPPFLAGS'
9964 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9965 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9966 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9967 >
9968 > cat >conftest.$ac_ext <<_ACEOF
9969 > /* confdefs.h.  */
9970   _ACEOF
9971 + cat confdefs.h >>conftest.$ac_ext
9972 + cat >>conftest.$ac_ext <<_ACEOF
9973 + /* end confdefs.h.  */
9974 + namespace Outer { namespace Inner { int i = 0; }}
9975 + #ifdef FC_DUMMY_MAIN
9976 + #ifndef FC_DUMMY_MAIN_EQ_F77
9977 + #  ifdef __cplusplus
9978 +     extern "C"
9979 + #  endif
9980 +   int FC_DUMMY_MAIN() { return 1; }
9981 + #endif
9982 + #endif
9983 + int
9984 + main ()
9985 + {
9986 + using namespace Outer::Inner; return i;
9987 +  ;
9988 +  return 0;
9989 + }
9990 + _ACEOF
9991   rm -f conftest.$ac_objext
9992   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9993    (eval $ac_compile) 2>conftest.er1
# Line 4256 | Line 9997 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9997    cat conftest.err >&5
9998    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9999    (exit $ac_status); } &&
10000 <         { ac_try='test -z "$ac_f90_werror_flag"
10000 >         { ac_try='test -z "$ac_cxx_werror_flag"
10001                           || test ! -s conftest.err'
10002    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10003    (eval $ac_try) 2>&5
# Line 4269 | Line 10010 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10010    ac_status=$?
10011    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10012    (exit $ac_status); }; }; then
10013 <  ac_cv_f90_module_names=
4273 < ac_file_list=*
4274 < for ac_file in $ac_file_list; do
4275 <   case $ac_file in
4276 <      # don't care for original source and object files
4277 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4278 <          :
4279 <          ;;
4280 <      # look for new files derived from the file name
4281 <      *conftest*)
4282 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4283 <            ac_exists=false
4284 <  for ac_i in $ac_cv_f90_module_names; do
4285 <    if test x"$ac_pat" = x"$ac_i"; then
4286 <      ac_exists=true
4287 <      break
4288 <    fi
4289 <  done
4290 <
4291 <  if test x"$ac_exists" = xtrue; then
4292 <  :
10013 >  ac_cv_cxx_namespaces=yes
10014   else
4294  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4295 fi
4296
4297          ;;
4298      # look for new files derived from the module name,
4299      # with different case translation schemes
4300      *Bar*)
4301          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4302            ac_exists=false
4303  for ac_i in $ac_cv_f90_module_names; do
4304    if test x"$ac_pat" = x"$ac_i"; then
4305      ac_exists=true
4306      break
4307    fi
4308  done
4309
4310  if test x"$ac_exists" = xtrue; then
4311  :
4312 else
4313  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4314 fi
4315
4316          ;;
4317      *bar*)
4318          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4319            ac_exists=false
4320  for ac_i in $ac_cv_f90_module_names; do
4321    if test x"$ac_pat" = x"$ac_i"; then
4322      ac_exists=true
4323      break
4324    fi
4325  done
4326
4327  if test x"$ac_exists" = xtrue; then
4328  :
4329 else
4330  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4331 fi
4332
4333          ;;
4334      *BAR*)
4335          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4336            ac_exists=false
4337  for ac_i in $ac_cv_f90_module_names; do
4338    if test x"$ac_pat" = x"$ac_i"; then
4339      ac_exists=true
4340      break
4341    fi
4342  done
4343
4344  if test x"$ac_exists" = xtrue; then
4345  :
4346 else
4347  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4348 fi
4349
4350          ;;
4351       # Other files - we have no idea how they are generated
4352       *)
4353          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4354 echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4355          ;;
4356   esac
4357 done
4358 if test "x$ac_cv_f90_module_names" = "x"; then
4359  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4360 echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4361 fi
4362
4363 else
10015    echo "$as_me: failed program was:" >&5
10016   sed 's/^/| /' conftest.$ac_ext >&5
10017  
10018 < ac_cv_f90_module_names=
4368 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4369 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
10018 > ac_cv_cxx_namespaces=no
10019   fi
10020   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10021 < cd ..
10022 < # cleanup
10023 < rm -rf conftest
10024 < ac_ext=f90
10025 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4377 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4378 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
10021 > ac_ext=cc
10022 > ac_cpp='$CXXCPP $CPPFLAGS'
10023 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10024 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10025 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10026  
4380 fi
4381 echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4382 echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
10027  
10028 < # We now generate a shell script that will help us to figure out the correct
10029 < # module file names, using the value of ac_cv_f90_module_names
10030 <
10031 < echo "Generating shell script modnam"
4388 <
4389 < cat > scripts/modnam << EOF
4390 < #! /bin/sh
4391 < # This script is auto-generated by configure
4392 < #
4393 < usage="\\
4394 < Usage: \$0 [FILES]
4395 <
4396 < [FILES] are Fortran 90 source files.
4397 < The output is a list of module file names that the Fortran 90 compiler
4398 < generates when compiling [FILES]."
10028 > fi
10029 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10030 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10031 > if test "$ac_cv_cxx_namespaces" = yes; then
10032  
10033 < list=
10034 < empty=
10033 > cat >>confdefs.h <<\_ACEOF
10034 > #define HAVE_NAMESPACES
10035 > _ACEOF
10036  
4403 if test \$# -eq 0; then
4404   echo "\$usage"; exit 0
10037   fi
10038  
10039 < while test \$# != 0; do
10040 <
10041 <  file=\$1
10042 <  shift
10043 <
10044 < # strip suffix
10045 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
10046 <
10047 <  test ! -f \$file && continue
4416 <
4417 < # Look for module definitions and transform them to upper / lower case
4418 <  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4419 <  upper=\`echo \$mods | tr a-z A-Z\`
4420 <  lower=\`echo \$mods | tr A-Z a-z\`
4421 <
4422 < # Here, the patterns for generating module file names were inserted by configure
4423 <  for trans in $ac_cv_f90_module_names; do
4424 <
4425 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4426 <    var=empty
4427 <    case \$pat in
4428 <       %MODULE%)
4429 <          var=upper ;;
4430 <       %Module%)
4431 <          var=mods ;;
4432 <       %module%)
4433 <          var=lower ;;
4434 <       %FILE%)
4435 <          test -n "\$mods" && var=base ;;
4436 <    esac
4437 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4438 <    list="\$list \$new"
4439 <  done
4440 < done
4441 <
4442 < echo \$list
4443 < # end of configure-generated script
4444 < EOF
4445 < chmod 755 scripts/modnam
4446 <
4447 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4448 < F90_MODULE_NAMES=empty
4449 < case $pat in
4450 <       %MODULE%)
4451 <          F90_MODULE_NAMES=UPPER ;;
4452 <       %Module%)
4453 <          F90_MODULE_NAMES=Mixed ;;
4454 <       %module%)
4455 <          F90_MODULE_NAMES=lower ;;
4456 <       *)
4457 <          F90_MODULE_NAMES=unknown ;;
4458 < esac
4459 <
4460 < ac_ext=c
4461 < ac_cpp='$CPP $CPPFLAGS'
4462 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4463 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4464 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4465 <
4466 <
4467 < ac_ext=c
4468 < ac_cpp='$CPP $CPPFLAGS'
4469 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4470 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4471 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4472 <
4473 < ac_ext=c
4474 < ac_cpp='$CPP $CPPFLAGS'
4475 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4476 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4477 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4478 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4479 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4480 < # On Suns, sometimes $CPP names a directory.
4481 < if test -n "$CPP" && test -d "$CPP"; then
4482 <  CPP=
4483 < fi
4484 < if test -z "$CPP"; then
4485 <  if test "${ac_cv_prog_CPP+set}" = set; then
10039 > ac_ext=cc
10040 > ac_cpp='$CXXCPP $CPPFLAGS'
10041 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10042 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10043 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10044 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10045 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10046 > if test -z "$CXXCPP"; then
10047 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10048    echo $ECHO_N "(cached) $ECHO_C" >&6
10049   else
10050 <      # Double quotes because CPP needs to be expanded
10051 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
10050 >      # Double quotes because CXXCPP needs to be expanded
10051 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10052      do
10053        ac_preproc_ok=false
10054 < for ac_c_preproc_warn_flag in '' yes
10054 > for ac_cxx_preproc_warn_flag in '' yes
10055   do
10056    # Use a header file that comes with gcc, so configuring glibc
10057    # with a fresh cross-compiler works.
# Line 4519 | Line 10081 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10081    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10082    (exit $ac_status); } >/dev/null; then
10083    if test -s conftest.err; then
10084 <    ac_cpp_err=$ac_c_preproc_warn_flag
10085 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10084 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10085 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10086    else
10087      ac_cpp_err=
10088    fi
# Line 4557 | Line 10119 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10119    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120    (exit $ac_status); } >/dev/null; then
10121    if test -s conftest.err; then
10122 <    ac_cpp_err=$ac_c_preproc_warn_flag
10123 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10122 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10123 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10124    else
10125      ac_cpp_err=
10126    fi
# Line 4586 | Line 10148 | fi
10148   fi
10149  
10150      done
10151 <    ac_cv_prog_CPP=$CPP
10151 >    ac_cv_prog_CXXCPP=$CXXCPP
10152  
10153   fi
10154 <  CPP=$ac_cv_prog_CPP
10154 >  CXXCPP=$ac_cv_prog_CXXCPP
10155   else
10156 <  ac_cv_prog_CPP=$CPP
10156 >  ac_cv_prog_CXXCPP=$CXXCPP
10157   fi
10158 < echo "$as_me:$LINENO: result: $CPP" >&5
10159 < echo "${ECHO_T}$CPP" >&6
10158 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10159 > echo "${ECHO_T}$CXXCPP" >&6
10160   ac_preproc_ok=false
10161 < for ac_c_preproc_warn_flag in '' yes
10161 > for ac_cxx_preproc_warn_flag in '' yes
10162   do
10163    # Use a header file that comes with gcc, so configuring glibc
10164    # with a fresh cross-compiler works.
# Line 4626 | Line 10188 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10188    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10189    (exit $ac_status); } >/dev/null; then
10190    if test -s conftest.err; then
10191 <    ac_cpp_err=$ac_c_preproc_warn_flag
10192 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10191 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10192 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10193    else
10194      ac_cpp_err=
10195    fi
# Line 4664 | Line 10226 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10226    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10227    (exit $ac_status); } >/dev/null; then
10228    if test -s conftest.err; then
10229 <    ac_cpp_err=$ac_c_preproc_warn_flag
10230 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10229 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10230 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10231    else
10232      ac_cpp_err=
10233    fi
# Line 4691 | Line 10253 | else
10253   if $ac_preproc_ok; then
10254    :
10255   else
10256 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
10256 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10257   See \`config.log' for more details." >&5
10258 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
10258 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10259   See \`config.log' for more details." >&2;}
10260     { (exit 1); exit 1; }; }
10261   fi
10262  
10263 < ac_ext=c
10264 < ac_cpp='$CPP $CPPFLAGS'
10265 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10266 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10267 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10263 > ac_ext=cc
10264 > ac_cpp='$CXXCPP $CPPFLAGS'
10265 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10266 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10267 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10268  
10269  
10270 < echo "$as_me:$LINENO: checking for egrep" >&5
10271 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
10272 < if test "${ac_cv_prog_egrep+set}" = set; then
10270 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10271 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10272 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10273    echo $ECHO_N "(cached) $ECHO_C" >&6
10274   else
4713  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4714    then ac_cv_prog_egrep='grep -E'
4715    else ac_cv_prog_egrep='egrep'
4716    fi
4717 fi
4718 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4719 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4720 EGREP=$ac_cv_prog_egrep
10275  
10276  
10277 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10278 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10279 < if test "${ac_cv_header_stdc+set}" = set; then
10280 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10281 < else
10282 <  cat >conftest.$ac_ext <<_ACEOF
10277 >
10278 > ac_ext=cc
10279 > ac_cpp='$CXXCPP $CPPFLAGS'
10280 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10281 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10282 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10283 >
10284 > cat >conftest.$ac_ext <<_ACEOF
10285   /* confdefs.h.  */
10286   _ACEOF
10287   cat confdefs.h >>conftest.$ac_ext
10288   cat >>conftest.$ac_ext <<_ACEOF
10289   /* end confdefs.h.  */
10290 < #include <stdlib.h>
10291 < #include <stdarg.h>
10292 < #include <string.h>
10293 < #include <float.h>
10294 <
10290 > #include <list>
10291 > #include <deque>
10292 > #ifdef HAVE_NAMESPACES
10293 > using namespace std;
10294 > #endif
10295 > #ifdef FC_DUMMY_MAIN
10296 > #ifndef FC_DUMMY_MAIN_EQ_F77
10297 > #  ifdef __cplusplus
10298 >     extern "C"
10299 > #  endif
10300 >   int FC_DUMMY_MAIN() { return 1; }
10301 > #endif
10302 > #endif
10303   int
10304   main ()
10305   {
10306 <
10306 > list<int> x; x.push_back(5);
10307 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10308    ;
10309    return 0;
10310   }
# Line 4753 | Line 10318 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10318    cat conftest.err >&5
10319    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10320    (exit $ac_status); } &&
10321 <         { ac_try='test -z "$ac_c_werror_flag"
10321 >         { ac_try='test -z "$ac_cxx_werror_flag"
10322                           || test ! -s conftest.err'
10323    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10324    (eval $ac_try) 2>&5
# Line 4766 | Line 10331 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10331    ac_status=$?
10332    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10333    (exit $ac_status); }; }; then
10334 <  ac_cv_header_stdc=yes
10334 >  ac_cv_cxx_have_stl=yes
10335   else
10336    echo "$as_me: failed program was:" >&5
10337   sed 's/^/| /' conftest.$ac_ext >&5
10338  
10339 < ac_cv_header_stdc=no
10339 > ac_cv_cxx_have_stl=no
10340   fi
10341   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10342 + ac_ext=cc
10343 + ac_cpp='$CXXCPP $CPPFLAGS'
10344 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10345 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10346 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10347  
4778 if test $ac_cv_header_stdc = yes; then
4779  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4780  cat >conftest.$ac_ext <<_ACEOF
4781 /* confdefs.h.  */
4782 _ACEOF
4783 cat confdefs.h >>conftest.$ac_ext
4784 cat >>conftest.$ac_ext <<_ACEOF
4785 /* end confdefs.h.  */
4786 #include <string.h>
10348  
4788 _ACEOF
4789 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4790  $EGREP "memchr" >/dev/null 2>&1; then
4791  :
4792 else
4793  ac_cv_header_stdc=no
10349   fi
10350 < rm -f conftest*
10351 <
10352 < fi
4798 <
4799 < if test $ac_cv_header_stdc = yes; then
4800 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
4801 <  cat >conftest.$ac_ext <<_ACEOF
4802 < /* confdefs.h.  */
4803 < _ACEOF
4804 < cat confdefs.h >>conftest.$ac_ext
4805 < cat >>conftest.$ac_ext <<_ACEOF
4806 < /* end confdefs.h.  */
4807 < #include <stdlib.h>
4808 <
4809 < _ACEOF
4810 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4811 <  $EGREP "free" >/dev/null 2>&1; then
4812 <  :
4813 < else
4814 <  ac_cv_header_stdc=no
4815 < fi
4816 < rm -f conftest*
4817 <
4818 < fi
4819 <
4820 < if test $ac_cv_header_stdc = yes; then
4821 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4822 <  if test "$cross_compiling" = yes; then
4823 <  :
4824 < else
4825 <  cat >conftest.$ac_ext <<_ACEOF
4826 < /* confdefs.h.  */
4827 < _ACEOF
4828 < cat confdefs.h >>conftest.$ac_ext
4829 < cat >>conftest.$ac_ext <<_ACEOF
4830 < /* end confdefs.h.  */
4831 < #include <ctype.h>
4832 < #if ((' ' & 0x0FF) == 0x020)
4833 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4834 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4835 < #else
4836 < # define ISLOWER(c) \
4837 <                   (('a' <= (c) && (c) <= 'i') \
4838 <                     || ('j' <= (c) && (c) <= 'r') \
4839 <                     || ('s' <= (c) && (c) <= 'z'))
4840 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4841 < #endif
10350 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10351 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10352 > if test "$ac_cv_cxx_have_stl" = yes; then
10353  
4843 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4844 int
4845 main ()
4846 {
4847  int i;
4848  for (i = 0; i < 256; i++)
4849    if (XOR (islower (i), ISLOWER (i))
4850        || toupper (i) != TOUPPER (i))
4851      exit(2);
4852  exit (0);
4853 }
4854 _ACEOF
4855 rm -f conftest$ac_exeext
4856 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4857  (eval $ac_link) 2>&5
4858  ac_status=$?
4859  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4860  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4861  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4862  (eval $ac_try) 2>&5
4863  ac_status=$?
4864  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4865  (exit $ac_status); }; }; then
4866  :
4867 else
4868  echo "$as_me: program exited with status $ac_status" >&5
4869 echo "$as_me: failed program was:" >&5
4870 sed 's/^/| /' conftest.$ac_ext >&5
4871
4872 ( exit $ac_status )
4873 ac_cv_header_stdc=no
4874 fi
4875 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4876 fi
4877 fi
4878 fi
4879 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4880 echo "${ECHO_T}$ac_cv_header_stdc" >&6
4881 if test $ac_cv_header_stdc = yes; then
4882
10354   cat >>confdefs.h <<\_ACEOF
10355 < #define STDC_HEADERS 1
10355 > #define HAVE_STL
10356   _ACEOF
10357  
10358   fi
10359  
4889 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
10360  
10361  
10362 <
10363 <
10364 <
10365 <
4896 <
4897 <
4898 <
4899 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4900 <                  inttypes.h stdint.h unistd.h
4901 < do
4902 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4903 < echo "$as_me:$LINENO: checking for $ac_header" >&5
4904 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4905 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10362 >  if test "${ac_cv_header_iostream+set}" = set; then
10363 >  echo "$as_me:$LINENO: checking for iostream" >&5
10364 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10365 > if test "${ac_cv_header_iostream+set}" = set; then
10366    echo $ECHO_N "(cached) $ECHO_C" >&6
10367 + fi
10368 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10369 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10370   else
10371 <  cat >conftest.$ac_ext <<_ACEOF
10371 >  # Is the header compilable?
10372 > echo "$as_me:$LINENO: checking iostream usability" >&5
10373 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10374 > cat >conftest.$ac_ext <<_ACEOF
10375   /* confdefs.h.  */
10376   _ACEOF
10377   cat confdefs.h >>conftest.$ac_ext
10378   cat >>conftest.$ac_ext <<_ACEOF
10379   /* end confdefs.h.  */
10380   $ac_includes_default
10381 <
4916 < #include <$ac_header>
10381 > #include <iostream>
10382   _ACEOF
10383   rm -f conftest.$ac_objext
10384   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 4924 | Line 10389 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10389    cat conftest.err >&5
10390    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10391    (exit $ac_status); } &&
10392 <         { ac_try='test -z "$ac_c_werror_flag"
10392 >         { ac_try='test -z "$ac_cxx_werror_flag"
10393                           || test ! -s conftest.err'
10394    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10395    (eval $ac_try) 2>&5
# Line 4937 | Line 10402 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10402    ac_status=$?
10403    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10404    (exit $ac_status); }; }; then
10405 <  eval "$as_ac_Header=yes"
10405 >  ac_header_compiler=yes
10406   else
10407    echo "$as_me: failed program was:" >&5
10408   sed 's/^/| /' conftest.$ac_ext >&5
10409  
10410 < eval "$as_ac_Header=no"
10410 > ac_header_compiler=no
10411   fi
10412   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10413 < fi
10414 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10415 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10416 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10417 <  cat >>confdefs.h <<_ACEOF
10418 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10413 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10414 > echo "${ECHO_T}$ac_header_compiler" >&6
10415 >
10416 > # Is the header present?
10417 > echo "$as_me:$LINENO: checking iostream presence" >&5
10418 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10419 > cat >conftest.$ac_ext <<_ACEOF
10420 > /* confdefs.h.  */
10421   _ACEOF
10422 + cat confdefs.h >>conftest.$ac_ext
10423 + cat >>conftest.$ac_ext <<_ACEOF
10424 + /* end confdefs.h.  */
10425 + #include <iostream>
10426 + _ACEOF
10427 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10428 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10429 +  ac_status=$?
10430 +  grep -v '^ *+' conftest.er1 >conftest.err
10431 +  rm -f conftest.er1
10432 +  cat conftest.err >&5
10433 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10434 +  (exit $ac_status); } >/dev/null; then
10435 +  if test -s conftest.err; then
10436 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
10437 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10438 +  else
10439 +    ac_cpp_err=
10440 +  fi
10441 + else
10442 +  ac_cpp_err=yes
10443 + fi
10444 + if test -z "$ac_cpp_err"; then
10445 +  ac_header_preproc=yes
10446 + else
10447 +  echo "$as_me: failed program was:" >&5
10448 + sed 's/^/| /' conftest.$ac_ext >&5
10449  
10450 +  ac_header_preproc=no
10451   fi
10452 + rm -f conftest.err conftest.$ac_ext
10453 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10454 + echo "${ECHO_T}$ac_header_preproc" >&6
10455  
10456 < done
10457 <
10458 <
10459 < #
10460 < # Handle user hints
10461 < #
10462 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
10463 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
10464 <
10465 < # Check whether --with-zlib or --without-zlib was given.
10466 < if test "${with_zlib+set}" = set; then
10467 <  withval="$with_zlib"
10468 <  if test "$withval" != no ; then
10469 <  echo "$as_me:$LINENO: result: yes" >&5
10470 < echo "${ECHO_T}yes" >&6
10471 <  if test -d "$withval"
10472 <  then
10473 <    ZLIB_HOME="$withval"
10474 <  else
10475 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
10476 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
10477 <  fi
10456 > # So?  What about this header?
10457 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10458 >  yes:no: )
10459 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10460 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10461 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10462 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10463 >    ac_header_preproc=yes
10464 >    ;;
10465 >  no:yes:* )
10466 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10467 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10468 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10469 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10470 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10471 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10472 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10473 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10474 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10475 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10476 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10477 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10478 >    (
10479 >      cat <<\_ASBOX
10480 > ## ------------------------------ ##
10481 > ## Report this to gezelter@nd.edu ##
10482 > ## ------------------------------ ##
10483 > _ASBOX
10484 >    ) |
10485 >      sed "s/^/$as_me: WARNING:     /" >&2
10486 >    ;;
10487 > esac
10488 > echo "$as_me:$LINENO: checking for iostream" >&5
10489 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10490 > if test "${ac_cv_header_iostream+set}" = set; then
10491 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10492   else
10493 <  echo "$as_me:$LINENO: result: no" >&5
4982 < echo "${ECHO_T}no" >&6
10493 >  ac_cv_header_iostream=$ac_header_preproc
10494   fi
10495 < fi;
10495 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10496 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10497  
4986 ZLIB_HOME=/usr/local
4987 if test ! -f "${ZLIB_HOME}/include/zlib.h"
4988 then
4989        ZLIB_HOME=/usr
10498   fi
10499 + if test $ac_cv_header_iostream = yes; then
10500  
4992 #
4993 # Locate zlib, if wanted
4994 #
4995 if test -n "${ZLIB_HOME}"
4996 then
4997        ZLIB_OLD_LDFLAGS=$LDFLAGS
4998        ZLIB_OLD_CPPFLAGS=$LDFLAGS
4999        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5000        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
10501  
10502 + cat >>confdefs.h <<\_ACEOF
10503 + #define HAVE_IOSTREAM 1
10504 + _ACEOF
10505  
10506 <        ac_ext=c
10507 < ac_cpp='$CPP $CPPFLAGS'
10508 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10509 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10510 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10511 <
10512 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
10513 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
10514 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
10506 >
10507 > else
10508 >
10509 >
10510 > for ac_header in iostream.h
10511 > do
10512 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10513 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10514 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10515 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10516 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10517    echo $ECHO_N "(cached) $ECHO_C" >&6
10518 + fi
10519 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10520 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10521   else
10522 <  ac_check_lib_save_LIBS=$LIBS
10523 < LIBS="-lz  $LIBS"
10522 >  # Is the header compilable?
10523 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10524 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10525   cat >conftest.$ac_ext <<_ACEOF
10526   /* confdefs.h.  */
10527   _ACEOF
10528   cat confdefs.h >>conftest.$ac_ext
10529   cat >>conftest.$ac_ext <<_ACEOF
10530   /* end confdefs.h.  */
10531 <
10532 < /* Override any gcc2 internal prototype to avoid an error.  */
5024 < #ifdef __cplusplus
5025 < extern "C"
5026 < #endif
5027 < /* We use char because int might match the return type of a gcc2
5028 <   builtin and then its argument prototype would still apply.  */
5029 < char inflateEnd ();
5030 < int
5031 < main ()
5032 < {
5033 < inflateEnd ();
5034 <  ;
5035 <  return 0;
5036 < }
10531 > $ac_includes_default
10532 > #include <$ac_header>
10533   _ACEOF
10534 < rm -f conftest.$ac_objext conftest$ac_exeext
10535 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10536 <  (eval $ac_link) 2>conftest.er1
10534 > rm -f conftest.$ac_objext
10535 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10536 >  (eval $ac_compile) 2>conftest.er1
10537    ac_status=$?
10538    grep -v '^ *+' conftest.er1 >conftest.err
10539    rm -f conftest.er1
10540    cat conftest.err >&5
10541    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10542    (exit $ac_status); } &&
10543 <         { ac_try='test -z "$ac_c_werror_flag"
10543 >         { ac_try='test -z "$ac_cxx_werror_flag"
10544                           || test ! -s conftest.err'
10545    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10546    (eval $ac_try) 2>&5
10547    ac_status=$?
10548    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10549    (exit $ac_status); }; } &&
10550 <         { ac_try='test -s conftest$ac_exeext'
10550 >         { ac_try='test -s conftest.$ac_objext'
10551    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10552    (eval $ac_try) 2>&5
10553    ac_status=$?
10554    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10555    (exit $ac_status); }; }; then
10556 <  ac_cv_lib_z_inflateEnd=yes
10556 >  ac_header_compiler=yes
10557   else
10558    echo "$as_me: failed program was:" >&5
10559   sed 's/^/| /' conftest.$ac_ext >&5
10560  
10561 < ac_cv_lib_z_inflateEnd=no
10561 > ac_header_compiler=no
10562   fi
10563 < rm -f conftest.err conftest.$ac_objext \
10564 <      conftest$ac_exeext conftest.$ac_ext
10565 < LIBS=$ac_check_lib_save_LIBS
10563 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10564 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10565 > echo "${ECHO_T}$ac_header_compiler" >&6
10566 >
10567 > # Is the header present?
10568 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10569 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10570 > cat >conftest.$ac_ext <<_ACEOF
10571 > /* confdefs.h.  */
10572 > _ACEOF
10573 > cat confdefs.h >>conftest.$ac_ext
10574 > cat >>conftest.$ac_ext <<_ACEOF
10575 > /* end confdefs.h.  */
10576 > #include <$ac_header>
10577 > _ACEOF
10578 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10579 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10580 >  ac_status=$?
10581 >  grep -v '^ *+' conftest.er1 >conftest.err
10582 >  rm -f conftest.er1
10583 >  cat conftest.err >&5
10584 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10585 >  (exit $ac_status); } >/dev/null; then
10586 >  if test -s conftest.err; then
10587 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10588 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10589 >  else
10590 >    ac_cpp_err=
10591 >  fi
10592 > else
10593 >  ac_cpp_err=yes
10594   fi
10595 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
10596 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5073 < if test $ac_cv_lib_z_inflateEnd = yes; then
5074 <  zlib_cv_libz=yes
10595 > if test -z "$ac_cpp_err"; then
10596 >  ac_header_preproc=yes
10597   else
10598 <  zlib_cv_libz=no
10598 >  echo "$as_me: failed program was:" >&5
10599 > sed 's/^/| /' conftest.$ac_ext >&5
10600 >
10601 >  ac_header_preproc=no
10602   fi
10603 + rm -f conftest.err conftest.$ac_ext
10604 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10605 + echo "${ECHO_T}$ac_header_preproc" >&6
10606  
10607 <        if test "${ac_cv_header_zlib_h+set}" = set; then
10608 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
10609 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10610 < if test "${ac_cv_header_zlib_h+set}" = set; then
10607 > # So?  What about this header?
10608 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10609 >  yes:no: )
10610 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10611 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10612 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10613 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10614 >    ac_header_preproc=yes
10615 >    ;;
10616 >  no:yes:* )
10617 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10618 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10619 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10620 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10621 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10622 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10623 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10624 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10625 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10626 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10627 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10628 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10629 >    (
10630 >      cat <<\_ASBOX
10631 > ## ------------------------------ ##
10632 > ## Report this to gezelter@nd.edu ##
10633 > ## ------------------------------ ##
10634 > _ASBOX
10635 >    ) |
10636 >      sed "s/^/$as_me: WARNING:     /" >&2
10637 >    ;;
10638 > esac
10639 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10640 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10641 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10642    echo $ECHO_N "(cached) $ECHO_C" >&6
10643 + else
10644 +  eval "$as_ac_Header=\$ac_header_preproc"
10645   fi
10646 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10647 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10646 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10647 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10648 >
10649 > fi
10650 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10651 >  cat >>confdefs.h <<_ACEOF
10652 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10653 > _ACEOF
10654 >
10655 > fi
10656 >
10657 > done
10658 >
10659 >
10660 > fi
10661 >
10662 >
10663 >
10664 >
10665 >  if test "${ac_cv_header_iomanip+set}" = set; then
10666 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10667 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10668 > if test "${ac_cv_header_iomanip+set}" = set; then
10669 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10670 > fi
10671 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10672 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10673   else
10674    # Is the header compilable?
10675 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
10676 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
10675 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10676 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10677   cat >conftest.$ac_ext <<_ACEOF
10678   /* confdefs.h.  */
10679   _ACEOF
# Line 5095 | Line 10681 | $ac_includes_default
10681   cat >>conftest.$ac_ext <<_ACEOF
10682   /* end confdefs.h.  */
10683   $ac_includes_default
10684 < #include <zlib.h>
10684 > #include <iomanip>
10685   _ACEOF
10686   rm -f conftest.$ac_objext
10687   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5106 | Line 10692 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10692    cat conftest.err >&5
10693    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10694    (exit $ac_status); } &&
10695 <         { ac_try='test -z "$ac_c_werror_flag"
10695 >         { ac_try='test -z "$ac_cxx_werror_flag"
10696                           || test ! -s conftest.err'
10697    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10698    (eval $ac_try) 2>&5
# Line 5131 | Line 10717 | echo "${ECHO_T}$ac_header_compiler" >&6
10717   echo "${ECHO_T}$ac_header_compiler" >&6
10718  
10719   # Is the header present?
10720 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
10721 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
10720 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10721 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10722   cat >conftest.$ac_ext <<_ACEOF
10723   /* confdefs.h.  */
10724   _ACEOF
10725   cat confdefs.h >>conftest.$ac_ext
10726   cat >>conftest.$ac_ext <<_ACEOF
10727   /* end confdefs.h.  */
10728 < #include <zlib.h>
10728 > #include <iomanip>
10729   _ACEOF
10730   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10731    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5150 | Line 10736 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10736    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10737    (exit $ac_status); } >/dev/null; then
10738    if test -s conftest.err; then
10739 <    ac_cpp_err=$ac_c_preproc_warn_flag
10740 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10739 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10740 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10741    else
10742      ac_cpp_err=
10743    fi
# Line 5171 | Line 10757 | echo "${ECHO_T}$ac_header_preproc" >&6
10757   echo "${ECHO_T}$ac_header_preproc" >&6
10758  
10759   # So?  What about this header?
10760 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10760 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10761    yes:no: )
10762 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
10763 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
10764 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
10765 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
10762 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10763 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10764 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10765 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10766      ac_header_preproc=yes
10767      ;;
10768    no:yes:* )
10769 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
10770 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
10771 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
10772 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
10773 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
10774 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
10775 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
10776 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
10777 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
10778 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
10779 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
10780 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
10769 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10770 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10771 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10772 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10773 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10774 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10775 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10776 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10777 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10778 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10779 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10780 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10781      (
10782        cat <<\_ASBOX
10783   ## ------------------------------ ##
# Line 5202 | Line 10788 | esac
10788        sed "s/^/$as_me: WARNING:     /" >&2
10789      ;;
10790   esac
10791 < echo "$as_me:$LINENO: checking for zlib.h" >&5
10792 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
10793 < if test "${ac_cv_header_zlib_h+set}" = set; then
10791 > echo "$as_me:$LINENO: checking for iomanip" >&5
10792 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10793 > if test "${ac_cv_header_iomanip+set}" = set; then
10794    echo $ECHO_N "(cached) $ECHO_C" >&6
10795   else
10796 <  ac_cv_header_zlib_h=$ac_header_preproc
10796 >  ac_cv_header_iomanip=$ac_header_preproc
10797   fi
10798 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
10799 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
10798 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10799 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10800  
10801   fi
10802 < if test $ac_cv_header_zlib_h = yes; then
5217 <  zlib_cv_zlib_h=yes
5218 < else
5219 <  zlib_cv_zlib_h=no
5220 < fi
10802 > if test $ac_cv_header_iomanip = yes; then
10803  
10804  
10805 <        ac_ext=c
10806 < ac_cpp='$CPP $CPPFLAGS'
10807 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5226 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5227 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10805 > cat >>confdefs.h <<\_ACEOF
10806 > #define HAVE_IOMANIP 1
10807 > _ACEOF
10808  
5229        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
5230        then
5231                #
5232                # If both library and header were found, use them
5233                #
10809  
10810 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
10811 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
10812 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
10810 > else
10811 >
10812 >
10813 > for ac_header in iomanip.h
10814 > do
10815 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10816 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10817 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10818 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10819 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10820    echo $ECHO_N "(cached) $ECHO_C" >&6
10821 + fi
10822 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10823 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10824   else
10825 <  ac_check_lib_save_LIBS=$LIBS
10826 < LIBS="-lz  $LIBS"
10825 >  # Is the header compilable?
10826 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10827 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10828   cat >conftest.$ac_ext <<_ACEOF
10829   /* confdefs.h.  */
10830   _ACEOF
10831   cat confdefs.h >>conftest.$ac_ext
10832   cat >>conftest.$ac_ext <<_ACEOF
10833   /* end confdefs.h.  */
10834 <
10835 < /* Override any gcc2 internal prototype to avoid an error.  */
5250 < #ifdef __cplusplus
5251 < extern "C"
5252 < #endif
5253 < /* We use char because int might match the return type of a gcc2
5254 <   builtin and then its argument prototype would still apply.  */
5255 < char inflateEnd ();
5256 < int
5257 < main ()
5258 < {
5259 < inflateEnd ();
5260 <  ;
5261 <  return 0;
5262 < }
10834 > $ac_includes_default
10835 > #include <$ac_header>
10836   _ACEOF
10837 < rm -f conftest.$ac_objext conftest$ac_exeext
10838 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10839 <  (eval $ac_link) 2>conftest.er1
10837 > rm -f conftest.$ac_objext
10838 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10839 >  (eval $ac_compile) 2>conftest.er1
10840    ac_status=$?
10841    grep -v '^ *+' conftest.er1 >conftest.err
10842    rm -f conftest.er1
10843    cat conftest.err >&5
10844    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10845    (exit $ac_status); } &&
10846 <         { ac_try='test -z "$ac_c_werror_flag"
10846 >         { ac_try='test -z "$ac_cxx_werror_flag"
10847                           || test ! -s conftest.err'
10848    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10849    (eval $ac_try) 2>&5
10850    ac_status=$?
10851    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10852    (exit $ac_status); }; } &&
10853 <         { ac_try='test -s conftest$ac_exeext'
10853 >         { ac_try='test -s conftest.$ac_objext'
10854    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10855    (eval $ac_try) 2>&5
10856    ac_status=$?
10857    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10858    (exit $ac_status); }; }; then
10859 <  ac_cv_lib_z_inflateEnd=yes
10859 >  ac_header_compiler=yes
10860   else
10861    echo "$as_me: failed program was:" >&5
10862   sed 's/^/| /' conftest.$ac_ext >&5
10863  
10864 < ac_cv_lib_z_inflateEnd=no
10864 > ac_header_compiler=no
10865   fi
10866 < rm -f conftest.err conftest.$ac_objext \
10867 <      conftest$ac_exeext conftest.$ac_ext
10868 < LIBS=$ac_check_lib_save_LIBS
5296 < fi
5297 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5298 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5299 < if test $ac_cv_lib_z_inflateEnd = yes; then
5300 <  cat >>confdefs.h <<_ACEOF
5301 < #define HAVE_LIBZ 1
5302 < _ACEOF
10866 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10867 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10868 > echo "${ECHO_T}$ac_header_compiler" >&6
10869  
10870 <  LIBS="-lz $LIBS"
10871 <
10870 > # Is the header present?
10871 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10872 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10873 > cat >conftest.$ac_ext <<_ACEOF
10874 > /* confdefs.h.  */
10875 > _ACEOF
10876 > cat confdefs.h >>conftest.$ac_ext
10877 > cat >>conftest.$ac_ext <<_ACEOF
10878 > /* end confdefs.h.  */
10879 > #include <$ac_header>
10880 > _ACEOF
10881 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10882 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10883 >  ac_status=$?
10884 >  grep -v '^ *+' conftest.er1 >conftest.err
10885 >  rm -f conftest.er1
10886 >  cat conftest.err >&5
10887 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10888 >  (exit $ac_status); } >/dev/null; then
10889 >  if test -s conftest.err; then
10890 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10891 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10892 >  else
10893 >    ac_cpp_err=
10894 >  fi
10895 > else
10896 >  ac_cpp_err=yes
10897   fi
10898 + if test -z "$ac_cpp_err"; then
10899 +  ac_header_preproc=yes
10900 + else
10901 +  echo "$as_me: failed program was:" >&5
10902 + sed 's/^/| /' conftest.$ac_ext >&5
10903  
10904 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5309 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5310 <                echo "$as_me:$LINENO: result: ok" >&5
5311 < echo "${ECHO_T}ok" >&6
5312 <        else
5313 <                #
5314 <                # If either header or library was not found, revert and bomb
5315 <                #
5316 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5317 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5318 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5319 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5320 <                echo "$as_me:$LINENO: result: failed" >&5
5321 < echo "${ECHO_T}failed" >&6
5322 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5323 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5324 <   { (exit 1); exit 1; }; }
5325 <        fi
10904 >  ac_header_preproc=no
10905   fi
10906 + rm -f conftest.err conftest.$ac_ext
10907 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10908 + echo "${ECHO_T}$ac_header_preproc" >&6
10909  
10910 <
10910 > # So?  What about this header?
10911 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10912 >  yes:no: )
10913 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10914 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10915 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10916 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10917 >    ac_header_preproc=yes
10918 >    ;;
10919 >  no:yes:* )
10920 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10921 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10922 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10923 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10924 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10925 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10926 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10927 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10928 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10929 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10930 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10931 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10932 >    (
10933 >      cat <<\_ASBOX
10934 > ## ------------------------------ ##
10935 > ## Report this to gezelter@nd.edu ##
10936 > ## ------------------------------ ##
10937 > _ASBOX
10938 >    ) |
10939 >      sed "s/^/$as_me: WARNING:     /" >&2
10940 >    ;;
10941 > esac
10942 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10943 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10944 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10945 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10946 > else
10947 >  eval "$as_ac_Header=\$ac_header_preproc"
10948 > fi
10949 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10950 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10951  
10952 + fi
10953 + if test `eval echo '${'$as_ac_Header'}'` = yes; then
10954 +  cat >>confdefs.h <<_ACEOF
10955 + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10956 + _ACEOF
10957  
10958 + fi
10959  
10960 + done
10961  
10962  
10963 + fi
10964  
10965  
10966  
10967  
10968 < for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
10968 > for ac_header in cmath
10969   do
10970   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10971   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5368 | Line 10998 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10998    cat conftest.err >&5
10999    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11000    (exit $ac_status); } &&
11001 <         { ac_try='test -z "$ac_c_werror_flag"
11001 >         { ac_try='test -z "$ac_cxx_werror_flag"
11002                           || test ! -s conftest.err'
11003    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11004    (eval $ac_try) 2>&5
# Line 5412 | Line 11042 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11042    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11043    (exit $ac_status); } >/dev/null; then
11044    if test -s conftest.err; then
11045 <    ac_cpp_err=$ac_c_preproc_warn_flag
11046 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11045 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11046 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11047    else
11048      ac_cpp_err=
11049    fi
# Line 5433 | Line 11063 | echo "${ECHO_T}$ac_header_preproc" >&6
11063   echo "${ECHO_T}$ac_header_preproc" >&6
11064  
11065   # So?  What about this header?
11066 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11066 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11067    yes:no: )
11068      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11069   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 5487 | Line 11117 | done
11117  
11118  
11119  
11120 <
11121 <
11122 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
5493 < do
5494 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5495 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5496 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5497 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11120 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11121 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11122 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11123    echo $ECHO_N "(cached) $ECHO_C" >&6
11124   else
11125 <  cat >conftest.$ac_ext <<_ACEOF
11125 >
11126 >      ac_cv_cxx_have_std_iostream=no
11127 >      ac_cv_cxx_need_use_std_iostream=no
11128 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11129 >
11130 >
11131 >        ac_ext=cc
11132 > ac_cpp='$CXXCPP $CPPFLAGS'
11133 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11134 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11135 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11136 >
11137 >        cat >conftest.$ac_ext <<_ACEOF
11138   /* confdefs.h.  */
11139   _ACEOF
11140   cat confdefs.h >>conftest.$ac_ext
11141   cat >>conftest.$ac_ext <<_ACEOF
11142   /* end confdefs.h.  */
5506 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5507   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5508 #define $ac_func innocuous_$ac_func
11143  
11144 < /* System header to define __stub macros and hopefully few prototypes,
11145 <    which can conflict with char $ac_func (); below.
5512 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5513 <    <limits.h> exists even on freestanding compilers.  */
5514 <
5515 < #ifdef __STDC__
5516 < # include <limits.h>
11144 > #ifdef HAVE_IOSTREAM
11145 > #include <iostream>
11146   #else
11147 < # include <assert.h>
11147 > #include <iostream.h>
11148   #endif
11149  
11150 < #undef $ac_func
11151 <
11152 < /* Override any gcc2 internal prototype to avoid an error.  */
11153 < #ifdef __cplusplus
11154 < extern "C"
11155 < {
11150 > #ifdef FC_DUMMY_MAIN
11151 > #ifndef FC_DUMMY_MAIN_EQ_F77
11152 > #  ifdef __cplusplus
11153 >     extern "C"
11154 > #  endif
11155 >   int FC_DUMMY_MAIN() { return 1; }
11156   #endif
5528 /* We use char because int might match the return type of a gcc2
5529   builtin and then its argument prototype would still apply.  */
5530 char $ac_func ();
5531 /* The GNU C library defines this for functions which it implements
5532    to always fail with ENOSYS.  Some functions are actually named
5533    something starting with __ and the normal name is an alias.  */
5534 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5535 choke me
5536 #else
5537 char (*f) () = $ac_func;
11157   #endif
11158 < #ifdef __cplusplus
11158 > int
11159 > main ()
11160 > {
11161 > std::cout<<"Hello World"<<std::endl;return 0;
11162 >  ;
11163 >  return 0;
11164   }
11165 + _ACEOF
11166 + rm -f conftest.$ac_objext
11167 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11168 +  (eval $ac_compile) 2>conftest.er1
11169 +  ac_status=$?
11170 +  grep -v '^ *+' conftest.er1 >conftest.err
11171 +  rm -f conftest.er1
11172 +  cat conftest.err >&5
11173 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11174 +  (exit $ac_status); } &&
11175 +         { ac_try='test -z "$ac_cxx_werror_flag"
11176 +                         || test ! -s conftest.err'
11177 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11178 +  (eval $ac_try) 2>&5
11179 +  ac_status=$?
11180 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11181 +  (exit $ac_status); }; } &&
11182 +         { ac_try='test -s conftest.$ac_objext'
11183 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11184 +  (eval $ac_try) 2>&5
11185 +  ac_status=$?
11186 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11187 +  (exit $ac_status); }; }; then
11188 +  ac_cv_cxx_have_std_iostream=yes
11189 + else
11190 +  echo "$as_me: failed program was:" >&5
11191 + sed 's/^/| /' conftest.$ac_ext >&5
11192 +
11193 + fi
11194 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11195 +        cat >conftest.$ac_ext <<_ACEOF
11196 + /* confdefs.h.  */
11197 + _ACEOF
11198 + cat confdefs.h >>conftest.$ac_ext
11199 + cat >>conftest.$ac_ext <<_ACEOF
11200 + /* end confdefs.h.  */
11201 +
11202 + #define __USE_STD_IOSTREAM 1
11203 + #ifdef HAVE_IOSTREAM
11204 + #include <iostream>
11205 + #else
11206 + #include <iostream.h>
11207   #endif
11208  
11209 + #ifdef FC_DUMMY_MAIN
11210 + #ifndef FC_DUMMY_MAIN_EQ_F77
11211 + #  ifdef __cplusplus
11212 +     extern "C"
11213 + #  endif
11214 +   int FC_DUMMY_MAIN() { return 1; }
11215 + #endif
11216 + #endif
11217   int
11218   main ()
11219   {
11220 < return f != $ac_func;
11220 > std::cout<<"Hello World"<<std::endl;return 0;
11221    ;
11222    return 0;
11223   }
11224   _ACEOF
11225 < rm -f conftest.$ac_objext conftest$ac_exeext
11226 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11227 <  (eval $ac_link) 2>conftest.er1
11225 > rm -f conftest.$ac_objext
11226 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11227 >  (eval $ac_compile) 2>conftest.er1
11228    ac_status=$?
11229    grep -v '^ *+' conftest.er1 >conftest.err
11230    rm -f conftest.er1
11231    cat conftest.err >&5
11232    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11233    (exit $ac_status); } &&
11234 <         { ac_try='test -z "$ac_c_werror_flag"
11234 >         { ac_try='test -z "$ac_cxx_werror_flag"
11235                           || test ! -s conftest.err'
11236    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11237    (eval $ac_try) 2>&5
11238    ac_status=$?
11239    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11240    (exit $ac_status); }; } &&
11241 <         { ac_try='test -s conftest$ac_exeext'
11241 >         { ac_try='test -s conftest.$ac_objext'
11242    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11243    (eval $ac_try) 2>&5
11244    ac_status=$?
11245    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11246    (exit $ac_status); }; }; then
11247 <  eval "$as_ac_var=yes"
11247 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11248   else
11249    echo "$as_me: failed program was:" >&5
11250   sed 's/^/| /' conftest.$ac_ext >&5
11251  
5578 eval "$as_ac_var=no"
11252   fi
11253 < rm -f conftest.err conftest.$ac_objext \
11254 <      conftest$ac_exeext conftest.$ac_ext
11253 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11254 >        ac_ext=cc
11255 > ac_cpp='$CXXCPP $CPPFLAGS'
11256 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11257 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11258 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11259 >
11260 >      fi
11261 >
11262   fi
11263 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11264 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11265 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11266 <  cat >>confdefs.h <<_ACEOF
11267 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11263 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11264 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11265 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11266 >
11267 > cat >>confdefs.h <<\_ACEOF
11268 > #define HAVE_STD_IOSTREAM 1
11269   _ACEOF
11270  
11271 < fi
11272 < done
11271 >  fi
11272 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11273  
11274 < # special check for _system_configuration because AIX <4.3.2 do not
11275 < # contain the `physmem' member.
11276 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11277 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
11278 < cat >conftest.$ac_ext <<_ACEOF
11274 > cat >>confdefs.h <<\_ACEOF
11275 > #define __USE_STD_IOSTREAM 1
11276 > _ACEOF
11277 >
11278 >  fi
11279 >
11280 >
11281 >
11282 >
11283 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11284 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11285 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11286 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11287 > else
11288 >
11289 >      ac_cv_cxx_have_std_stl=no
11290 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11291 >
11292 >
11293 >        ac_ext=cc
11294 > ac_cpp='$CXXCPP $CPPFLAGS'
11295 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11296 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11297 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11298 >
11299 >        cat >conftest.$ac_ext <<_ACEOF
11300   /* confdefs.h.  */
11301   _ACEOF
11302   cat confdefs.h >>conftest.$ac_ext
11303   cat >>conftest.$ac_ext <<_ACEOF
11304   /* end confdefs.h.  */
11305 < #include <sys/systemcfg.h>
11305 > #include <list>
11306 >
11307 > #ifdef FC_DUMMY_MAIN
11308 > #ifndef FC_DUMMY_MAIN_EQ_F77
11309 > #  ifdef __cplusplus
11310 >     extern "C"
11311 > #  endif
11312 >   int FC_DUMMY_MAIN() { return 1; }
11313 > #endif
11314 > #endif
11315   int
11316   main ()
11317   {
11318 < double x = _system_configuration.physmem;
11318 > std::list<int> foo;return 0;
11319    ;
11320    return 0;
11321   }
# Line 5618 | Line 11329 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11329    cat conftest.err >&5
11330    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11331    (exit $ac_status); } &&
11332 <         { ac_try='test -z "$ac_c_werror_flag"
11332 >         { ac_try='test -z "$ac_cxx_werror_flag"
11333                           || test ! -s conftest.err'
11334    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11335    (eval $ac_try) 2>&5
# Line 5631 | Line 11342 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11342    ac_status=$?
11343    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11344    (exit $ac_status); }; }; then
11345 <  echo "$as_me:$LINENO: result: yes" >&5
11346 < echo "${ECHO_T}yes" >&6
11345 >  ac_cv_cxx_have_std_stl=yes
11346 > else
11347 >  echo "$as_me: failed program was:" >&5
11348 > sed 's/^/| /' conftest.$ac_ext >&5
11349  
11350 + fi
11351 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11352 +        ac_ext=cc
11353 + ac_cpp='$CXXCPP $CPPFLAGS'
11354 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11355 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11356 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11357 +
11358 +      fi
11359 +
11360 + fi
11361 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11362 + echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11363 +  if test "$ac_cv_cxx_have_std_stl" = yes; then
11364 +
11365   cat >>confdefs.h <<\_ACEOF
11366 < #define HAVE__SYSTEM_CONFIGURATION 1
11366 > #define HAVE_STD_STL 1
11367   _ACEOF
11368  
11369 +  fi
11370 +
11371 +
11372 +
11373 +  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11374 + echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11375 + if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11376 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11377   else
11378 +
11379 +    ac_cv_cxx_have_fstream_attach=no
11380 +
11381 +
11382 +    ac_ext=cc
11383 + ac_cpp='$CXXCPP $CPPFLAGS'
11384 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11385 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11386 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11387 +
11388 +    cat >conftest.$ac_ext <<_ACEOF
11389 + /* confdefs.h.  */
11390 + _ACEOF
11391 + cat confdefs.h >>conftest.$ac_ext
11392 + cat >>conftest.$ac_ext <<_ACEOF
11393 + /* end confdefs.h.  */
11394 +
11395 + #ifdef HAVE_IOSTREAM
11396 + #include <fstream>
11397 + #else
11398 + #include <fstream.h>
11399 + #endif
11400 + #ifdef HAVE_STD_IOSTREAM
11401 + using namespace std;
11402 + #endif
11403 +
11404 + #ifdef FC_DUMMY_MAIN
11405 + #ifndef FC_DUMMY_MAIN_EQ_F77
11406 + #  ifdef __cplusplus
11407 +     extern "C"
11408 + #  endif
11409 +   int FC_DUMMY_MAIN() { return 1; }
11410 + #endif
11411 + #endif
11412 + int
11413 + main ()
11414 + {
11415 + int fd=0;ofstream s;s.attach(fd);
11416 +  ;
11417 +  return 0;
11418 + }
11419 + _ACEOF
11420 + rm -f conftest.$ac_objext
11421 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11422 +  (eval $ac_compile) 2>conftest.er1
11423 +  ac_status=$?
11424 +  grep -v '^ *+' conftest.er1 >conftest.err
11425 +  rm -f conftest.er1
11426 +  cat conftest.err >&5
11427 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11428 +  (exit $ac_status); } &&
11429 +         { ac_try='test -z "$ac_cxx_werror_flag"
11430 +                         || test ! -s conftest.err'
11431 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11432 +  (eval $ac_try) 2>&5
11433 +  ac_status=$?
11434 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11435 +  (exit $ac_status); }; } &&
11436 +         { ac_try='test -s conftest.$ac_objext'
11437 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11438 +  (eval $ac_try) 2>&5
11439 +  ac_status=$?
11440 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11441 +  (exit $ac_status); }; }; then
11442 +  ac_cv_cxx_have_fstream_attach=yes
11443 + else
11444    echo "$as_me: failed program was:" >&5
11445   sed 's/^/| /' conftest.$ac_ext >&5
11446  
5645 echo "$as_me:$LINENO: result: no" >&5
5646 echo "${ECHO_T}no" >&6
11447   fi
11448   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11449 <
11450 <  # clean out junk possibly left behind by a previous configuration
11451 <  rm -f src/getopt.h
11452 <  # Check for getopt_long support
11449 >    ac_ext=cc
11450 > ac_cpp='$CXXCPP $CPPFLAGS'
11451 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11452 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11453 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11454  
11455 < for ac_header in getopt.h
11455 >
11456 > fi
11457 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11458 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11459 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11460 >
11461 > cat >>confdefs.h <<\_ACEOF
11462 > #define HAVE_FSTREAM_ATTACH 1
11463 > _ACEOF
11464 >
11465 >  fi
11466 >
11467 >
11468 >
11469 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11470 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11471 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11472 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11473 > else
11474 >
11475 >    ac_cv_cxx_have_fstream_open=no
11476 >    ac_cv_cxx_fstream_open_prot=no
11477 >
11478 >
11479 >    ac_ext=cc
11480 > ac_cpp='$CXXCPP $CPPFLAGS'
11481 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11482 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11483 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11484 >
11485 >    # Try with 2 parameters
11486 >    cat >conftest.$ac_ext <<_ACEOF
11487 > /* confdefs.h.  */
11488 > _ACEOF
11489 > cat confdefs.h >>conftest.$ac_ext
11490 > cat >>conftest.$ac_ext <<_ACEOF
11491 > /* end confdefs.h.  */
11492 >
11493 > #ifdef HAVE_IOSTREAM
11494 > #include <fstream>
11495 > #else
11496 > #include <fstream.h>
11497 > #endif
11498 > #ifdef HAVE_STD_IOSTREAM
11499 > using namespace std;
11500 > #endif
11501 >
11502 > #ifdef FC_DUMMY_MAIN
11503 > #ifndef FC_DUMMY_MAIN_EQ_F77
11504 > #  ifdef __cplusplus
11505 >     extern "C"
11506 > #  endif
11507 >   int FC_DUMMY_MAIN() { return 1; }
11508 > #endif
11509 > #endif
11510 > int
11511 > main ()
11512 > {
11513 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11514 >  ;
11515 >  return 0;
11516 > }
11517 > _ACEOF
11518 > rm -f conftest.$ac_objext
11519 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11520 >  (eval $ac_compile) 2>conftest.er1
11521 >  ac_status=$?
11522 >  grep -v '^ *+' conftest.er1 >conftest.err
11523 >  rm -f conftest.er1
11524 >  cat conftest.err >&5
11525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11526 >  (exit $ac_status); } &&
11527 >         { ac_try='test -z "$ac_cxx_werror_flag"
11528 >                         || test ! -s conftest.err'
11529 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11530 >  (eval $ac_try) 2>&5
11531 >  ac_status=$?
11532 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11533 >  (exit $ac_status); }; } &&
11534 >         { ac_try='test -s conftest.$ac_objext'
11535 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11536 >  (eval $ac_try) 2>&5
11537 >  ac_status=$?
11538 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11539 >  (exit $ac_status); }; }; then
11540 >  ac_cv_cxx_have_fstream_open=yes
11541 > else
11542 >  echo "$as_me: failed program was:" >&5
11543 > sed 's/^/| /' conftest.$ac_ext >&5
11544 >
11545 > fi
11546 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11547 >    # Try with mode parameter
11548 >    cat >conftest.$ac_ext <<_ACEOF
11549 > /* confdefs.h.  */
11550 > _ACEOF
11551 > cat confdefs.h >>conftest.$ac_ext
11552 > cat >>conftest.$ac_ext <<_ACEOF
11553 > /* end confdefs.h.  */
11554 >
11555 > #ifdef HAVE_IOSTREAM
11556 > #include <fstream>
11557 > #else
11558 > #include <fstream.h>
11559 > #endif
11560 > #ifdef HAVE_STD_IOSTREAM
11561 > using namespace std;
11562 > #endif
11563 >
11564 > #ifdef FC_DUMMY_MAIN
11565 > #ifndef FC_DUMMY_MAIN_EQ_F77
11566 > #  ifdef __cplusplus
11567 >     extern "C"
11568 > #  endif
11569 >   int FC_DUMMY_MAIN() { return 1; }
11570 > #endif
11571 > #endif
11572 > int
11573 > main ()
11574 > {
11575 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11576 >  ;
11577 >  return 0;
11578 > }
11579 > _ACEOF
11580 > rm -f conftest.$ac_objext
11581 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11582 >  (eval $ac_compile) 2>conftest.er1
11583 >  ac_status=$?
11584 >  grep -v '^ *+' conftest.er1 >conftest.err
11585 >  rm -f conftest.er1
11586 >  cat conftest.err >&5
11587 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11588 >  (exit $ac_status); } &&
11589 >         { ac_try='test -z "$ac_cxx_werror_flag"
11590 >                         || test ! -s conftest.err'
11591 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11592 >  (eval $ac_try) 2>&5
11593 >  ac_status=$?
11594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11595 >  (exit $ac_status); }; } &&
11596 >         { ac_try='test -s conftest.$ac_objext'
11597 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11598 >  (eval $ac_try) 2>&5
11599 >  ac_status=$?
11600 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11601 >  (exit $ac_status); }; }; then
11602 >  ac_cv_cxx_fstream_open_prot=yes
11603 > else
11604 >  echo "$as_me: failed program was:" >&5
11605 > sed 's/^/| /' conftest.$ac_ext >&5
11606 >
11607 > fi
11608 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11609 >    ac_ext=cc
11610 > ac_cpp='$CXXCPP $CPPFLAGS'
11611 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11612 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11613 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11614 >
11615 >
11616 > fi
11617 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11618 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11619 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11620 >
11621 > cat >>confdefs.h <<\_ACEOF
11622 > #define HAVE_FSTREAM_OPEN 1
11623 > _ACEOF
11624 >
11625 >  fi
11626 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11627 >
11628 > cat >>confdefs.h <<\_ACEOF
11629 > #define FSTREAM_OPEN_PROT 1
11630 > _ACEOF
11631 >
11632 >  fi
11633 >
11634 >
11635 >
11636 >
11637 >
11638 >
11639 >
11640 > for ac_header in ctype.h iostream fstream sstream strstream
11641   do
11642   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11643   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5684 | Line 11670 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11670    cat conftest.err >&5
11671    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11672    (exit $ac_status); } &&
11673 <         { ac_try='test -z "$ac_c_werror_flag"
11673 >         { ac_try='test -z "$ac_cxx_werror_flag"
11674                           || test ! -s conftest.err'
11675    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11676    (eval $ac_try) 2>&5
# Line 5728 | Line 11714 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11714    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11715    (exit $ac_status); } >/dev/null; then
11716    if test -s conftest.err; then
11717 <    ac_cpp_err=$ac_c_preproc_warn_flag
11718 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11717 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11718 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11719    else
11720      ac_cpp_err=
11721    fi
# Line 5749 | Line 11735 | echo "${ECHO_T}$ac_header_preproc" >&6
11735   echo "${ECHO_T}$ac_header_preproc" >&6
11736  
11737   # So?  What about this header?
11738 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11738 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11739    yes:no: )
11740      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11741   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 5800 | Line 11786 | done
11786  
11787   done
11788  
11789 + # AC_CPP_FUNC
11790 + # ------------------ #
11791 + # Checks to see if ANSI C99 CPP variable __func__ works.
11792 + # If not, perhaps __FUNCTION__ works instead.
11793 + # If not, we'll just define __func__ to "".
11794 + # AC_CPP_FUNC
11795  
11796 < for ac_func in getopt_long
11797 < do
11798 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11799 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5808 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5809 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11796 >
11797 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11798 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11799 > if test "${ac_cv_cpp_func+set}" = set; then
11800    echo $ECHO_N "(cached) $ECHO_C" >&6
11801   else
11802    cat >conftest.$ac_ext <<_ACEOF
# Line 5815 | Line 11805 | cat >>conftest.$ac_ext <<_ACEOF
11805   cat confdefs.h >>conftest.$ac_ext
11806   cat >>conftest.$ac_ext <<_ACEOF
11807   /* end confdefs.h.  */
5818 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5819   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5820 #define $ac_func innocuous_$ac_func
11808  
11809 < /* System header to define __stub macros and hopefully few prototypes,
11810 <    which can conflict with char $ac_func (); below.
11811 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11812 <    <limits.h> exists even on freestanding compilers.  */
11813 <
11814 < #ifdef __STDC__
5828 < # include <limits.h>
5829 < #else
5830 < # include <assert.h>
5831 < #endif
5832 <
5833 < #undef $ac_func
5834 <
5835 < /* Override any gcc2 internal prototype to avoid an error.  */
5836 < #ifdef __cplusplus
5837 < extern "C"
5838 < {
11809 > #ifdef FC_DUMMY_MAIN
11810 > #ifndef FC_DUMMY_MAIN_EQ_F77
11811 > #  ifdef __cplusplus
11812 >     extern "C"
11813 > #  endif
11814 >   int FC_DUMMY_MAIN() { return 1; }
11815   #endif
5840 /* We use char because int might match the return type of a gcc2
5841   builtin and then its argument prototype would still apply.  */
5842 char $ac_func ();
5843 /* The GNU C library defines this for functions which it implements
5844    to always fail with ENOSYS.  Some functions are actually named
5845    something starting with __ and the normal name is an alias.  */
5846 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5847 choke me
5848 #else
5849 char (*f) () = $ac_func;
11816   #endif
5851 #ifdef __cplusplus
5852 }
5853 #endif
5854
11817   int
11818   main ()
11819   {
11820 < return f != $ac_func;
11820 > const char *foo = __func__;
11821    ;
11822    return 0;
11823   }
11824   _ACEOF
11825 < rm -f conftest.$ac_objext conftest$ac_exeext
11826 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11827 <  (eval $ac_link) 2>conftest.er1
11825 > rm -f conftest.$ac_objext
11826 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11827 >  (eval $ac_compile) 2>conftest.er1
11828    ac_status=$?
11829    grep -v '^ *+' conftest.er1 >conftest.err
11830    rm -f conftest.er1
11831    cat conftest.err >&5
11832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11833    (exit $ac_status); } &&
11834 <         { ac_try='test -z "$ac_c_werror_flag"
11834 >         { ac_try='test -z "$ac_cxx_werror_flag"
11835                           || test ! -s conftest.err'
11836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11837    (eval $ac_try) 2>&5
11838    ac_status=$?
11839    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11840    (exit $ac_status); }; } &&
11841 <         { ac_try='test -s conftest$ac_exeext'
11841 >         { ac_try='test -s conftest.$ac_objext'
11842    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11843    (eval $ac_try) 2>&5
11844    ac_status=$?
11845    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11846    (exit $ac_status); }; }; then
11847 <  eval "$as_ac_var=yes"
11847 >  ac_cv_cpp_func=yes
11848   else
11849    echo "$as_me: failed program was:" >&5
11850   sed 's/^/| /' conftest.$ac_ext >&5
11851  
5890 eval "$as_ac_var=no"
5891 fi
5892 rm -f conftest.err conftest.$ac_objext \
5893      conftest$ac_exeext conftest.$ac_ext
5894 fi
5895 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5896 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5897 if test `eval echo '${'$as_ac_var'}'` = yes; then
5898  cat >>confdefs.h <<_ACEOF
5899 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5900 _ACEOF
5901
5902 else
5903  # FreeBSD has a gnugetopt library for this
5904    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5905 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5906 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5907  echo $ECHO_N "(cached) $ECHO_C" >&6
5908 else
5909  ac_check_lib_save_LIBS=$LIBS
5910 LIBS="-lgnugetopt  $LIBS"
11852   cat >conftest.$ac_ext <<_ACEOF
11853   /* confdefs.h.  */
11854   _ACEOF
# Line 5915 | Line 11856 | cat >>conftest.$ac_ext <<_ACEOF
11856   cat >>conftest.$ac_ext <<_ACEOF
11857   /* end confdefs.h.  */
11858  
11859 < /* Override any gcc2 internal prototype to avoid an error.  */
11860 < #ifdef __cplusplus
11861 < extern "C"
11859 > #ifdef FC_DUMMY_MAIN
11860 > #ifndef FC_DUMMY_MAIN_EQ_F77
11861 > #  ifdef __cplusplus
11862 >     extern "C"
11863 > #  endif
11864 >   int FC_DUMMY_MAIN() { return 1; }
11865   #endif
11866 < /* We use char because int might match the return type of a gcc2
5923 <   builtin and then its argument prototype would still apply.  */
5924 < char getopt_long ();
11866 > #endif
11867   int
11868   main ()
11869   {
11870 < getopt_long ();
11870 > const char *foo = __FUNCTION__;
11871    ;
11872    return 0;
11873   }
11874   _ACEOF
11875 < rm -f conftest.$ac_objext conftest$ac_exeext
11876 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11877 <  (eval $ac_link) 2>conftest.er1
11875 > rm -f conftest.$ac_objext
11876 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11877 >  (eval $ac_compile) 2>conftest.er1
11878    ac_status=$?
11879    grep -v '^ *+' conftest.er1 >conftest.err
11880    rm -f conftest.er1
11881    cat conftest.err >&5
11882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883    (exit $ac_status); } &&
11884 <         { ac_try='test -z "$ac_c_werror_flag"
11884 >         { ac_try='test -z "$ac_cxx_werror_flag"
11885                           || test ! -s conftest.err'
11886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887    (eval $ac_try) 2>&5
11888    ac_status=$?
11889    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11890    (exit $ac_status); }; } &&
11891 <         { ac_try='test -s conftest$ac_exeext'
11891 >         { ac_try='test -s conftest.$ac_objext'
11892    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11893    (eval $ac_try) 2>&5
11894    ac_status=$?
11895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896    (exit $ac_status); }; }; then
11897 <  ac_cv_lib_gnugetopt_getopt_long=yes
11897 >  ac_cv_cpp_func=__FUNCTION__
11898   else
11899    echo "$as_me: failed program was:" >&5
11900   sed 's/^/| /' conftest.$ac_ext >&5
11901  
11902 < ac_cv_lib_gnugetopt_getopt_long=no
11902 > ac_cv_cpp_func=no
11903   fi
11904 < rm -f conftest.err conftest.$ac_objext \
5963 <      conftest$ac_exeext conftest.$ac_ext
5964 < LIBS=$ac_check_lib_save_LIBS
11904 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11905   fi
11906 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11907 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11908 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11909 <  cat >>confdefs.h <<\_ACEOF
11910 < #define HAVE_GETOPT_LONG 1
11906 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11907 > fi
11908 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11909 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11910 > if test $ac_cv_cpp_func = __FUNCTION__; then
11911 >
11912 > cat >>confdefs.h <<\_ACEOF
11913 > #define __func__ __FUNCTION__
11914   _ACEOF
11915  
11916 < else
5974 <  # use the GNU replacement
5975 <      case $LIBOBJS in
5976 <    "getopt.$ac_objext"   | \
5977 <  *" getopt.$ac_objext"   | \
5978 <    "getopt.$ac_objext "* | \
5979 <  *" getopt.$ac_objext "* ) ;;
5980 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5981 < esac
11916 > elif test $ac_cv_cpp_func = no; then
11917  
11918 <      case $LIBOBJS in
11919 <    "getopt1.$ac_objext"   | \
11920 <  *" getopt1.$ac_objext"   | \
5986 <    "getopt1.$ac_objext "* | \
5987 <  *" getopt1.$ac_objext "* ) ;;
5988 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5989 < esac
11918 > cat >>confdefs.h <<\_ACEOF
11919 > #define __func__ ""
11920 > _ACEOF
11921  
5991                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5992
11922   fi
11923  
5995 fi
5996 done
11924  
11925  
11926  
11927 +
11928   case $debug in
11929    1)
11930       ;;
# Line 6005 | Line 11933 | case $debug in
11933  
11934  
11935  
11936 + # Try to determine "good" native compiler flags if none specified on command
11937 + # line
11938  
11939 + if test "$ac_test_FFLAGS" != "set"; then
11940 +  FCFLAGS=""
11941 +  case "${host_cpu}-${host_os}" in
11942  
11943 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11944 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11945 +                fi;;
11946 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11947 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11948 +                fi;;
11949 +   powerpc*-aix*)
11950 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11951 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11952 +                echo "*******************************************************"
11953 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11954 +                echo "*  recommended that you use                           *"
11955 +                echo "*                                                     *"
11956 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11957 +                echo "*                                 ^^^                 *"
11958 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11959 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11960 +                echo "*******************************************************"
11961 +        fi;;
11962 +   *darwin*)
11963 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11964 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11965 +        fi
11966 +        if test "$FC" = ifort; then
11967 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11968 +        fi;;
11969 +  esac
11970 +
11971 +  if test -n "$CPU_FLAGS"; then
11972 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11973 +  fi
11974 +
11975 +  if test -z "$FCFLAGS"; then
11976 +        echo ""
11977 +        echo "*********************************************************"
11978 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11979 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11980 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11981 +        echo "*********************************************************"
11982 +        echo ""
11983 +        FCFLAGS="-O3"
11984 +  fi
11985 +
11986 +
11987 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11988 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11989 + if test "${ac_guessed_f90flags+set}" = set; then
11990 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11991 + else
11992 +
11993 +
11994 +
11995 + ac_ext=${FC_SRCEXT-f}
11996 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11997 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11998 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11999 +
12000 + echo 'program main' > conftest.$ac_ext
12001 + echo 'end program main' >> conftest.$ac_ext
12002 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12003 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12004 +  (eval $ac_compile) 2>&5
12005 +  ac_status=$?
12006 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12007 +  (exit $ac_status); }; then
12008 +        ac_guessed_f90flags=yes
12009 + else
12010 +        ac_guessed_f90flags=no
12011 + fi
12012 + rm -f conftest*
12013 + ac_ext=cc
12014 + ac_cpp='$CXXCPP $CPPFLAGS'
12015 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12016 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12017 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12018 +
12019 +
12020 + fi
12021 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12022 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12023 + if test "$ac_guessed_f90flags" = yes; then
12024 +        :
12025 +
12026 + else
12027 +        :
12028 +
12029 +        echo ""
12030 +        echo "**********************************************************"
12031 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12032 +        echo "* your compiler.                                        *"
12033 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12034 +        echo "*********************************************************"
12035 +        echo ""
12036 +        FCFLAGS=""
12037 +
12038 + fi
12039 +
12040 +
12041 + fi
12042 +
12043 +
12044 +
12045 +
12046 +
12047 +
12048 +
12049   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12050   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12051   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 6015 | Line 12054 | cat > conftest.c <<EOF
12054  
12055   cat > conftest.c <<EOF
12056   #ifdef __GNUC__
12057 <  #ifndef __INTEL_COMPILER
12057 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12058 >     no;
12059 >  #else
12060       yes;
12061    #endif
12062   #endif
# Line 6053 | Line 12094 | if test "$ac_test_CFLAGS" != "set"; then
12094                      CFLAGS="-O"
12095                  fi;;
12096    sparc-solaris2*) if test "$CC" = cc; then
12097 <                    CFLAGS="-native -fast -xO5 -dalign"
12097 >                    CFLAGS="-O -dalign"
12098                   fi;;
12099  
12100    alpha*-osf*)  if test "$CC" = cc; then
# Line 6083 | Line 12124 | if test "$ac_test_CFLAGS" != "set"; then
12124     *darwin*)
12125          if test "$CC" = xlc -o "$CC" = cc; then
12126                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12127 +        fi
12128 +        if test "$CC" = icc; then
12129 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12130          fi;;
12131    esac
12132  
# Line 6096 | Line 12140 | if test "$ac_test_CFLAGS" != "set"; then
12140      # -malign-double for x86 systems
12141  
12142  
12143 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12144 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12143 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12144 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12145   if test "${ac_align_double+set}" = set; then
12146    echo $ECHO_N "(cached) $ECHO_C" >&6
12147   else
12148    echo 'void f(){}' > conftest.c
12149 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12149 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12150          ac_align_double=yes
12151   else
12152          ac_align_double=no
# Line 6123 | Line 12167 | fi
12167      # -fstrict-aliasing for gcc-2.95+
12168  
12169  
12170 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12171 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12170 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12171 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12172   if test "${ac_fstrict_aliasing+set}" = set; then
12173    echo $ECHO_N "(cached) $ECHO_C" >&6
12174   else
12175    echo 'void f(){}' > conftest.c
12176 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12176 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12177          ac_fstrict_aliasing=yes
12178   else
12179          ac_fstrict_aliasing=no
# Line 6154 | Line 12198 | fi
12198                    case "${host_cpu}" in
12199            i586*)
12200  
12201 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12202 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12201 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12202 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12203   if test "${ac_cpu_pentium+set}" = set; then
12204    echo $ECHO_N "(cached) $ECHO_C" >&6
12205   else
12206    echo 'void f(){}' > conftest.c
12207 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12207 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12208          ac_cpu_pentium=yes
12209   else
12210          ac_cpu_pentium=no
# Line 6177 | Line 12221 | else
12221          :
12222  
12223  
12224 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12225 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12224 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12225 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12226   if test "${ac_pentium+set}" = set; then
12227    echo $ECHO_N "(cached) $ECHO_C" >&6
12228   else
12229    echo 'void f(){}' > conftest.c
12230 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12230 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12231          ac_pentium=yes
12232   else
12233          ac_pentium=no
# Line 6206 | Line 12250 | fi
12250                    ;;
12251            i686*)
12252  
12253 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12254 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12253 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12254 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12255   if test "${ac_cpu_pentiumpro+set}" = set; then
12256    echo $ECHO_N "(cached) $ECHO_C" >&6
12257   else
12258    echo 'void f(){}' > conftest.c
12259 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12259 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12260          ac_cpu_pentiumpro=yes
12261   else
12262          ac_cpu_pentiumpro=no
# Line 6229 | Line 12273 | else
12273          :
12274  
12275  
12276 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12277 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12276 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12277 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12278   if test "${ac_pentiumpro+set}" = set; then
12279    echo $ECHO_N "(cached) $ECHO_C" >&6
12280   else
12281    echo 'void f(){}' > conftest.c
12282 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12282 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12283          ac_pentiumpro=yes
12284   else
12285          ac_pentiumpro=no
# Line 6262 | Line 12306 | fi
12306                  if test -n "$is60x"; then
12307  
12308  
12309 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12310 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12309 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12310 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12311   if test "${ac_m_cpu_60x+set}" = set; then
12312    echo $ECHO_N "(cached) $ECHO_C" >&6
12313   else
12314    echo 'void f(){}' > conftest.c
12315 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12315 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12316          ac_m_cpu_60x=yes
12317   else
12318          ac_m_cpu_60x=no
# Line 6320 | Line 12364 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12364          :
12365  
12366  
12367 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12368 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12367 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12368 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12369   if test "${ac_m_cpu_750+set}" = set; then
12370    echo $ECHO_N "(cached) $ECHO_C" >&6
12371   else
12372    echo 'void f(){}' > conftest.c
12373 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12373 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12374          ac_m_cpu_750=yes
12375   else
12376          ac_m_cpu_750=no
# Line 6353 | Line 12397 | fi
12397                  if test -z "$CPU_FLAGS"; then
12398  
12399  
12400 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12401 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12400 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12401 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12402   if test "${ac_m_cpu_powerpc+set}" = set; then
12403    echo $ECHO_N "(cached) $ECHO_C" >&6
12404   else
12405    echo 'void f(){}' > conftest.c
12406 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12406 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12407          ac_m_cpu_powerpc=yes
12408   else
12409          ac_m_cpu_powerpc=no
# Line 6381 | Line 12425 | fi
12425                  if test -z "$CPU_FLAGS"; then
12426  
12427  
12428 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12429 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12428 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12429 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12430   if test "${ac_m_powerpc+set}" = set; then
12431    echo $ECHO_N "(cached) $ECHO_C" >&6
12432   else
12433    echo 'void f(){}' > conftest.c
12434 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12434 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12435          ac_m_powerpc=yes
12436   else
12437          ac_m_powerpc=no
# Line 6426 | Line 12470 | fi
12470  
12471  
12472  
12473 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12474 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12473 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12474 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12475   if test "${ac_guessed_cflags+set}" = set; then
12476    echo $ECHO_N "(cached) $ECHO_C" >&6
12477   else
12478    echo 'void f(){}' > conftest.c
12479 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12479 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12480          ac_guessed_cflags=yes
12481   else
12482          ac_guessed_cflags=no
# Line 6476 | Line 12520 | cat > conftest.cpp <<EOF
12520  
12521   cat > conftest.cpp <<EOF
12522   #ifdef __GNUC__
12523 <  #ifndef __INTEL_COMPILER
12523 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12524 >     no;
12525 >  #else
12526       yes;
12527    #endif
12528   #endif
# Line 6514 | Line 12560 | if test "$ac_test_CXXFLAGS" != "set"; then
12560                      CXXFLAGS="-O"
12561                  fi;;
12562    sparc-solaris2*) if test "$CXX" = CC; then
12563 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12563 >                    CXXFLAGS="-features=extensions -O -dalign"
12564                   fi;;
12565     rs6000*-aix*)  if test "$CXX" = xlC; then
12566                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 6535 | Line 12581 | if test "$ac_test_CXXFLAGS" != "set"; then
12581     *darwin*)
12582          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12583                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12584 +        fi
12585 +        if test "$CXX" = icpc; then
12586 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12587          fi;;
12588    esac
12589  
# Line 6548 | Line 12597 | if test "$ac_test_CXXFLAGS" != "set"; then
12597      # -malign-double for x86 systems
12598  
12599  
12600 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12601 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12600 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12601 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12602   if test "${ac_align_double+set}" = set; then
12603    echo $ECHO_N "(cached) $ECHO_C" >&6
12604   else
12605    echo 'void f(){}' > conftest.cpp
12606 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12606 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12607          ac_align_double=yes
12608   else
12609          ac_align_double=no
# Line 6575 | Line 12624 | fi
12624      # -fstrict-aliasing for gcc-2.95+
12625  
12626  
12627 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12628 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12627 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12628 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12629   if test "${ac_fstrict_aliasing+set}" = set; then
12630    echo $ECHO_N "(cached) $ECHO_C" >&6
12631   else
12632    echo 'void f(){}' > conftest.cpp
12633 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12633 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12634          ac_fstrict_aliasing=yes
12635   else
12636          ac_fstrict_aliasing=no
# Line 6606 | Line 12655 | fi
12655                    case "${host_cpu}" in
12656            i586*)
12657  
12658 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12659 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12658 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12659 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12660   if test "${ac_cpu_pentium+set}" = set; then
12661    echo $ECHO_N "(cached) $ECHO_C" >&6
12662   else
12663    echo 'void f(){}' > conftest.cpp
12664 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12664 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12665          ac_cpu_pentium=yes
12666   else
12667          ac_cpu_pentium=no
# Line 6629 | Line 12678 | else
12678          :
12679  
12680  
12681 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12682 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12681 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12682 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12683   if test "${ac_pentium+set}" = set; then
12684    echo $ECHO_N "(cached) $ECHO_C" >&6
12685   else
12686    echo 'void f(){}' > conftest.cpp
12687 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12687 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12688          ac_pentium=yes
12689   else
12690          ac_pentium=no
# Line 6658 | Line 12707 | fi
12707                    ;;
12708            i686*)
12709  
12710 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12711 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12710 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12711 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12712   if test "${ac_cpu_pentiumpro+set}" = set; then
12713    echo $ECHO_N "(cached) $ECHO_C" >&6
12714   else
12715    echo 'void f(){}' > conftest.cpp
12716 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12716 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12717          ac_cpu_pentiumpro=yes
12718   else
12719          ac_cpu_pentiumpro=no
# Line 6681 | Line 12730 | else
12730          :
12731  
12732  
12733 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12734 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12733 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12734 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12735   if test "${ac_pentiumpro+set}" = set; then
12736    echo $ECHO_N "(cached) $ECHO_C" >&6
12737   else
12738    echo 'void f(){}' > conftest.cpp
12739 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12739 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12740          ac_pentiumpro=yes
12741   else
12742          ac_pentiumpro=no
# Line 6714 | Line 12763 | fi
12763                  if test -n "$is60x"; then
12764  
12765  
12766 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12767 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12766 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12767 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12768   if test "${ac_m_cpu_60x+set}" = set; then
12769    echo $ECHO_N "(cached) $ECHO_C" >&6
12770   else
12771    echo 'void f(){}' > conftest.cpp
12772 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12772 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12773          ac_m_cpu_60x=yes
12774   else
12775          ac_m_cpu_60x=no
# Line 6755 | Line 12804 | if { ac_try='${CXX-c++} -E conftest.cpp'
12804   #endif
12805   EOF
12806   if { ac_try='${CXX-c++} -E conftest.cpp'
6758  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6759  (eval $ac_try) 2>&5
6760  ac_status=$?
6761  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6762  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
6763  ac_cv_prog_gxx_2_95=yes
6764 else
6765  ac_cv_prog_gxx_2_95=no
6766 fi
6767
6768 fi
6769 echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
6770 echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
6771 if test "$ac_cv_prog_gxx_2_95" = yes; then
6772        :
6773
6774
6775 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
6776 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
6777 if test "${ac_m_cpu_750+set}" = set; then
6778  echo $ECHO_N "(cached) $ECHO_C" >&6
6779 else
6780  echo 'void f(){}' > conftest.cpp
6781 if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
6782        ac_m_cpu_750=yes
6783 else
6784        ac_m_cpu_750=no
6785 fi
6786 rm -f conftest*
6787
6788 fi
6789 echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
6790 echo "${ECHO_T}$ac_m_cpu_750" >&6
6791 if test "$ac_m_cpu_750" = yes; then
6792        :
6793        CPU_FLAGS=-mcpu=750
6794 else
6795        :
6796
6797 fi
6798
6799 else
6800        :
6801
6802 fi
6803
6804                fi
6805                if test -z "$CPU_FLAGS"; then
6806
6807
6808 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
6809 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
6810 if test "${ac_m_cpu_powerpc+set}" = set; then
6811  echo $ECHO_N "(cached) $ECHO_C" >&6
6812 else
6813  echo 'void f(){}' > conftest.cpp
6814 if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
6815        ac_m_cpu_powerpc=yes
6816 else
6817        ac_m_cpu_powerpc=no
6818 fi
6819 rm -f conftest*
6820
6821 fi
6822 echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
6823 echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
6824 if test "$ac_m_cpu_powerpc" = yes; then
6825        :
6826        CPU_FLAGS=-mcpu=powerpc
6827 else
6828        :
6829
6830 fi
6831
6832                fi
6833                if test -z "$CPU_FLAGS"; then
6834
6835
6836 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
6837 echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
6838 if test "${ac_m_powerpc+set}" = set; then
6839  echo $ECHO_N "(cached) $ECHO_C" >&6
6840 else
6841  echo 'void f(){}' > conftest.cpp
6842 if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
6843        ac_m_powerpc=yes
6844 else
6845        ac_m_powerpc=no
6846 fi
6847 rm -f conftest*
6848
6849 fi
6850 echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
6851 echo "${ECHO_T}$ac_m_powerpc" >&6
6852 if test "$ac_m_powerpc" = yes; then
6853        :
6854        CPU_FLAGS=-mpowerpc
6855 else
6856        :
6857
6858 fi
6859
6860                fi
6861          esac
6862  fi
6863
6864  if test -n "$CPU_FLAGS"; then
6865        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6866  fi
6867
6868  if test -z "$CXXFLAGS"; then
6869        echo ""
6870        echo "**********************************************************"
6871        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6872        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6873        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6874        echo "**********************************************************"
6875        echo ""
6876        CXXFLAGS="-O3"
6877  fi
6878
6879
6880
6881 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6882 echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6883 if test "${ac_guessed_cxxflags+set}" = set; then
6884  echo $ECHO_N "(cached) $ECHO_C" >&6
6885 else
6886  echo 'void f(){}' > conftest.cpp
6887 if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6888        ac_guessed_cxxflags=yes
6889 else
6890        ac_guessed_cxxflags=no
6891 fi
6892 rm -f conftest*
6893
6894 fi
6895 echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6896 echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6897 if test "$ac_guessed_cxxflags" = yes; then
6898        :
6899
6900 else
6901        :
6902
6903        echo ""
6904        echo "**********************************************************"
6905        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6906        echo "* your compiler.                                         *"
6907        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6908        echo "**********************************************************"
6909        echo ""
6910        CXXFLAGS=""
6911
6912 fi
6913
6914
6915 fi
6916
6917
6918
6919
6920
6921 # Try to determine "good" native compiler flags if none specified on command
6922 # line
6923
6924 if test x"$F90FLAGS" = x ; then
6925  F90FLAGS=""
6926  case "${host_cpu}-${host_os}" in
6927
6928  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6929                    F90FLAGS="-O"
6930                fi;;
6931   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6932                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6933                fi;;
6934   powerpc*-aix*)
6935        if test "$F90" = f90 -o "$F90" = xlf90; then
6936                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6937                echo "*******************************************************"
6938                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6939                echo "*  recommended that you use                           *"
6940                echo "*                                                     *"
6941                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6942                echo "*                                 ^^^                 *"
6943                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6944                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6945                echo "*******************************************************"
6946        fi;;
6947   *darwin*)
6948        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6949                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6950        fi;;
6951  esac
6952
6953  if test -n "$CPU_FLAGS"; then
6954        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6955  fi
6956
6957  if test -z "$F90FLAGS"; then
6958        echo ""
6959        echo "**********************************************************"
6960        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6961        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6962        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6963        echo "**********************************************************"
6964        echo ""
6965        F90FLAGS="-O3"
6966  fi
6967
6968
6969 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6970 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6971 if test "${ac_guessed_f90flags+set}" = set; then
6972  echo $ECHO_N "(cached) $ECHO_C" >&6
6973 else
6974
6975
6976
6977 ac_ext=f90
6978 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6979 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6980 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6981
6982 echo 'program main' > conftest.$ac_ext
6983 echo 'end program main' >> conftest.$ac_ext
6984 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6985 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6986  (eval $ac_compile) 2>&5
6987  ac_status=$?
6988  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6989  (exit $ac_status); }; then
6990        ac_guessed_f90flags=yes
6991 else
6992        ac_guessed_f90flags=no
6993 fi
6994 rm -f conftest*
6995 ac_ext=c
6996 ac_cpp='$CPP $CPPFLAGS'
6997 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6998 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6999 ac_compiler_gnu=$ac_cv_c_compiler_gnu
7000
7001
7002 fi
7003 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
7004 echo "${ECHO_T}$ac_guessed_f90flags" >&6
7005 if test "$ac_guessed_f90flags" = yes; then
7006        :
7007
7008 else
7009        :
7010
7011        echo ""
7012        echo "**********************************************************"
7013        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
7014        echo "* your compiler.                                         *"
7015        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
7016        echo "**********************************************************"
7017        echo ""
7018        F90FLAGS=""
7019
7020 fi
7021
7022
7023 fi
7024
7025     ;;
7026 esac
7027
7028 # Find a good install program.  We prefer a C program (faster),
7029 # so one script is as good as another.  But avoid the broken or
7030 # incompatible versions:
7031 # SysV /etc/install, /usr/sbin/install
7032 # SunOS /usr/etc/install
7033 # IRIX /sbin/install
7034 # AIX /bin/install
7035 # AmigaOS /C/install, which installs bootblocks on floppy discs
7036 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
7037 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
7038 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
7039 # OS/2's system install, which has a completely different semantic
7040 # ./install, which can be erroneously created by make from ./install.sh.
7041 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
7042 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
7043 if test -z "$INSTALL"; then
7044 if test "${ac_cv_path_install+set}" = set; then
7045  echo $ECHO_N "(cached) $ECHO_C" >&6
7046 else
7047  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7048 for as_dir in $PATH
7049 do
7050  IFS=$as_save_IFS
7051  test -z "$as_dir" && as_dir=.
7052  # Account for people who put trailing slashes in PATH elements.
7053 case $as_dir/ in
7054  ./ | .// | /cC/* | \
7055  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
7056  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
7057  /usr/ucb/* ) ;;
7058  *)
7059    # OSF1 and SCO ODT 3.0 have their own names for install.
7060    # Don't use installbsd from OSF since it installs stuff as root
7061    # by default.
7062    for ac_prog in ginstall scoinst install; do
7063      for ac_exec_ext in '' $ac_executable_extensions; do
7064        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
7065          if test $ac_prog = install &&
7066            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
7067            # AIX install.  It has an incompatible calling convention.
7068            :
7069          elif test $ac_prog = install &&
7070            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
7071            # program-specific install script used by HP pwplus--don't use.
7072            :
7073          else
7074            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
7075            break 3
7076          fi
7077        fi
7078      done
7079    done
7080    ;;
7081 esac
7082 done
7083
7084
7085 fi
7086  if test "${ac_cv_path_install+set}" = set; then
7087    INSTALL=$ac_cv_path_install
7088  else
7089    # As a last resort, use the slow shell script.  We don't cache a
7090    # path for INSTALL within a source directory, because that will
7091    # break other packages using the cache if that directory is
7092    # removed, or if the path is relative.
7093    INSTALL=$ac_install_sh
7094  fi
7095 fi
7096 echo "$as_me:$LINENO: result: $INSTALL" >&5
7097 echo "${ECHO_T}$INSTALL" >&6
7098
7099 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
7100 # It thinks the first close brace ends the variable substitution.
7101 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
7102
7103 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
7104
7105 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
7106
7107 echo "$as_me:$LINENO: checking whether ln -s works" >&5
7108 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
7109 LN_S=$as_ln_s
7110 if test "$LN_S" = "ln -s"; then
7111  echo "$as_me:$LINENO: result: yes" >&5
7112 echo "${ECHO_T}yes" >&6
7113 else
7114  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
7115 echo "${ECHO_T}no, using $LN_S" >&6
7116 fi
7117
7118 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
7119 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
7120 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
7121 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
7122  echo $ECHO_N "(cached) $ECHO_C" >&6
7123 else
7124  cat >conftest.make <<\_ACEOF
7125 all:
7126        @echo 'ac_maketemp="$(MAKE)"'
7127 _ACEOF
7128 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
7129 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
7130 if test -n "$ac_maketemp"; then
7131  eval ac_cv_prog_make_${ac_make}_set=yes
7132 else
7133  eval ac_cv_prog_make_${ac_make}_set=no
7134 fi
7135 rm -f conftest.make
7136 fi
7137 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
7138  echo "$as_me:$LINENO: result: yes" >&5
7139 echo "${ECHO_T}yes" >&6
7140  SET_MAKE=
7141 else
7142  echo "$as_me:$LINENO: result: no" >&5
7143 echo "${ECHO_T}no" >&6
7144  SET_MAKE="MAKE=${MAKE-make}"
7145 fi
7146
7147 if test -n "$ac_tool_prefix"; then
7148  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
7149 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
7150 echo "$as_me:$LINENO: checking for $ac_word" >&5
7151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7152 if test "${ac_cv_prog_RANLIB+set}" = set; then
7153  echo $ECHO_N "(cached) $ECHO_C" >&6
7154 else
7155  if test -n "$RANLIB"; then
7156  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7157 else
7158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7159 for as_dir in $PATH
7160 do
7161  IFS=$as_save_IFS
7162  test -z "$as_dir" && as_dir=.
7163  for ac_exec_ext in '' $ac_executable_extensions; do
7164  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7165    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
7166    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7167    break 2
7168  fi
7169 done
7170 done
7171
7172 fi
7173 fi
7174 RANLIB=$ac_cv_prog_RANLIB
7175 if test -n "$RANLIB"; then
7176  echo "$as_me:$LINENO: result: $RANLIB" >&5
7177 echo "${ECHO_T}$RANLIB" >&6
7178 else
7179  echo "$as_me:$LINENO: result: no" >&5
7180 echo "${ECHO_T}no" >&6
7181 fi
7182
7183 fi
7184 if test -z "$ac_cv_prog_RANLIB"; then
7185  ac_ct_RANLIB=$RANLIB
7186  # Extract the first word of "ranlib", so it can be a program name with args.
7187 set dummy ranlib; ac_word=$2
7188 echo "$as_me:$LINENO: checking for $ac_word" >&5
7189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7190 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
7191  echo $ECHO_N "(cached) $ECHO_C" >&6
7192 else
7193  if test -n "$ac_ct_RANLIB"; then
7194  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
7195 else
7196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7197 for as_dir in $PATH
7198 do
7199  IFS=$as_save_IFS
7200  test -z "$as_dir" && as_dir=.
7201  for ac_exec_ext in '' $ac_executable_extensions; do
7202  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7203    ac_cv_prog_ac_ct_RANLIB="ranlib"
7204    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7205    break 2
7206  fi
7207 done
7208 done
7209
7210  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
7211 fi
7212 fi
7213 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
7214 if test -n "$ac_ct_RANLIB"; then
7215  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
7216 echo "${ECHO_T}$ac_ct_RANLIB" >&6
7217 else
7218  echo "$as_me:$LINENO: result: no" >&5
7219 echo "${ECHO_T}no" >&6
7220 fi
7221
7222  RANLIB=$ac_ct_RANLIB
7223 else
7224  RANLIB="$ac_cv_prog_RANLIB"
7225 fi
7226
7227 for ac_prog in 'bison -y' byacc
7228 do
7229  # Extract the first word of "$ac_prog", so it can be a program name with args.
7230 set dummy $ac_prog; ac_word=$2
7231 echo "$as_me:$LINENO: checking for $ac_word" >&5
7232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7233 if test "${ac_cv_prog_YACC+set}" = set; then
7234  echo $ECHO_N "(cached) $ECHO_C" >&6
7235 else
7236  if test -n "$YACC"; then
7237  ac_cv_prog_YACC="$YACC" # Let the user override the test.
7238 else
7239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7240 for as_dir in $PATH
7241 do
7242  IFS=$as_save_IFS
7243  test -z "$as_dir" && as_dir=.
7244  for ac_exec_ext in '' $ac_executable_extensions; do
7245  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7246    ac_cv_prog_YACC="$ac_prog"
7247    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7248    break 2
7249  fi
7250 done
7251 done
7252
7253 fi
7254 fi
7255 YACC=$ac_cv_prog_YACC
7256 if test -n "$YACC"; then
7257  echo "$as_me:$LINENO: result: $YACC" >&5
7258 echo "${ECHO_T}$YACC" >&6
7259 else
7260  echo "$as_me:$LINENO: result: no" >&5
7261 echo "${ECHO_T}no" >&6
7262 fi
7263
7264  test -n "$YACC" && break
7265 done
7266 test -n "$YACC" || YACC="yacc"
7267
7268 for ac_prog in flex lex
7269 do
7270  # Extract the first word of "$ac_prog", so it can be a program name with args.
7271 set dummy $ac_prog; ac_word=$2
7272 echo "$as_me:$LINENO: checking for $ac_word" >&5
7273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7274 if test "${ac_cv_prog_LEX+set}" = set; then
7275  echo $ECHO_N "(cached) $ECHO_C" >&6
7276 else
7277  if test -n "$LEX"; then
7278  ac_cv_prog_LEX="$LEX" # Let the user override the test.
7279 else
7280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7281 for as_dir in $PATH
7282 do
7283  IFS=$as_save_IFS
7284  test -z "$as_dir" && as_dir=.
7285  for ac_exec_ext in '' $ac_executable_extensions; do
7286  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7287    ac_cv_prog_LEX="$ac_prog"
7288    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7289    break 2
7290  fi
7291 done
7292 done
7293
7294 fi
7295 fi
7296 LEX=$ac_cv_prog_LEX
7297 if test -n "$LEX"; then
7298  echo "$as_me:$LINENO: result: $LEX" >&5
7299 echo "${ECHO_T}$LEX" >&6
7300 else
7301  echo "$as_me:$LINENO: result: no" >&5
7302 echo "${ECHO_T}no" >&6
7303 fi
7304
7305  test -n "$LEX" && break
7306 done
7307 test -n "$LEX" || LEX=":"
7308
7309 if test -z "$LEXLIB"
7310 then
7311  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
7312 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
7313 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
7314  echo $ECHO_N "(cached) $ECHO_C" >&6
7315 else
7316  ac_check_lib_save_LIBS=$LIBS
7317 LIBS="-lfl  $LIBS"
7318 cat >conftest.$ac_ext <<_ACEOF
7319 /* confdefs.h.  */
7320 _ACEOF
7321 cat confdefs.h >>conftest.$ac_ext
7322 cat >>conftest.$ac_ext <<_ACEOF
7323 /* end confdefs.h.  */
7324
7325 /* Override any gcc2 internal prototype to avoid an error.  */
7326 #ifdef __cplusplus
7327 extern "C"
7328 #endif
7329 /* We use char because int might match the return type of a gcc2
7330   builtin and then its argument prototype would still apply.  */
7331 char yywrap ();
7332 int
7333 main ()
7334 {
7335 yywrap ();
7336  ;
7337  return 0;
7338 }
7339 _ACEOF
7340 rm -f conftest.$ac_objext conftest$ac_exeext
7341 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7342  (eval $ac_link) 2>conftest.er1
7343  ac_status=$?
7344  grep -v '^ *+' conftest.er1 >conftest.err
7345  rm -f conftest.er1
7346  cat conftest.err >&5
7347  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7348  (exit $ac_status); } &&
7349         { ac_try='test -z "$ac_c_werror_flag"
7350                         || test ! -s conftest.err'
7351  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7352  (eval $ac_try) 2>&5
7353  ac_status=$?
7354  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7355  (exit $ac_status); }; } &&
7356         { ac_try='test -s conftest$ac_exeext'
7357  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7358  (eval $ac_try) 2>&5
7359  ac_status=$?
7360  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7361  (exit $ac_status); }; }; then
7362  ac_cv_lib_fl_yywrap=yes
7363 else
7364  echo "$as_me: failed program was:" >&5
7365 sed 's/^/| /' conftest.$ac_ext >&5
7366
7367 ac_cv_lib_fl_yywrap=no
7368 fi
7369 rm -f conftest.err conftest.$ac_objext \
7370      conftest$ac_exeext conftest.$ac_ext
7371 LIBS=$ac_check_lib_save_LIBS
7372 fi
7373 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
7374 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
7375 if test $ac_cv_lib_fl_yywrap = yes; then
7376  LEXLIB="-lfl"
7377 else
7378  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
7379 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
7380 if test "${ac_cv_lib_l_yywrap+set}" = set; then
7381  echo $ECHO_N "(cached) $ECHO_C" >&6
7382 else
7383  ac_check_lib_save_LIBS=$LIBS
7384 LIBS="-ll  $LIBS"
7385 cat >conftest.$ac_ext <<_ACEOF
7386 /* confdefs.h.  */
7387 _ACEOF
7388 cat confdefs.h >>conftest.$ac_ext
7389 cat >>conftest.$ac_ext <<_ACEOF
7390 /* end confdefs.h.  */
7391
7392 /* Override any gcc2 internal prototype to avoid an error.  */
7393 #ifdef __cplusplus
7394 extern "C"
7395 #endif
7396 /* We use char because int might match the return type of a gcc2
7397   builtin and then its argument prototype would still apply.  */
7398 char yywrap ();
7399 int
7400 main ()
7401 {
7402 yywrap ();
7403  ;
7404  return 0;
7405 }
7406 _ACEOF
7407 rm -f conftest.$ac_objext conftest$ac_exeext
7408 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7409  (eval $ac_link) 2>conftest.er1
7410  ac_status=$?
7411  grep -v '^ *+' conftest.er1 >conftest.err
7412  rm -f conftest.er1
7413  cat conftest.err >&5
7414  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7415  (exit $ac_status); } &&
7416         { ac_try='test -z "$ac_c_werror_flag"
7417                         || test ! -s conftest.err'
12807    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12808    (eval $ac_try) 2>&5
12809    ac_status=$?
12810    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12811 <  (exit $ac_status); }; } &&
12812 <         { ac_try='test -s conftest$ac_exeext'
7424 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7425 <  (eval $ac_try) 2>&5
7426 <  ac_status=$?
7427 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7428 <  (exit $ac_status); }; }; then
7429 <  ac_cv_lib_l_yywrap=yes
12811 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12812 >  ac_cv_prog_gxx_2_95=yes
12813   else
12814 <  echo "$as_me: failed program was:" >&5
7432 < sed 's/^/| /' conftest.$ac_ext >&5
7433 <
7434 < ac_cv_lib_l_yywrap=no
12814 >  ac_cv_prog_gxx_2_95=no
12815   fi
7436 rm -f conftest.err conftest.$ac_objext \
7437      conftest$ac_exeext conftest.$ac_ext
7438 LIBS=$ac_check_lib_save_LIBS
7439 fi
7440 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
7441 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
7442 if test $ac_cv_lib_l_yywrap = yes; then
7443  LEXLIB="-ll"
7444 fi
12816  
12817   fi
12818 + echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12819 + echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12820 + if test "$ac_cv_prog_gxx_2_95" = yes; then
12821 +        :
12822  
7448 fi
12823  
12824 < if test "x$LEX" != "x:"; then
12825 <  echo "$as_me:$LINENO: checking lex output file root" >&5
12826 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
7453 < if test "${ac_cv_prog_lex_root+set}" = set; then
12824 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12825 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12826 > if test "${ac_m_cpu_750+set}" = set; then
12827    echo $ECHO_N "(cached) $ECHO_C" >&6
12828   else
12829 <  # The minimal lex program is just a single line: %%.  But some broken lexes
12830 < # (Solaris, I think it was) want two %% lines, so accommodate them.
12831 < cat >conftest.l <<_ACEOF
7459 < %%
7460 < %%
7461 < _ACEOF
7462 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
7463 <  (eval $LEX conftest.l) 2>&5
7464 <  ac_status=$?
7465 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7466 <  (exit $ac_status); }
7467 < if test -f lex.yy.c; then
7468 <  ac_cv_prog_lex_root=lex.yy
7469 < elif test -f lexyy.c; then
7470 <  ac_cv_prog_lex_root=lexyy
12829 >  echo 'void f(){}' > conftest.cpp
12830 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12831 >        ac_m_cpu_750=yes
12832   else
12833 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7473 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7474 <   { (exit 1); exit 1; }; }
12833 >        ac_m_cpu_750=no
12834   fi
12835 < fi
7477 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7478 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7479 < rm -f conftest.l
7480 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12835 > rm -f conftest*
12836  
12837 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
12838 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
12839 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
12840 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12837 > fi
12838 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12839 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12840 > if test "$ac_m_cpu_750" = yes; then
12841 >        :
12842 >        CPU_FLAGS=-mcpu=750
12843   else
12844 <  # POSIX says lex can declare yytext either as a pointer or an array; the
7488 < # default is implementation-dependent. Figure out which it is, since
7489 < # not all implementations provide the %pointer and %array declarations.
7490 < ac_cv_prog_lex_yytext_pointer=no
7491 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
7492 < ac_save_LIBS=$LIBS
7493 < LIBS="$LIBS $LEXLIB"
7494 < cat >conftest.$ac_ext <<_ACEOF
7495 < `cat $LEX_OUTPUT_ROOT.c`
7496 < _ACEOF
7497 < rm -f conftest.$ac_objext conftest$ac_exeext
7498 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7499 <  (eval $ac_link) 2>conftest.er1
7500 <  ac_status=$?
7501 <  grep -v '^ *+' conftest.er1 >conftest.err
7502 <  rm -f conftest.er1
7503 <  cat conftest.err >&5
7504 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7505 <  (exit $ac_status); } &&
7506 <         { ac_try='test -z "$ac_c_werror_flag"
7507 <                         || test ! -s conftest.err'
7508 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7509 <  (eval $ac_try) 2>&5
7510 <  ac_status=$?
7511 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7512 <  (exit $ac_status); }; } &&
7513 <         { ac_try='test -s conftest$ac_exeext'
7514 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7515 <  (eval $ac_try) 2>&5
7516 <  ac_status=$?
7517 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7518 <  (exit $ac_status); }; }; then
7519 <  ac_cv_prog_lex_yytext_pointer=yes
7520 < else
7521 <  echo "$as_me: failed program was:" >&5
7522 < sed 's/^/| /' conftest.$ac_ext >&5
12844 >        :
12845  
12846   fi
7525 rm -f conftest.err conftest.$ac_objext \
7526      conftest$ac_exeext conftest.$ac_ext
7527 LIBS=$ac_save_LIBS
7528 rm -f "${LEX_OUTPUT_ROOT}.c"
12847  
12848 < fi
12849 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
7532 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
7533 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12848 > else
12849 >        :
12850  
7535 cat >>confdefs.h <<\_ACEOF
7536 #define YYTEXT_POINTER 1
7537 _ACEOF
7538
12851   fi
12852  
12853 < fi
12853 >                fi
12854 >                if test -z "$CPU_FLAGS"; then
12855  
12856 <   # Extract the first word of "perl", so it can be a program name with args.
12857 < set dummy perl; ac_word=$2
12858 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12859 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7547 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
12856 >
12857 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12858 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12859 > if test "${ac_m_cpu_powerpc+set}" = set; then
12860    echo $ECHO_N "(cached) $ECHO_C" >&6
12861   else
12862 <  case $PERLINTERP in
12863 <  [\\/]* | ?:[\\/]*)
12864 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
12865 <  ;;
12866 <  *)
7555 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7556 < for as_dir in $PATH
7557 < do
7558 <  IFS=$as_save_IFS
7559 <  test -z "$as_dir" && as_dir=.
7560 <  for ac_exec_ext in '' $ac_executable_extensions; do
7561 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7562 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
7563 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7564 <    break 2
7565 <  fi
7566 < done
7567 < done
7568 <
7569 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
7570 <  ;;
7571 < esac
12862 >  echo 'void f(){}' > conftest.cpp
12863 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12864 >        ac_m_cpu_powerpc=yes
12865 > else
12866 >        ac_m_cpu_powerpc=no
12867   fi
12868 < PERLINTERP=$ac_cv_path_PERLINTERP
12868 > rm -f conftest*
12869  
12870 < if test -n "$PERLINTERP"; then
12871 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
12872 < echo "${ECHO_T}$PERLINTERP" >&6
12870 > fi
12871 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12872 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12873 > if test "$ac_m_cpu_powerpc" = yes; then
12874 >        :
12875 >        CPU_FLAGS=-mcpu=powerpc
12876   else
12877 <  echo "$as_me:$LINENO: result: no" >&5
12878 < echo "${ECHO_T}no" >&6
12877 >        :
12878 >
12879   fi
12880  
12881 <   ac_cv_path_perlinterp="$PERLINTERP"
12882 <   _sHpB='#!'
12881 >                fi
12882 >                if test -z "$CPU_FLAGS"; then
12883  
12884  
12885 < # Check whether --with-perl-shebang or --without-perl-shebang was given.
12886 < if test "${with_perl_shebang+set}" = set; then
12887 <  withval="$with_perl_shebang"
7590 <  opt_perl_shebang="$withval"
7591 < else
7592 <                opt_perl_shebang="not_set"
7593 < fi;
7594 <   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
7595 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
7596 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
12885 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12886 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12887 > if test "${ac_m_powerpc+set}" = set; then
12888    echo $ECHO_N "(cached) $ECHO_C" >&6
12889   else
12890 <   case "$opt_perl_shebang" in
12891 <                      not_set  ) ax_cv_opt_perl_shebang=''
12892 <                               ;;
12893 <                         *     )
12894 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
7604 <                    esac
7605 <
12890 >  echo 'void f(){}' > conftest.cpp
12891 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12892 >        ac_m_powerpc=yes
12893 > else
12894 >        ac_m_powerpc=no
12895   fi
12896 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
7608 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
7609 <   if test "A$ax_cv_opt_perl_shebang" != "A"
7610 <     then
7611 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
7612 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
7613 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
7614 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
12896 > rm -f conftest*
12897  
12898 < # Automatic detection of sharpbang formula starts here
12899 <     else
12900 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
12901 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
12902 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
12903 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
7622 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
7623 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12898 > fi
12899 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12900 > echo "${ECHO_T}$ac_m_powerpc" >&6
12901 > if test "$ac_m_powerpc" = yes; then
12902 >        :
12903 >        CPU_FLAGS=-mpowerpc
12904   else
12905 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
7626 <        if test "x$_somian_kspb_perl" == x
7627 <          then _somian_ksbp_warn_empty='durnit'
7628 <          else
7629 <          case "A$_somian_kspb_perl" in
7630 <                 A#!*perl* )
7631 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
7632 <                        ;;
7633 <                     A*    )  _somian_ksbp_warn_defau='trouble'
7634 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
7635 <          esac
7636 <        fi
12905 >        :
12906  
12907   fi
7639 echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
7640 echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
7641 # The above prints Checking ... result message to user.
7642   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
12908  
12909 <    if test A${_somian_ksbp_warn_empty+set} == Aset
12910 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
7646 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
7647 <    fi
7648 < # Inform user after printing result value
7649 <    if test A${_somian_ksbp_warn_defau+set} == Aset
7650 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
7651 < echo "$as_me: Maybe Not good -" >&6;}
7652 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
7653 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
7654 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
7655 < echo "$as_me: OK Good result - " >&6;}
7656 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
7657 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
7658 <    fi
12909 >                fi
12910 >          esac
12911    fi
12912  
12913 < # Extract the first word of "ar", so it can be a program name with args.
12914 < set dummy ar; ac_word=$2
7663 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7664 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7665 < if test "${ac_cv_prog_AR+set}" = set; then
7666 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7667 < else
7668 <  if test -n "$AR"; then
7669 <  ac_cv_prog_AR="$AR" # Let the user override the test.
7670 < else
7671 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7672 < for as_dir in $PATH
7673 < do
7674 <  IFS=$as_save_IFS
7675 <  test -z "$as_dir" && as_dir=.
7676 <  for ac_exec_ext in '' $ac_executable_extensions; do
7677 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7678 <    ac_cv_prog_AR="ar"
7679 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7680 <    break 2
12913 >  if test -n "$CPU_FLAGS"; then
12914 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12915    fi
7682 done
7683 done
12916  
12917 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12918 < fi
12919 < fi
12920 < AR=$ac_cv_prog_AR
12921 < if test -n "$AR"; then
12922 <  echo "$as_me:$LINENO: result: $AR" >&5
12923 < echo "${ECHO_T}$AR" >&6
12924 < else
12925 <  echo "$as_me:$LINENO: result: no" >&5
12926 < echo "${ECHO_T}no" >&6
7695 < fi
12917 >  if test -z "$CXXFLAGS"; then
12918 >        echo ""
12919 >        echo "**********************************************************"
12920 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12921 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12922 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12923 >        echo "**********************************************************"
12924 >        echo ""
12925 >        CXXFLAGS="-O3"
12926 >  fi
12927  
7697 if test "$AR" = "NONE"; then
7698  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
7699 echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7700   { (exit 1); exit 1; }; }
7701  cat >confcache <<\_ACEOF
7702 # This file is a shell script that caches the results of configure
7703 # tests run on this system so they can be shared between configure
7704 # scripts and configure runs, see configure's option --config-cache.
7705 # It is not useful on other systems.  If it contains results you don't
7706 # want to keep, you may remove or edit it.
7707 #
7708 # config.status only pays attention to the cache file if you give it
7709 # the --recheck option to rerun configure.
7710 #
7711 # `ac_cv_env_foo' variables (set or unset) will be overridden when
7712 # loading this file, other *unset* `ac_cv_foo' will be assigned the
7713 # following values.
12928  
7715 _ACEOF
12929  
12930 < # The following way of writing the cache mishandles newlines in values,
12931 < # but we know of no workaround that is simple, portable, and efficient.
12932 < # So, don't put newlines in cache variables' values.
7720 < # Ultrix sh set writes to stderr and can't be redirected directly,
7721 < # and sets the high bit in the cache file unless we assign to the vars.
7722 < {
7723 <  (set) 2>&1 |
7724 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
7725 <    *ac_space=\ *)
7726 <      # `set' does not quote correctly, so add quotes (double-quote
7727 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7728 <      sed -n \
7729 <        "s/'/'\\\\''/g;
7730 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7731 <      ;;
7732 <    *)
7733 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
7734 <      sed -n \
7735 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7736 <      ;;
7737 <    esac;
7738 < } |
7739 <  sed '
7740 <     t clear
7741 <     : clear
7742 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7743 <     t end
7744 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7745 <     : end' >>confcache
7746 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
7747 <  if test -w $cache_file; then
7748 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7749 <    cat confcache >$cache_file
7750 <  else
7751 <    echo "not updating unwritable cache $cache_file"
7752 <  fi
7753 < fi
7754 < rm -f confcache
7755 <  exit 1
7756 < fi
7757 <
7758 < # Extract the first word of "ps", so it can be a program name with args.
7759 < set dummy ps; ac_word=$2
7760 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7761 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7762 < if test "${ac_cv_path_PS+set}" = set; then
12930 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12931 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12932 > if test "${ac_guessed_cxxflags+set}" = set; then
12933    echo $ECHO_N "(cached) $ECHO_C" >&6
12934   else
12935 <  case $PS in
12936 <  [\\/]* | ?:[\\/]*)
12937 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
12938 <  ;;
12939 <  *)
7770 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7771 < for as_dir in $PATH
7772 < do
7773 <  IFS=$as_save_IFS
7774 <  test -z "$as_dir" && as_dir=.
7775 <  for ac_exec_ext in '' $ac_executable_extensions; do
7776 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7777 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7778 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7779 <    break 2
7780 <  fi
7781 < done
7782 < done
7783 <
7784 <  ;;
7785 < esac
12935 >  echo 'void f(){}' > conftest.cpp
12936 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12937 >        ac_guessed_cxxflags=yes
12938 > else
12939 >        ac_guessed_cxxflags=no
12940   fi
12941 < PS=$ac_cv_path_PS
12941 > rm -f conftest*
12942  
7789 if test -n "$PS"; then
7790  echo "$as_me:$LINENO: result: $PS" >&5
7791 echo "${ECHO_T}$PS" >&6
7792 else
7793  echo "$as_me:$LINENO: result: no" >&5
7794 echo "${ECHO_T}no" >&6
12943   fi
12944 + echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12945 + echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12946 + if test "$ac_guessed_cxxflags" = yes; then
12947 +        :
12948  
7797 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
7798 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
7799 if test "${ac_cv_prog_ps_syntax+set}" = set; then
7800  echo $ECHO_N "(cached) $ECHO_C" >&6
12949   else
12950 +        :
12951  
12952 <        if $PS ax -o rss > /dev/null 2>&1; then
12953 <                ac_cv_prog_ps_ax=yes
12954 <        else
12955 <                ac_cv_prog_ps_ax=no
12956 <        fi
12957 <        if $PS -ef -o rss > /dev/null 2>&1; then
12958 <                ac_cv_prog_ps_ef=yes
12959 <        else
7811 <                ac_cv_prog_ps_ef=no
7812 <        fi
7813 <        if test "$ac_cv_prog_ps_ax" = yes; then
7814 <                ac_cv_prog_ps_syntax=BSD
7815 <        else
7816 <                if test "$ac_cv_prog_ps_ef" = yes; then
7817 <                        ac_cv_prog_ps_syntax=POSIX
7818 <                else
7819 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7820 < echo "$as_me: error: Could not determine ps syntax" >&2;}
7821 <   { (exit 1); exit 1; }; }
7822 <                fi
7823 <        fi
12952 >        echo ""
12953 >        echo "**********************************************************"
12954 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12955 >        echo "* your compiler.                                         *"
12956 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12957 >        echo "**********************************************************"
12958 >        echo ""
12959 >        CXXFLAGS=""
12960  
12961   fi
7826 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7827 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
12962  
12963  
12964 < cat >>confdefs.h <<_ACEOF
7831 < #define PSCOMMAND $PS
7832 < _ACEOF
12964 > fi
12965  
12966 +     ;;
12967 + esac
12968  
7835 if test "$ac_cv_prog_ps_syntax" = BSD; then
7836  cat >>confdefs.h <<\_ACEOF
7837 #define PSTYPE_IS_BSD 1
7838 _ACEOF
12969  
12970 < else
12971 <   if test "$ac_cv_prog_ps_syntax" = POSIX; then
7842 <       cat >>confdefs.h <<\_ACEOF
7843 < #define PSTYPE_IS_POSIX 1
12970 > cat >>confdefs.h <<\_ACEOF
12971 > #define OBAPI
12972   _ACEOF
12973  
7846   else
7847       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
7848 echo "$as_me: error: Unknown ps syntax type!" >&2;}
7849   { (exit 1); exit 1; }; }
7850   fi
7851 fi
12974  
12975  
12976 +
12977   # Check whether --with-mpi or --without-mpi was given.
12978   if test "${with_mpi+set}" = set; then
12979    withval="$with_mpi"
# Line 7904 | Line 13027 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13027  
13028   echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13029   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13030 +
13031 +
13032 + ac_ext=${FC_SRCEXT-f}
13033 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13034 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13035 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13036 +
13037 + ac_save_ext=$ac_ext
13038 + ac_ext=F90
13039 + ac_save_FCFLAGS=$FCFLAGS
13040   have_mpif_h=0
13041   rm -f conftest*
13042 < cat >conftest.f90 <<EOF
13042 > cat >conftest.$ac_ext <<EOF
13043   program main
13044     include 'mpif.h'
13045   end
13046   EOF
13047 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13047 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13048          echo "$as_me:$LINENO: result: yes" >&5
13049   echo "${ECHO_T}yes" >&6
13050          MPI_F90_INC="$MPI_INC_DIR"
# Line 7933 | Line 13066 | fi
13066   _ACEOF
13067  
13068   fi
13069 + FCFLAGS=$ac_save_FCFLAGS
13070 + ac_ext=$ac_save_ext
13071 + ac_ext=cc
13072 + ac_cpp='$CXXCPP $CPPFLAGS'
13073 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13074 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13075 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13076  
13077 +
13078   ac_ext=c
13079   ac_cpp='$CPP $CPPFLAGS'
13080   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7941 | Line 13082 | ac_save_LDFLAGS=$LDFLAGS
13082   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13083  
13084   ac_save_LDFLAGS=$LDFLAGS
13085 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13085 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13086  
13087   if test x = x"$MPI_LIB"; then
13088          echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
# Line 7965 | Line 13106 | char MPI_Init ();
13106   /* We use char because int might match the return type of a gcc2
13107     builtin and then its argument prototype would still apply.  */
13108   char MPI_Init ();
13109 + #ifdef FC_DUMMY_MAIN
13110 + #ifndef FC_DUMMY_MAIN_EQ_F77
13111 + #  ifdef __cplusplus
13112 +     extern "C"
13113 + #  endif
13114 +   int FC_DUMMY_MAIN() { return 1; }
13115 + #endif
13116 + #endif
13117   int
13118   main ()
13119   {
# Line 8013 | Line 13162 | fi
13162   fi
13163  
13164   fi
13165 + $as_unset ac_cv_lib_mpich_MPI_Init
13166   if test x = x"$MPI_LIB"; then
13167 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13168 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13169 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13167 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13168 > echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13169 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13170    echo $ECHO_N "(cached) $ECHO_C" >&6
13171   else
13172    ac_check_lib_save_LIBS=$LIBS
13173 < LIBS="-lmpi  $LIBS"
13173 > LIBS="-lmpich "-lpmpich" $LIBS"
13174   cat >conftest.$ac_ext <<_ACEOF
13175   /* confdefs.h.  */
13176   _ACEOF
# Line 8035 | Line 13185 | char MPI_Init ();
13185   /* We use char because int might match the return type of a gcc2
13186     builtin and then its argument prototype would still apply.  */
13187   char MPI_Init ();
13188 + #ifdef FC_DUMMY_MAIN
13189 + #ifndef FC_DUMMY_MAIN_EQ_F77
13190 + #  ifdef __cplusplus
13191 +     extern "C"
13192 + #  endif
13193 +   int FC_DUMMY_MAIN() { return 1; }
13194 + #endif
13195 + #endif
13196   int
13197   main ()
13198   {
# Line 8065 | Line 13223 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13223    ac_status=$?
13224    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13225    (exit $ac_status); }; }; then
13226 <  ac_cv_lib_mpi_MPI_Init=yes
13226 >  ac_cv_lib_mpich_MPI_Init=yes
13227   else
13228    echo "$as_me: failed program was:" >&5
13229   sed 's/^/| /' conftest.$ac_ext >&5
13230  
13231 < ac_cv_lib_mpi_MPI_Init=no
13231 > ac_cv_lib_mpich_MPI_Init=no
13232   fi
13233   rm -f conftest.err conftest.$ac_objext \
13234        conftest$ac_exeext conftest.$ac_ext
13235   LIBS=$ac_check_lib_save_LIBS
13236   fi
13237 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13238 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13239 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13240 <  MPI_LIB="-lmpi"
13237 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13238 > echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13239 > if test $ac_cv_lib_mpich_MPI_Init = yes; then
13240 >  MPI_LIB="-lpmpich -lmpich"
13241   fi
13242  
13243   fi
8086 $as_unset ac_cv_lib_mpi_MPI_Init
13244   if test x = x"$MPI_LIB"; then
13245          echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13246   echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
# Line 8091 | Line 13248 | else
13248    echo $ECHO_N "(cached) $ECHO_C" >&6
13249   else
13250    ac_check_lib_save_LIBS=$LIBS
13251 < LIBS="-lmpi "-llam" $LIBS"
13251 > LIBS="-lmpi  $LIBS"
13252   cat >conftest.$ac_ext <<_ACEOF
13253   /* confdefs.h.  */
13254   _ACEOF
# Line 8106 | Line 13263 | char MPI_Init ();
13263   /* We use char because int might match the return type of a gcc2
13264     builtin and then its argument prototype would still apply.  */
13265   char MPI_Init ();
13266 + #ifdef FC_DUMMY_MAIN
13267 + #ifndef FC_DUMMY_MAIN_EQ_F77
13268 + #  ifdef __cplusplus
13269 +     extern "C"
13270 + #  endif
13271 +   int FC_DUMMY_MAIN() { return 1; }
13272 + #endif
13273 + #endif
13274   int
13275   main ()
13276   {
# Line 8150 | Line 13315 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13315   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13316   echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13317   if test $ac_cv_lib_mpi_MPI_Init = yes; then
13318 <  MPI_LIB="-lmpi -llam"
13318 >  MPI_LIB="-lmpi"
13319   fi
13320  
13321   fi
13322 < $as_unset ac_cv_lib_mpich_MPI_Init
13322 > $as_unset ac_cv_lib_mpi_MPI_Init
13323   if test x = x"$MPI_LIB"; then
13324 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13325 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13326 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13324 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13325 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13326 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13327    echo $ECHO_N "(cached) $ECHO_C" >&6
13328   else
13329    ac_check_lib_save_LIBS=$LIBS
13330 < LIBS="-lmpich "-lpmpich" $LIBS"
13330 > LIBS="-lmpi "-llam" $LIBS"
13331   cat >conftest.$ac_ext <<_ACEOF
13332   /* confdefs.h.  */
13333   _ACEOF
# Line 8177 | Line 13342 | char MPI_Init ();
13342   /* We use char because int might match the return type of a gcc2
13343     builtin and then its argument prototype would still apply.  */
13344   char MPI_Init ();
13345 + #ifdef FC_DUMMY_MAIN
13346 + #ifndef FC_DUMMY_MAIN_EQ_F77
13347 + #  ifdef __cplusplus
13348 +     extern "C"
13349 + #  endif
13350 +   int FC_DUMMY_MAIN() { return 1; }
13351 + #endif
13352 + #endif
13353   int
13354   main ()
13355   {
# Line 8207 | Line 13380 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13380    ac_status=$?
13381    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13382    (exit $ac_status); }; }; then
13383 <  ac_cv_lib_mpich_MPI_Init=yes
13383 >  ac_cv_lib_mpi_MPI_Init=yes
13384   else
13385    echo "$as_me: failed program was:" >&5
13386   sed 's/^/| /' conftest.$ac_ext >&5
13387  
13388 < ac_cv_lib_mpich_MPI_Init=no
13388 > ac_cv_lib_mpi_MPI_Init=no
13389   fi
13390   rm -f conftest.err conftest.$ac_objext \
13391        conftest$ac_exeext conftest.$ac_ext
13392   LIBS=$ac_check_lib_save_LIBS
13393   fi
13394 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13395 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13396 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13397 <  MPI_LIB="-lmpich -lpmpich"
13394 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13395 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13396 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13397 >  MPI_LIB="-lmpi -llam"
13398   fi
13399  
13400   fi
8228
13401   $as_unset ac_cv_lib_mpi_MPI_Init
13402   if test x = x"$MPI_LIB"; then
13403   echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
# Line 8249 | Line 13421 | char MPI_Init ();
13421   /* We use char because int might match the return type of a gcc2
13422     builtin and then its argument prototype would still apply.  */
13423   char MPI_Init ();
13424 + #ifdef FC_DUMMY_MAIN
13425 + #ifndef FC_DUMMY_MAIN_EQ_F77
13426 + #  ifdef __cplusplus
13427 +     extern "C"
13428 + #  endif
13429 +   int FC_DUMMY_MAIN() { return 1; }
13430 + #endif
13431 + #endif
13432   int
13433   main ()
13434   {
# Line 8325 | Line 13505 | fi
13505  
13506  
13507  
8328
13508   USE_CGAL=no
13509   cgal_makefile=auto
13510  
# Line 8431 | Line 13610 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13610  
13611      save_CXXFLAGS="$CXXFLAGS"
13612      CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13613 <
8435 < ac_ext=cc
8436 < ac_cpp='$CXXCPP $CPPFLAGS'
8437 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8438 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8439 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8440 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
8441 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
8442 < if test -z "$CXXCPP"; then
8443 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
8444 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8445 < else
8446 <      # Double quotes because CXXCPP needs to be expanded
8447 <    for CXXCPP in "$CXX -E" "/lib/cpp"
8448 <    do
8449 <      ac_preproc_ok=false
8450 < for ac_cxx_preproc_warn_flag in '' yes
8451 < do
8452 <  # Use a header file that comes with gcc, so configuring glibc
8453 <  # with a fresh cross-compiler works.
8454 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8455 <  # <limits.h> exists even on freestanding compilers.
8456 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8457 <  # not just through cpp. "Syntax error" is here to catch this case.
8458 <  cat >conftest.$ac_ext <<_ACEOF
8459 < /* confdefs.h.  */
8460 < _ACEOF
8461 < cat confdefs.h >>conftest.$ac_ext
8462 < cat >>conftest.$ac_ext <<_ACEOF
8463 < /* end confdefs.h.  */
8464 < #ifdef __STDC__
8465 < # include <limits.h>
8466 < #else
8467 < # include <assert.h>
8468 < #endif
8469 <                     Syntax error
8470 < _ACEOF
8471 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8472 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8473 <  ac_status=$?
8474 <  grep -v '^ *+' conftest.er1 >conftest.err
8475 <  rm -f conftest.er1
8476 <  cat conftest.err >&5
8477 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8478 <  (exit $ac_status); } >/dev/null; then
8479 <  if test -s conftest.err; then
8480 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8481 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8482 <  else
8483 <    ac_cpp_err=
8484 <  fi
8485 < else
8486 <  ac_cpp_err=yes
8487 < fi
8488 < if test -z "$ac_cpp_err"; then
8489 <  :
8490 < else
8491 <  echo "$as_me: failed program was:" >&5
8492 < sed 's/^/| /' conftest.$ac_ext >&5
8493 <
8494 <  # Broken: fails on valid input.
8495 < continue
8496 < fi
8497 < rm -f conftest.err conftest.$ac_ext
8498 <
8499 <  # OK, works on sane cases.  Now check whether non-existent headers
8500 <  # can be detected and how.
8501 <  cat >conftest.$ac_ext <<_ACEOF
8502 < /* confdefs.h.  */
8503 < _ACEOF
8504 < cat confdefs.h >>conftest.$ac_ext
8505 < cat >>conftest.$ac_ext <<_ACEOF
8506 < /* end confdefs.h.  */
8507 < #include <ac_nonexistent.h>
8508 < _ACEOF
8509 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8510 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8511 <  ac_status=$?
8512 <  grep -v '^ *+' conftest.er1 >conftest.err
8513 <  rm -f conftest.er1
8514 <  cat conftest.err >&5
8515 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8516 <  (exit $ac_status); } >/dev/null; then
8517 <  if test -s conftest.err; then
8518 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8519 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8520 <  else
8521 <    ac_cpp_err=
8522 <  fi
8523 < else
8524 <  ac_cpp_err=yes
8525 < fi
8526 < if test -z "$ac_cpp_err"; then
8527 <  # Broken: success on invalid input.
8528 < continue
8529 < else
8530 <  echo "$as_me: failed program was:" >&5
8531 < sed 's/^/| /' conftest.$ac_ext >&5
8532 <
8533 <  # Passes both tests.
8534 < ac_preproc_ok=:
8535 < break
8536 < fi
8537 < rm -f conftest.err conftest.$ac_ext
8538 <
8539 < done
8540 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8541 < rm -f conftest.err conftest.$ac_ext
8542 < if $ac_preproc_ok; then
8543 <  break
8544 < fi
8545 <
8546 <    done
8547 <    ac_cv_prog_CXXCPP=$CXXCPP
8548 <
8549 < fi
8550 <  CXXCPP=$ac_cv_prog_CXXCPP
8551 < else
8552 <  ac_cv_prog_CXXCPP=$CXXCPP
8553 < fi
8554 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
8555 < echo "${ECHO_T}$CXXCPP" >&6
8556 < ac_preproc_ok=false
8557 < for ac_cxx_preproc_warn_flag in '' yes
8558 < do
8559 <  # Use a header file that comes with gcc, so configuring glibc
8560 <  # with a fresh cross-compiler works.
8561 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8562 <  # <limits.h> exists even on freestanding compilers.
8563 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8564 <  # not just through cpp. "Syntax error" is here to catch this case.
8565 <  cat >conftest.$ac_ext <<_ACEOF
8566 < /* confdefs.h.  */
8567 < _ACEOF
8568 < cat confdefs.h >>conftest.$ac_ext
8569 < cat >>conftest.$ac_ext <<_ACEOF
8570 < /* end confdefs.h.  */
8571 < #ifdef __STDC__
8572 < # include <limits.h>
8573 < #else
8574 < # include <assert.h>
8575 < #endif
8576 <                     Syntax error
8577 < _ACEOF
8578 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8579 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8580 <  ac_status=$?
8581 <  grep -v '^ *+' conftest.er1 >conftest.err
8582 <  rm -f conftest.er1
8583 <  cat conftest.err >&5
8584 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8585 <  (exit $ac_status); } >/dev/null; then
8586 <  if test -s conftest.err; then
8587 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8588 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8589 <  else
8590 <    ac_cpp_err=
8591 <  fi
8592 < else
8593 <  ac_cpp_err=yes
8594 < fi
8595 < if test -z "$ac_cpp_err"; then
8596 <  :
8597 < else
8598 <  echo "$as_me: failed program was:" >&5
8599 < sed 's/^/| /' conftest.$ac_ext >&5
8600 <
8601 <  # Broken: fails on valid input.
8602 < continue
8603 < fi
8604 < rm -f conftest.err conftest.$ac_ext
8605 <
8606 <  # OK, works on sane cases.  Now check whether non-existent headers
8607 <  # can be detected and how.
8608 <  cat >conftest.$ac_ext <<_ACEOF
8609 < /* confdefs.h.  */
8610 < _ACEOF
8611 < cat confdefs.h >>conftest.$ac_ext
8612 < cat >>conftest.$ac_ext <<_ACEOF
8613 < /* end confdefs.h.  */
8614 < #include <ac_nonexistent.h>
8615 < _ACEOF
8616 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8617 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8618 <  ac_status=$?
8619 <  grep -v '^ *+' conftest.er1 >conftest.err
8620 <  rm -f conftest.er1
8621 <  cat conftest.err >&5
8622 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8623 <  (exit $ac_status); } >/dev/null; then
8624 <  if test -s conftest.err; then
8625 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8626 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8627 <  else
8628 <    ac_cpp_err=
8629 <  fi
8630 < else
8631 <  ac_cpp_err=yes
8632 < fi
8633 < if test -z "$ac_cpp_err"; then
8634 <  # Broken: success on invalid input.
8635 < continue
8636 < else
8637 <  echo "$as_me: failed program was:" >&5
8638 < sed 's/^/| /' conftest.$ac_ext >&5
8639 <
8640 <  # Passes both tests.
8641 < ac_preproc_ok=:
8642 < break
8643 < fi
8644 < rm -f conftest.err conftest.$ac_ext
8645 <
8646 < done
8647 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8648 < rm -f conftest.err conftest.$ac_ext
8649 < if $ac_preproc_ok; then
8650 <  :
8651 < else
8652 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8653 < See \`config.log' for more details." >&5
8654 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8655 < See \`config.log' for more details." >&2;}
8656 <   { (exit 1); exit 1; }; }
8657 < fi
8658 <
8659 < ac_ext=cc
8660 < ac_cpp='$CXXCPP $CPPFLAGS'
8661 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8662 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8663 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8664 <
8665 <
8666 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13613 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13614    echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13615   echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13616   if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
# Line 8899 | Line 13846 | cat >>conftest.$ac_ext <<_ACEOF
13846   cat >>conftest.$ac_ext <<_ACEOF
13847   /* end confdefs.h.  */
13848   #include <CGAL/Cartesian.h>
13849 + #ifdef FC_DUMMY_MAIN
13850 + #ifndef FC_DUMMY_MAIN_EQ_F77
13851 + #  ifdef __cplusplus
13852 +     extern "C"
13853 + #  endif
13854 +   int FC_DUMMY_MAIN() { return 1; }
13855 + #endif
13856 + #endif
13857   int
13858   main ()
13859   {
# Line 9004 | Line 13959 | CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13959  
13960  
13961  
9007
13962   # Check whether --enable-doxygen or --disable-doxygen was given.
13963   if test "${enable_doxygen+set}" = set; then
13964    enableval="$enable_doxygen"
# Line 9146 | Line 14100 | fi
14100  
14101  
14102  
9149 OBJEXT=".$OBJEXT"
14103  
9151 OOPSE=oopse
14104  
9153 if test "x${prefix}" = "xNONE"
9154 then
9155  OOPSE_HOME=${ac_default_prefix}/oopse
9156 else
9157  OOPSE_HOME=${prefix}/oopse
9158 fi
9159 # Check whether --enable-oopse-home or --disable-oopse-home was given.
9160 if test "${enable_oopse_home+set}" = set; then
9161  enableval="$enable_oopse_home"
9162  OOPSE_HOME="${enableval}"
9163 fi;
14105  
9165 case "x$INSTALL" in
9166   x/*) ;;
9167   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
9168 esac
14106  
9170 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14107  
9172 CFLAGS=${CFLAGS-""}
9173 CXXFLAGS=${CXXFLAGS-""}
9174 CPPFLAGS=${CPPFLAGS-""}
9175 FFLAGS=${FFLAGS-""}
9176 F90FLAGS=${F90FLAGS-""}
9177 LDFLAGS=${LDFLAGS-""}
9178 DEBUG=${DEBUG-"-g"}
14108  
9180 case $debug in
9181  1)
9182     FFLAGS="$DEBUG $FFLAGS"
9183     F90FLAGS="$DEBUG $F90FLAGS"
9184     ;;
9185  *)
9186     ;;
9187 esac
14109  
14110  
14111  
14112  
14113  
14114  
9194
9195
9196
9197
9198
9199
9200
9201
9202
9203
9204
9205
9206          ac_config_headers="$ac_config_headers src/config.h"
9207
14115                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14116  
14117  
# Line 9570 | Line 14477 | cat >&5 <<_CSEOF
14477   } >&5
14478   cat >&5 <<_CSEOF
14479  
14480 < This file was extended by OOPSE $as_me 2.0, which was
14480 > This file was extended by OOPSE $as_me 3.0, which was
14481   generated by GNU Autoconf 2.59.  Invocation command line was
14482  
14483    CONFIG_FILES    = $CONFIG_FILES
# Line 9633 | Line 14540 | ac_cs_version="\\
14540  
14541   cat >>$CONFIG_STATUS <<_ACEOF
14542   ac_cs_version="\\
14543 < OOPSE config.status 2.0
14543 > OOPSE config.status 3.0
14544   configured by $0, generated by GNU Autoconf 2.59,
14545    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14546  
# Line 9827 | Line 14734 | s,@LIBS@,$LIBS,;t t
14734   s,@ECHO_N@,$ECHO_N,;t t
14735   s,@ECHO_T@,$ECHO_T,;t t
14736   s,@LIBS@,$LIBS,;t t
9830 s,@PROGNAME@,$PROGNAME,;t t
9831 s,@debug@,$debug,;t t
14737   s,@build@,$build,;t t
14738   s,@build_cpu@,$build_cpu,;t t
14739   s,@build_vendor@,$build_vendor,;t t
# Line 9837 | Line 14742 | s,@host_os@,$host_os,;t t
14742   s,@host_cpu@,$host_cpu,;t t
14743   s,@host_vendor@,$host_vendor,;t t
14744   s,@host_os@,$host_os,;t t
14745 < s,@CC@,$CC,;t t
14746 < s,@CFLAGS@,$CFLAGS,;t t
14745 > s,@PROGNAME@,$PROGNAME,;t t
14746 > s,@debug@,$debug,;t t
14747 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
14748 > s,@CXX@,$CXX,;t t
14749 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14750   s,@LDFLAGS@,$LDFLAGS,;t t
14751   s,@CPPFLAGS@,$CPPFLAGS,;t t
14752 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14752 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14753   s,@EXEEXT@,$EXEEXT,;t t
14754   s,@OBJEXT@,$OBJEXT,;t t
14755 < s,@CXX@,$CXX,;t t
14756 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14757 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14758 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14759 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14760 < s,@F90@,$F90,;t t
9853 < s,@F90FLAGS@,$F90FLAGS,;t t
9854 < s,@ac_ct_F90@,$ac_ct_F90,;t t
9855 < s,@PREPFLAG@,$PREPFLAG,;t t
9856 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
9857 < s,@F90LIBS@,$F90LIBS,;t t
9858 < s,@F90_FUNC@,$F90_FUNC,;t t
9859 < s,@F90_FUNC_@,$F90_FUNC_,;t t
9860 < s,@MOD@,$MOD,;t t
9861 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
9862 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
9863 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
9864 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14755 > s,@CC@,$CC,;t t
14756 > s,@CFLAGS@,$CFLAGS,;t t
14757 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14758 > s,@FC@,$FC,;t t
14759 > s,@FCFLAGS@,$FCFLAGS,;t t
14760 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14761   s,@CPP@,$CPP,;t t
14762   s,@EGREP@,$EGREP,;t t
9867 s,@LIBOBJS@,$LIBOBJS,;t t
9868 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
9869 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
9870 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14763   s,@LN_S@,$LN_S,;t t
14764   s,@SET_MAKE@,$SET_MAKE,;t t
14765   s,@RANLIB@,$RANLIB,;t t
14766   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
9875 s,@YACC@,$YACC,;t t
9876 s,@LEX@,$LEX,;t t
9877 s,@LEXLIB@,$LEXLIB,;t t
9878 s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14767   s,@PERLINTERP@,$PERLINTERP,;t t
14768   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14769 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14770 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14771 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14772   s,@AR@,$AR,;t t
14773   s,@PS@,$PS,;t t
14774 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14775 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14776 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14777 + s,@FCLIBS@,$FCLIBS,;t t
14778 + s,@FC_FUNC@,$FC_FUNC,;t t
14779 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14780 + s,@MOD@,$MOD,;t t
14781 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14782 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14783 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14784 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14785 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14786 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14787 + s,@ZLIB@,$ZLIB,;t t
14788 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14789 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14790 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14791 + s,@LIBOBJS@,$LIBOBJS,;t t
14792 + s,@POW_LIB@,$POW_LIB,;t t
14793 + s,@CXXCPP@,$CXXCPP,;t t
14794 + s,@__func__@,$__func__,;t t
14795   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14796   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14797   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14798   s,@MPI_LIB@,$MPI_LIB,;t t
14799   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14800   s,@USE_MPI@,$USE_MPI,;t t
9889 s,@CXXCPP@,$CXXCPP,;t t
14801   s,@USE_CGAL@,$USE_CGAL,;t t
14802   s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14803   s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
# Line 9905 | Line 14816 | s,@SUBDIRS@,$SUBDIRS,;t t
14816   s,@OOPSE@,$OOPSE,;t t
14817   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14818   s,@SUBDIRS@,$SUBDIRS,;t t
9908 s,@FFLAGS@,$FFLAGS,;t t
14819   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14820   CEOF
14821  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines