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

Comparing trunk/OOPSE-3.0/configure (file contents):
Revision 1509 by gezelter, Wed Sep 29 17:57:47 2004 UTC vs.
Revision 2753 by gezelter, Tue May 16 20:38:23 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_VERSION='2.0'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX 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 CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI SPRNG_LIB_DIR SPRNG_INC_DIR SPRNG_LIB USE_SPRNG MKL_LIBDIR MKL_LIB MKL_INC HAVE_MKL BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
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_env_F90_set=${F90+set}
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_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}
791   ac_cv_env_CPP_value=$CPP
792 + ac_env_CXXCPP_set=${CXXCPP+set}
793 + ac_env_CXXCPP_value=$CXXCPP
794 + ac_cv_env_CXXCPP_set=${CXXCPP+set}
795 + ac_cv_env_CXXCPP_value=$CXXCPP
796  
797   #
798   # Report the --help message.
# Line 797 | 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 858 | 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]
868  --enable-debug          Compile OOPSE in debug mode
872    --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873 +  --enable-debug          Compile OOPSE in debug mode
874 +  --enable-doxygen        enable documentation generation with doxygen (auto)
875 +  --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876 +  --enable-html-docs      enable HTML generation with doxygen (yes)
877 +  --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884 +  --with-zlib=DIR root directory path of zlib installation defaults to
885 +                    /usr/local or /usr if not found in /usr/local
886 +  --without-zlib to disable zlib usage completely
887 +  --with-fftw=DIR         root directory path of fftw installation (defaults
888 +                          to /usr/local or /usr if not found in /usr/local)
889    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
890 <  --with-sprng=<prefix>   compile with SPRNG installed in <prefix>
876 <                          [default=/usr/local]
877 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
890 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
891  
892   Some influential environment variables:
893 <  CC          C compiler command
894 <  CFLAGS      C compiler flags
893 >  CXX         C++ compiler command
894 >  CXXFLAGS    C++ compiler flags
895    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
896                nonstandard directory <lib dir>
897    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
898                headers in a nonstandard directory <include dir>
899 <  CXX         C++ compiler command
900 <  CXXFLAGS    C++ compiler flags
901 <  F90         Fortran 90 compiler command
902 <  F90FLAGS    Fortran 90 compiler flags
899 >  CC          C compiler command
900 >  CFLAGS      C compiler flags
901 >  FC          Fortran compiler command
902 >  FCFLAGS     Fortran compiler flags
903    CPP         C preprocessor
904 +  CXXCPP      C++ preprocessor
905  
906   Use these variables to override the choices made by `configure' or to help
907   it to find libraries and programs with nonstandard names/locations.
# Line 988 | Line 1002 | OOPSE configure 2.0
1002   test -n "$ac_init_help" && exit 0
1003   if $ac_init_version; then
1004    cat <<\_ACEOF
1005 < OOPSE configure 2.0
1005 > OOPSE configure 3.0
1006   generated by GNU Autoconf 2.59
1007  
1008   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1002 | Line 1016 | It was created by OOPSE $as_me 2.0, which was
1016   This file contains any messages produced by compilers while
1017   running configure, to aid debugging if configure makes a mistake.
1018  
1019 < It was created by OOPSE $as_me 2.0, which was
1019 > It was created by OOPSE $as_me 3.0, which was
1020   generated by GNU Autoconf 2.59.  Invocation command line was
1021  
1022    $ $0 $@
# Line 1362 | Line 1376 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1376   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1377   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1378   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1365
1366
1367 # This file is part of Autoconf.                       -*- Autoconf -*-
1368 # Programming languages support.
1369 # Copyright 2000, 2001
1370 # Free Software Foundation, Inc.
1371 #
1372 # This program is free software; you can redistribute it and/or modify
1373 # it under the terms of the GNU General Public License as published by
1374 # the Free Software Foundation; either version 2, or (at your option)
1375 # any later version.
1376 #
1377 # This program is distributed in the hope that it will be useful,
1378 # but WITHOUT ANY WARRANTY; without even the implied warranty of
1379 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1380 # GNU General Public License for more details.
1381 #
1382 # You should have received a copy of the GNU General Public License
1383 # along with this program; if not, write to the Free Software
1384 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1385 # 02111-1307, USA.
1386 #
1387 # As a special exception, the Free Software Foundation gives unlimited
1388 # permission to copy, distribute and modify the configure scripts that
1389 # are the output of Autoconf.  You need not follow the terms of the GNU
1390 # General Public License when using or distributing such scripts, even
1391 # though portions of the text of Autoconf appear in them.  The GNU
1392 # General Public License (GPL) does govern all other use of the material
1393 # that constitutes the Autoconf program.
1394 #
1395 # Certain portions of the Autoconf source text are designed to be copied
1396 # (in certain cases, depending on the input) into the output of
1397 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1398 # source text consists of comments plus executable code that decides which
1399 # of the data portions to output in any given case.  We call these
1400 # comments and executable code the "non-data" portions.  Autoconf never
1401 # copies any of the non-data portions into its output.
1402 #
1403 # This special exception to the GPL applies to versions of Autoconf
1404 # released by the Free Software Foundation.  When you make and
1405 # distribute a modified version of Autoconf, you may extend this special
1406 # exception to the GPL to apply to your modified version as well, *unless*
1407 # your modified version has the potential to copy into its output some
1408 # of the text that was the non-data portion of the version that you started
1409 # with.  (In other words, unless your change moves or copies text from
1410 # the non-data portions to the data portions.)  If your modification has
1411 # such potential, you must delete any notice of this special exception
1412 # to the GPL from your modified version.
1413 #
1414 # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1415 # many others).
1379  
1380  
1381 < # Table of Contents:
1419 < #
1420 < # 1. Language selection
1421 < #    and routines to produce programs in a given language.
1422 < #  a. Fortran 77 (to be moved from aclang.m4)
1423 < #  b. Fortran 90
1424 < #  c. Fortran 95
1425 < #
1426 < # 2. Producing programs in a given language.
1427 < #  a. Fortran 77 (to be moved from aclang.m4)
1428 < #  b. Fortran 90
1429 < #  c. Fortran 95
1430 < #
1431 < # 3. Looking for a compiler
1432 < #    And possibly the associated preprocessor.
1433 < #  a. Fortran 77 (to be moved from aclang.m4)
1434 < #  b. Fortran 90
1435 < #  c. Fortran 95
1436 < #
1437 < # 4. Compilers' characteristics.
1438 < #  a. Fortran 77 (to be moved from aclang.m4)
1439 < #  b. Fortran 90
1440 < #  c. Fortran 95
1381 >          ac_config_headers="$ac_config_headers src/config.h"
1382  
1442 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1443 # ---------------------------------------------------------------------------
1444 #
1445 # Processing the elements of a list is tedious in shell programming,
1446 # as lists tend to be implemented as space delimited strings.
1447 #
1448 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1449 # if ELEMENT is a member of LIST, otherwise it executes
1450 # ACTION-IF-NOT-FOUND.
1451 # _AC_LIST_MEMBER_IF
1383  
1384  
1385  
1455 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1456 # -------------------------------------------------
1457 #
1458 # Specifying options to the compiler (whether it be the C, C++ or
1459 # Fortran 77 compiler) that are meant for the linker is compiler
1460 # dependent.  This macro lets you give options to the compiler that
1461 # are meant for the linker in a portable, compiler-independent way.
1462 #
1463 # This macro take two arguments, a list of linker options that the
1464 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1465 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1466 # appended to the shell variable in a compiler-dependent way.
1467 #
1468 # For example, if the selected language is C, then this:
1469 #
1470 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1471 #
1472 # will expand into this if the selected C compiler is gcc:
1473 #
1474 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1475 #
1476 # otherwise, it will expand into this:
1477 #
1478 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1479 #
1480 # You are encouraged to add support for compilers that this macro
1481 # doesn't currently support.
1482 # FIXME: Get rid of this macro.
1483 # _AC_LINKER_OPTION
1386  
1387  
1388  
1487 ## ----------------------- ##
1488 ## 1. Language selection.  ##
1489 ## ----------------------- ##
1389  
1491 # ----------------------------- #
1492 # 1b. The Fortran 90 language.  #
1493 # ----------------------------- #
1390  
1495 # AC_LANG(Fortran 90)
1496 # -------------------
1391  
1392  
1393  
1500 # _AC_LANG_ABBREV(Fortran 90)
1501 # ---------------------------
1394  
1395  
1396  
1505 # ----------------------------- #
1506 # 1c. The Fortran 95 language.  #
1507 # ----------------------------- #
1397  
1509 # AC_LANG(Fortran 95)
1510 # -------------------
1398  
1399  
1400  
1514 # _AC_LANG_ABBREV(Fortran 95)
1515 # ---------------------------
1401  
1402  
1403  
1519 ## ---------------------- ##
1520 ## 2.Producing programs.  ##
1521 ## ---------------------- ##
1404  
1523 # ------------------------ #
1524 # 2b. Fortran 90 sources.  #
1525 # ------------------------ #
1405  
1527 # AC_LANG_SOURCE(Fortran 90)(BODY)
1528 # --------------------------------
1406  
1407  
1408  
1532 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1533 # -----------------------------------------------
1409  
1410  
1536 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1537 # --------------------------------------------
1411  
1412  
1413  
1541 # ------------------------ #
1542 # 2c. Fortran 95 sources.  #
1543 # ------------------------ #
1414  
1545 # AC_LANG_SOURCE(Fortran 95)(BODY)
1546 # --------------------------------
1415  
1416  
1549 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1550 # -----------------------------------------------
1551
1552
1553 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1554 # --------------------------------------------
1555
1556
1557
1558 ## -------------------------------------------- ##
1559 ## 3. Looking for Compilers and Preprocessors.  ##
1560 ## -------------------------------------------- ##
1417  
1562 # ----------------------------- #
1563 # 3b. The Fortran 90 compiler.  #
1564 # ----------------------------- #
1418  
1419  
1567 # AC_LANG_PREPROC(Fortran 90)
1568 # ---------------------------
1569 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1420  
1421  
1422  
1573 # AC_LANG_COMPILER(Fortran 90)
1574 # ----------------------------
1575 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1576 # AC_REQUIRE'able.
1423  
1424  
1425  
1580 # AC_PROG_F90([COMPILERS...])
1581 # ---------------------------
1582 # COMPILERS is a space separated list of Fortran 90 compilers to search
1583 # for.
1426   #
1585 # Compilers are ordered by
1586 #  1. F90, F95
1587 #  2. Good/tested native compilers, bad/untested native compilers
1427   #
1428 < # pgf90 is the Portland Group F90 compilers.
1590 < # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1591 < # lf95 is the Lahey-Fujitsu compiler.
1592 < # epcf90 is the "Edinburgh Portable Compiler" F90.
1593 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1594 < # AC_PROG_F90
1428 > #
1429  
1430  
1597 # ----------------------------- #
1598 # 3c. The Fortran 95 compiler.  #
1599 # ----------------------------- #
1431  
1432  
1602 # AC_LANG_PREPROC(Fortran 95)
1603 # ---------------------------
1604 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1433  
1434 <
1435 <
1608 < # AC_LANG_COMPILER(Fortran 95)
1609 < # ----------------------------
1610 < # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1611 < # AC_REQUIRE'able.
1612 <
1613 <
1614 <
1615 < # AC_PROG_F95([COMPILERS...])
1616 < # ---------------------------
1617 < # COMPILERS is a space separated list of Fortran 95 compilers to search
1618 < # for.
1434 > # AC_F90_MODULE_NAMES
1435 > # -------------------
1436   #
1437 < # Compilers are ordered by
1621 < #  1. Good/tested native compilers, bad/untested native compilers
1437 > # Figure out how the Fortran 90 compiler constructs module file names
1438   #
1439 < # xlf95 is the IBM (AIX) F95 compiler.
1624 < # lf95 is the Lahey-Fujitsu compiler.
1625 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1626 < # AC_PROG_F95
1439 > # AC_F90_MODULE_NAMES
1440  
1441  
1629 ## ------------------------------- ##
1630 ## 4. Compilers' characteristics.  ##
1631 ## ------------------------------- ##
1442  
1443  
1634 # ---------------------------------------- #
1635 # 4b. Fortan 90 compiler characteristics.  #
1636 # ---------------------------------------- #
1444  
1445  
1639 # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1640 # -------------------------------------------------
1641 # Link a trivial Fortran program, compiling with a verbose output FLAG
1642 # (which default value, $ac_cv_prog_f90_v, is computed by
1643 # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1644 # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1645 # so that any link flags that are echoed by the compiler appear as
1646 # space-separated items.
1647 # _AC_PROG_F90_V_OUTPUT
1446  
1447  
1650 # _AC_PROG_F90_V
1651 # --------------
1652 #
1653 # Determine the flag that causes the Fortran 90 compiler to print
1654 # information of library and object files (normally -v)
1655 # Needed for AC_F90_LIBRARY_FLAGS
1656 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1657 # _AC_PROG_F90_V
1658
1659
1660 # AC_F90_LIBRARY_LDFLAGS
1661 # ----------------------
1662 #
1663 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1664 # intrinsic and run-time libraries that are required to successfully
1665 # link a Fortran 90 program or shared library.  The output variable
1666 # F90LIBS is set to these flags.
1667 #
1668 # This macro is intended to be used in those situations when it is
1669 # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1670 # program or shared library.
1671 #
1672 # For example, if object files from a C++ and Fortran 90 compiler must
1673 # be linked together, then the C++ compiler/linker must be used for
1674 # linking (since special C++-ish things need to happen at link time
1675 # like calling global constructors, instantiating templates, enabling
1676 # exception support, etc.).
1677 #
1678 # However, the Fortran 90 intrinsic and run-time libraries must be
1679 # linked in as well, but the C++ compiler/linker doesn't know how to
1680 # add these Fortran 90 libraries.  Hence, the macro
1681 # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1682 # libraries.
1683 #
1684 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1685 # AC_F90_LIBRARY_LDFLAGS
1686
1687
1688 # _AC_F90_NAME_MANGLING
1689 # ---------------------
1690 # Test for the name mangling scheme used by the Fortran 90 compiler.
1691 #
1692 # Sets ac_cv_f90_mangling. The value contains three fields, separated
1693 # by commas:
1694 #
1695 # lower case / upper case:
1696 #    case translation of the Fortan 90 symbols
1697 # underscore / no underscore:
1698 #    whether the compiler appends "_" to symbol names
1699 # extra underscore / no extra underscore:
1700 #    whether the compiler appends an extra "_" to symbol names already
1701 #    containing at least one underscore
1702 #
1703 # _AC_F90_NAME_MANGLING
1704
1705 # The replacement is empty.
1706
1707
1708
1709 # AC_F90_WRAPPERS
1710 # ---------------
1711 # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1712 # properly mangle the names of C identifiers, and C identifiers with
1713 # underscores, respectively, so that they match the name mangling
1714 # scheme used by the Fortran 90 compiler.
1715 # AC_F90_WRAPPERS
1448  
1449  
1718 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1719 # ------------------------------------
1720 # For a Fortran subroutine of given NAME, define a shell variable
1721 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1722 # argument is not supplied, it defaults to NAME.
1723 # AC_F90_FUNC
1450  
1451  
1726 # ---------------------------------------- #
1727 # 4c. Fortan 95 compiler characteristics.  #
1728 # ---------------------------------------- #
1452  
1453  
1731 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1732 # -------------------------------------------------
1733 # Link a trivial Fortran program, compiling with a verbose output FLAG
1734 # (which default value, $ac_cv_prog_f95_v, is computed by
1735 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1736 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1737 # so that any link flags that are echoed by the compiler appear as
1738 # space-separated items.
1739 # _AC_PROG_F95_V_OUTPUT
1454  
1455  
1742 # _AC_PROG_F95_V
1743 # --------------
1744 #
1745 # Determine the flag that causes the Fortran 95 compiler to print
1746 # information of library and object files (normally -v)
1747 # Needed for AC_F95_LIBRARY_FLAGS
1748 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1749 # _AC_PROG_F95_V
1456  
1457  
1752 # AC_F95_LIBRARY_LDFLAGS
1753 # ----------------------
1754 #
1755 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1756 # intrinsic and run-time libraries that are required to successfully
1757 # link a Fortran 95 program or shared library.  The output variable
1758 # F95LIBS is set to these flags.
1759 #
1760 # This macro is intended to be used in those situations when it is
1761 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1762 # program or shared library.
1763 #
1764 # For example, if object files from a C++ and Fortran 95 compiler must
1765 # be linked together, then the C++ compiler/linker must be used for
1766 # linking (since special C++-ish things need to happen at link time
1767 # like calling global constructors, instantiating templates, enabling
1768 # exception support, etc.).
1769 #
1770 # However, the Fortran 95 intrinsic and run-time libraries must be
1771 # linked in as well, but the C++ compiler/linker doesn't know how to
1772 # add these Fortran 95 libraries.  Hence, the macro
1773 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1774 # libraries.
1775 #
1776 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1777 # AC_F95_LIBRARY_LDFLAGS
1458  
1459  
1780 # _AC_F95_NAME_MANGLING
1781 # ---------------------
1782 # Test for the name mangling scheme used by the Fortran 95 compiler.
1783 #
1784 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1785 # by commas:
1786 #
1787 # lower case / upper case:
1788 #    case translation of the Fortan 95 symbols
1789 # underscore / no underscore:
1790 #    whether the compiler appends "_" to symbol names
1791 # extra underscore / no extra underscore:
1792 #    whether the compiler appends an extra "_" to symbol names already
1793 #    containing at least one underscore
1794 #
1795 # _AC_F95_NAME_MANGLING
1460  
1797 # The replacement is empty.
1461  
1462  
1463  
1801 # AC_F95_WRAPPERS
1802 # ---------------
1803 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1804 # properly mangle the names of C identifiers, and C identifiers with
1805 # underscores, respectively, so that they match the name mangling
1806 # scheme used by the Fortran 95 compiler.
1807 # AC_F95_WRAPPERS
1464  
1465  
1810 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1811 # ------------------------------------
1812 # For a Fortran subroutine of given NAME, define a shell variable
1813 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1814 # argument is not supplied, it defaults to NAME.
1815 # AC_F95_FUNC
1466  
1467  
1468  
# Line 1868 | Line 1518 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1518  
1519  
1520  
1871 # set program name
1872 PROGNAME="oopse"
1521  
1522  
1875 # there are two ways to do debugging.  One with the --enable-debug flag
1876 # and one using the DEBUG environment variable
1523  
1878 debug=0
1879 # Check whether --enable-debug or --disable-debug was given.
1880 if test "${enable_debug+set}" = set; then
1881  enableval="$enable_debug"
1882  debug=1
1883 fi;
1884 if test "${DEBUG}"; then
1524  
1886 cat >>confdefs.h <<\_ACEOF
1887 #define debug 1
1888 _ACEOF
1525  
1890  msg="$msg, debug mode"
1891 fi
1526  
1527  
1528   # who am i
# Line 1949 | Line 1583 | ac_ext=c
1583  
1584  
1585  
1586 < ac_ext=c
1587 < ac_cpp='$CPP $CPPFLAGS'
1588 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1589 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1590 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1586 > # set program name
1587 > PROGNAME="oopse"
1588 >
1589 >
1590 >
1591 >
1592 > OBJEXT=".$OBJEXT"
1593 >
1594 > OOPSE=oopse
1595 >
1596 > if test "x${prefix}" = "xNONE"
1597 > then
1598 >  OOPSE_HOME=${ac_default_prefix}/oopse
1599 > else
1600 >  OOPSE_HOME=${prefix}/oopse
1601 > fi
1602 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1603 > if test "${enable_oopse_home+set}" = set; then
1604 >  enableval="$enable_oopse_home"
1605 >  OOPSE_HOME="${enableval}"
1606 > fi;
1607 >
1608 > # there are two ways to do debugging.  One with the --enable-debug flag
1609 > # and one using the DEBUG environment variable
1610 >
1611 > debug=0
1612 > # Check whether --enable-debug or --disable-debug was given.
1613 > if test "${enable_debug+set}" = set; then
1614 >  enableval="$enable_debug"
1615 >  debug=1
1616 > fi;
1617 > if test "${DEBUG}"; then
1618 >
1619 > cat >>confdefs.h <<\_ACEOF
1620 > #define debug 1
1621 > _ACEOF
1622 >
1623 >  msg="$msg, debug mode"
1624 > fi
1625 >
1626 >
1627 > # Checks for programs.
1628 > ac_ext=cc
1629 > ac_cpp='$CXXCPP $CPPFLAGS'
1630 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1631 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1632 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1633   if test -n "$ac_tool_prefix"; then
1634 <  for ac_prog in icc xlc gcc cc
1634 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1635    do
1636      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1637   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1638   echo "$as_me:$LINENO: checking for $ac_word" >&5
1639   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1640 < if test "${ac_cv_prog_CC+set}" = set; then
1640 > if test "${ac_cv_prog_CXX+set}" = set; then
1641    echo $ECHO_N "(cached) $ECHO_C" >&6
1642   else
1643 <  if test -n "$CC"; then
1644 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1643 >  if test -n "$CXX"; then
1644 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1645   else
1646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1647   for as_dir in $PATH
# Line 1974 | Line 1650 | do
1650    test -z "$as_dir" && as_dir=.
1651    for ac_exec_ext in '' $ac_executable_extensions; do
1652    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1653 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1653 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1654      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1655      break 2
1656    fi
# Line 1983 | Line 1659 | CC=$ac_cv_prog_CC
1659  
1660   fi
1661   fi
1662 < CC=$ac_cv_prog_CC
1663 < if test -n "$CC"; then
1664 <  echo "$as_me:$LINENO: result: $CC" >&5
1665 < echo "${ECHO_T}$CC" >&6
1662 > CXX=$ac_cv_prog_CXX
1663 > if test -n "$CXX"; then
1664 >  echo "$as_me:$LINENO: result: $CXX" >&5
1665 > echo "${ECHO_T}$CXX" >&6
1666   else
1667    echo "$as_me:$LINENO: result: no" >&5
1668   echo "${ECHO_T}no" >&6
1669   fi
1670  
1671 <    test -n "$CC" && break
1671 >    test -n "$CXX" && break
1672    done
1673   fi
1674 < if test -z "$CC"; then
1675 <  ac_ct_CC=$CC
1676 <  for ac_prog in icc xlc gcc cc
1674 > if test -z "$CXX"; then
1675 >  ac_ct_CXX=$CXX
1676 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1677   do
1678    # Extract the first word of "$ac_prog", so it can be a program name with args.
1679   set dummy $ac_prog; ac_word=$2
1680   echo "$as_me:$LINENO: checking for $ac_word" >&5
1681   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1682 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1682 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1683    echo $ECHO_N "(cached) $ECHO_C" >&6
1684   else
1685 <  if test -n "$ac_ct_CC"; then
1686 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1685 >  if test -n "$ac_ct_CXX"; then
1686 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1687   else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689   for as_dir in $PATH
# Line 2016 | Line 1692 | do
1692    test -z "$as_dir" && as_dir=.
1693    for ac_exec_ext in '' $ac_executable_extensions; do
1694    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1695 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1695 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1696      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1697      break 2
1698    fi
# Line 2025 | Line 1701 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1701  
1702   fi
1703   fi
1704 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1705 < if test -n "$ac_ct_CC"; then
1706 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1707 < echo "${ECHO_T}$ac_ct_CC" >&6
1704 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1705 > if test -n "$ac_ct_CXX"; then
1706 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1707 > echo "${ECHO_T}$ac_ct_CXX" >&6
1708   else
1709    echo "$as_me:$LINENO: result: no" >&5
1710   echo "${ECHO_T}no" >&6
1711   fi
1712  
1713 <  test -n "$ac_ct_CC" && break
1713 >  test -n "$ac_ct_CXX" && break
1714   done
1715 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1716  
1717 <  CC=$ac_ct_CC
1717 >  CXX=$ac_ct_CXX
1718   fi
1719  
1720  
2044 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2045 See \`config.log' for more details." >&5
2046 echo "$as_me: error: no acceptable C compiler found in \$PATH
2047 See \`config.log' for more details." >&2;}
2048   { (exit 1); exit 1; }; }
2049
1721   # Provide some information about the compiler.
1722   echo "$as_me:$LINENO:" \
1723 <     "checking for C compiler version" >&5
1723 >     "checking for C++ compiler version" >&5
1724   ac_compiler=`set X $ac_compile; echo $2`
1725   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1726    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2087 | Line 1758 | echo "$as_me:$LINENO: checking for C compiler default
1758   # Try to create an executable without -o first, disregard a.out.
1759   # It will help us diagnose broken compilers, and finding out an intuition
1760   # of exeext.
1761 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1762 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1761 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1762 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1763   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1764   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1765    (eval $ac_link_default) 2>&5
# Line 2131 | Line 1802 | sed 's/^/| /' conftest.$ac_ext >&5
1802    echo "$as_me: failed program was:" >&5
1803   sed 's/^/| /' conftest.$ac_ext >&5
1804  
1805 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1805 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1806   See \`config.log' for more details." >&5
1807 < echo "$as_me: error: C compiler cannot create executables
1807 > echo "$as_me: error: C++ compiler cannot create executables
1808   See \`config.log' for more details." >&2;}
1809     { (exit 77); exit 77; }; }
1810   fi
# Line 2144 | Line 1815 | echo "$as_me:$LINENO: checking whether the C compiler
1815  
1816   # Check the compiler produces executables we can run.  If not, either
1817   # the compiler is broken, or we cross compile.
1818 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1819 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1818 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1819 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1820   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1821   # If not cross compiling, check that we can run a simple program.
1822   if test "$cross_compiling" != yes; then
# Line 2160 | Line 1831 | if test "$cross_compiling" != yes; then
1831      if test "$cross_compiling" = maybe; then
1832          cross_compiling=yes
1833      else
1834 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1834 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1835   If you meant to cross compile, use \`--host'.
1836   See \`config.log' for more details." >&5
1837 < echo "$as_me: error: cannot run C compiled programs.
1837 > echo "$as_me: error: cannot run C++ compiled programs.
1838   If you meant to cross compile, use \`--host'.
1839   See \`config.log' for more details." >&2;}
1840     { (exit 1); exit 1; }; }
# Line 2268 | Line 1939 | echo "$as_me:$LINENO: checking whether we are using th
1939   echo "${ECHO_T}$ac_cv_objext" >&6
1940   OBJEXT=$ac_cv_objext
1941   ac_objext=$OBJEXT
1942 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1943 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1944 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1945 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1946 + else
1947 +  cat >conftest.$ac_ext <<_ACEOF
1948 + /* confdefs.h.  */
1949 + _ACEOF
1950 + cat confdefs.h >>conftest.$ac_ext
1951 + cat >>conftest.$ac_ext <<_ACEOF
1952 + /* end confdefs.h.  */
1953 +
1954 + int
1955 + main ()
1956 + {
1957 + #ifndef __GNUC__
1958 +       choke me
1959 + #endif
1960 +
1961 +  ;
1962 +  return 0;
1963 + }
1964 + _ACEOF
1965 + rm -f conftest.$ac_objext
1966 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1967 +  (eval $ac_compile) 2>conftest.er1
1968 +  ac_status=$?
1969 +  grep -v '^ *+' conftest.er1 >conftest.err
1970 +  rm -f conftest.er1
1971 +  cat conftest.err >&5
1972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973 +  (exit $ac_status); } &&
1974 +         { ac_try='test -z "$ac_cxx_werror_flag"
1975 +                         || test ! -s conftest.err'
1976 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1977 +  (eval $ac_try) 2>&5
1978 +  ac_status=$?
1979 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1980 +  (exit $ac_status); }; } &&
1981 +         { ac_try='test -s conftest.$ac_objext'
1982 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1983 +  (eval $ac_try) 2>&5
1984 +  ac_status=$?
1985 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986 +  (exit $ac_status); }; }; then
1987 +  ac_compiler_gnu=yes
1988 + else
1989 +  echo "$as_me: failed program was:" >&5
1990 + sed 's/^/| /' conftest.$ac_ext >&5
1991 +
1992 + ac_compiler_gnu=no
1993 + fi
1994 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1996 +
1997 + fi
1998 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1999 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2000 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2001 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2002 + ac_save_CXXFLAGS=$CXXFLAGS
2003 + CXXFLAGS="-g"
2004 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2005 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2006 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2007 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2008 + else
2009 +  cat >conftest.$ac_ext <<_ACEOF
2010 + /* confdefs.h.  */
2011 + _ACEOF
2012 + cat confdefs.h >>conftest.$ac_ext
2013 + cat >>conftest.$ac_ext <<_ACEOF
2014 + /* end confdefs.h.  */
2015 +
2016 + int
2017 + main ()
2018 + {
2019 +
2020 +  ;
2021 +  return 0;
2022 + }
2023 + _ACEOF
2024 + rm -f conftest.$ac_objext
2025 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2026 +  (eval $ac_compile) 2>conftest.er1
2027 +  ac_status=$?
2028 +  grep -v '^ *+' conftest.er1 >conftest.err
2029 +  rm -f conftest.er1
2030 +  cat conftest.err >&5
2031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2032 +  (exit $ac_status); } &&
2033 +         { ac_try='test -z "$ac_cxx_werror_flag"
2034 +                         || test ! -s conftest.err'
2035 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2036 +  (eval $ac_try) 2>&5
2037 +  ac_status=$?
2038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2039 +  (exit $ac_status); }; } &&
2040 +         { ac_try='test -s conftest.$ac_objext'
2041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2042 +  (eval $ac_try) 2>&5
2043 +  ac_status=$?
2044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045 +  (exit $ac_status); }; }; then
2046 +  ac_cv_prog_cxx_g=yes
2047 + else
2048 +  echo "$as_me: failed program was:" >&5
2049 + sed 's/^/| /' conftest.$ac_ext >&5
2050 +
2051 + ac_cv_prog_cxx_g=no
2052 + fi
2053 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2054 + fi
2055 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2056 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2057 + if test "$ac_test_CXXFLAGS" = set; then
2058 +  CXXFLAGS=$ac_save_CXXFLAGS
2059 + elif test $ac_cv_prog_cxx_g = yes; then
2060 +  if test "$GXX" = yes; then
2061 +    CXXFLAGS="-g -O2"
2062 +  else
2063 +    CXXFLAGS="-g"
2064 +  fi
2065 + else
2066 +  if test "$GXX" = yes; then
2067 +    CXXFLAGS="-O2"
2068 +  else
2069 +    CXXFLAGS=
2070 +  fi
2071 + fi
2072 + for ac_declaration in \
2073 +   '' \
2074 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2075 +   'extern "C" void std::exit (int); using std::exit;' \
2076 +   'extern "C" void exit (int) throw ();' \
2077 +   'extern "C" void exit (int);' \
2078 +   'void exit (int);'
2079 + do
2080 +  cat >conftest.$ac_ext <<_ACEOF
2081 + /* confdefs.h.  */
2082 + _ACEOF
2083 + cat confdefs.h >>conftest.$ac_ext
2084 + cat >>conftest.$ac_ext <<_ACEOF
2085 + /* end confdefs.h.  */
2086 + $ac_declaration
2087 + #include <stdlib.h>
2088 + int
2089 + main ()
2090 + {
2091 + exit (42);
2092 +  ;
2093 +  return 0;
2094 + }
2095 + _ACEOF
2096 + rm -f conftest.$ac_objext
2097 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2098 +  (eval $ac_compile) 2>conftest.er1
2099 +  ac_status=$?
2100 +  grep -v '^ *+' conftest.er1 >conftest.err
2101 +  rm -f conftest.er1
2102 +  cat conftest.err >&5
2103 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104 +  (exit $ac_status); } &&
2105 +         { ac_try='test -z "$ac_cxx_werror_flag"
2106 +                         || test ! -s conftest.err'
2107 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108 +  (eval $ac_try) 2>&5
2109 +  ac_status=$?
2110 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2111 +  (exit $ac_status); }; } &&
2112 +         { ac_try='test -s conftest.$ac_objext'
2113 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2114 +  (eval $ac_try) 2>&5
2115 +  ac_status=$?
2116 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2117 +  (exit $ac_status); }; }; then
2118 +  :
2119 + else
2120 +  echo "$as_me: failed program was:" >&5
2121 + sed 's/^/| /' conftest.$ac_ext >&5
2122 +
2123 + continue
2124 + fi
2125 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2126 +  cat >conftest.$ac_ext <<_ACEOF
2127 + /* confdefs.h.  */
2128 + _ACEOF
2129 + cat confdefs.h >>conftest.$ac_ext
2130 + cat >>conftest.$ac_ext <<_ACEOF
2131 + /* end confdefs.h.  */
2132 + $ac_declaration
2133 + int
2134 + main ()
2135 + {
2136 + exit (42);
2137 +  ;
2138 +  return 0;
2139 + }
2140 + _ACEOF
2141 + rm -f conftest.$ac_objext
2142 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2143 +  (eval $ac_compile) 2>conftest.er1
2144 +  ac_status=$?
2145 +  grep -v '^ *+' conftest.er1 >conftest.err
2146 +  rm -f conftest.er1
2147 +  cat conftest.err >&5
2148 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2149 +  (exit $ac_status); } &&
2150 +         { ac_try='test -z "$ac_cxx_werror_flag"
2151 +                         || test ! -s conftest.err'
2152 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2153 +  (eval $ac_try) 2>&5
2154 +  ac_status=$?
2155 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2156 +  (exit $ac_status); }; } &&
2157 +         { ac_try='test -s conftest.$ac_objext'
2158 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2159 +  (eval $ac_try) 2>&5
2160 +  ac_status=$?
2161 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2162 +  (exit $ac_status); }; }; then
2163 +  break
2164 + else
2165 +  echo "$as_me: failed program was:" >&5
2166 + sed 's/^/| /' conftest.$ac_ext >&5
2167 +
2168 + fi
2169 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2170 + done
2171 + rm -f conftest*
2172 + if test -n "$ac_declaration"; then
2173 +  echo '#ifdef __cplusplus' >>confdefs.h
2174 +  echo $ac_declaration      >>confdefs.h
2175 +  echo '#endif'             >>confdefs.h
2176 + fi
2177 +
2178 + ac_ext=c
2179 + ac_cpp='$CPP $CPPFLAGS'
2180 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2181 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2182 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2183 +
2184 + ac_ext=c
2185 + ac_cpp='$CPP $CPPFLAGS'
2186 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2187 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2188 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2189 + if test -n "$ac_tool_prefix"; then
2190 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2191 +  do
2192 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2193 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2194 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2195 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2196 + if test "${ac_cv_prog_CC+set}" = set; then
2197 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2198 + else
2199 +  if test -n "$CC"; then
2200 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2201 + else
2202 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2203 + for as_dir in $PATH
2204 + do
2205 +  IFS=$as_save_IFS
2206 +  test -z "$as_dir" && as_dir=.
2207 +  for ac_exec_ext in '' $ac_executable_extensions; do
2208 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2209 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2210 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2211 +    break 2
2212 +  fi
2213 + done
2214 + done
2215 +
2216 + fi
2217 + fi
2218 + CC=$ac_cv_prog_CC
2219 + if test -n "$CC"; then
2220 +  echo "$as_me:$LINENO: result: $CC" >&5
2221 + echo "${ECHO_T}$CC" >&6
2222 + else
2223 +  echo "$as_me:$LINENO: result: no" >&5
2224 + echo "${ECHO_T}no" >&6
2225 + fi
2226 +
2227 +    test -n "$CC" && break
2228 +  done
2229 + fi
2230 + if test -z "$CC"; then
2231 +  ac_ct_CC=$CC
2232 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2233 + do
2234 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2235 + set dummy $ac_prog; ac_word=$2
2236 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2237 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2238 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2239 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2240 + else
2241 +  if test -n "$ac_ct_CC"; then
2242 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2243 + else
2244 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2245 + for as_dir in $PATH
2246 + do
2247 +  IFS=$as_save_IFS
2248 +  test -z "$as_dir" && as_dir=.
2249 +  for ac_exec_ext in '' $ac_executable_extensions; do
2250 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2251 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2252 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2253 +    break 2
2254 +  fi
2255 + done
2256 + done
2257 +
2258 + fi
2259 + fi
2260 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2261 + if test -n "$ac_ct_CC"; then
2262 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2263 + echo "${ECHO_T}$ac_ct_CC" >&6
2264 + else
2265 +  echo "$as_me:$LINENO: result: no" >&5
2266 + echo "${ECHO_T}no" >&6
2267 + fi
2268 +
2269 +  test -n "$ac_ct_CC" && break
2270 + done
2271 +
2272 +  CC=$ac_ct_CC
2273 + fi
2274 +
2275 +
2276 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2277 + See \`config.log' for more details." >&5
2278 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2279 + See \`config.log' for more details." >&2;}
2280 +   { (exit 1); exit 1; }; }
2281 +
2282 + # Provide some information about the compiler.
2283 + echo "$as_me:$LINENO:" \
2284 +     "checking for C compiler version" >&5
2285 + ac_compiler=`set X $ac_compile; echo $2`
2286 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2287 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2288 +  ac_status=$?
2289 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2290 +  (exit $ac_status); }
2291 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2292 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2293 +  ac_status=$?
2294 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2295 +  (exit $ac_status); }
2296 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2297 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2298 +  ac_status=$?
2299 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2300 +  (exit $ac_status); }
2301 +
2302   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2303   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2304   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2662 | Line 2693 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2693   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2694   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2695  
2696 <
2697 < ac_ext=cc
2698 < ac_cpp='$CXXCPP $CPPFLAGS'
2699 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2669 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2670 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2696 > ac_ext=${FC_SRCEXT-f}
2697 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2698 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2699 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2700   if test -n "$ac_tool_prefix"; then
2701 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2701 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2702    do
2703      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2704   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2705   echo "$as_me:$LINENO: checking for $ac_word" >&5
2706   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2707 < if test "${ac_cv_prog_CXX+set}" = set; then
2707 > if test "${ac_cv_prog_FC+set}" = set; then
2708    echo $ECHO_N "(cached) $ECHO_C" >&6
2709   else
2710 <  if test -n "$CXX"; then
2711 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2710 >  if test -n "$FC"; then
2711 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2712   else
2713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2714   for as_dir in $PATH
# Line 2688 | Line 2717 | do
2717    test -z "$as_dir" && as_dir=.
2718    for ac_exec_ext in '' $ac_executable_extensions; do
2719    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2720 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2720 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2721      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2722      break 2
2723    fi
# Line 2697 | Line 2726 | CXX=$ac_cv_prog_CXX
2726  
2727   fi
2728   fi
2729 < CXX=$ac_cv_prog_CXX
2730 < if test -n "$CXX"; then
2731 <  echo "$as_me:$LINENO: result: $CXX" >&5
2732 < echo "${ECHO_T}$CXX" >&6
2729 > FC=$ac_cv_prog_FC
2730 > if test -n "$FC"; then
2731 >  echo "$as_me:$LINENO: result: $FC" >&5
2732 > echo "${ECHO_T}$FC" >&6
2733   else
2734    echo "$as_me:$LINENO: result: no" >&5
2735   echo "${ECHO_T}no" >&6
2736   fi
2737  
2738 <    test -n "$CXX" && break
2738 >    test -n "$FC" && break
2739    done
2740   fi
2741 < if test -z "$CXX"; then
2742 <  ac_ct_CXX=$CXX
2743 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2741 > if test -z "$FC"; then
2742 >  ac_ct_FC=$FC
2743 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2744   do
2745    # Extract the first word of "$ac_prog", so it can be a program name with args.
2746   set dummy $ac_prog; ac_word=$2
2747   echo "$as_me:$LINENO: checking for $ac_word" >&5
2748   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2749 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2749 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2750    echo $ECHO_N "(cached) $ECHO_C" >&6
2751   else
2752 <  if test -n "$ac_ct_CXX"; then
2753 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2752 >  if test -n "$ac_ct_FC"; then
2753 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2754   else
2755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2756   for as_dir in $PATH
# Line 2730 | Line 2759 | do
2759    test -z "$as_dir" && as_dir=.
2760    for ac_exec_ext in '' $ac_executable_extensions; do
2761    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2762 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2762 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2763      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2764      break 2
2765    fi
# Line 2739 | Line 2768 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2768  
2769   fi
2770   fi
2771 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2772 < if test -n "$ac_ct_CXX"; then
2773 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2774 < echo "${ECHO_T}$ac_ct_CXX" >&6
2771 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2772 > if test -n "$ac_ct_FC"; then
2773 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2774 > echo "${ECHO_T}$ac_ct_FC" >&6
2775   else
2776    echo "$as_me:$LINENO: result: no" >&5
2777   echo "${ECHO_T}no" >&6
2778   fi
2779  
2780 <  test -n "$ac_ct_CXX" && break
2780 >  test -n "$ac_ct_FC" && break
2781   done
2753 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2782  
2783 <  CXX=$ac_ct_CXX
2783 >  FC=$ac_ct_FC
2784   fi
2785  
2786  
2787   # Provide some information about the compiler.
2788 < echo "$as_me:$LINENO:" \
2789 <     "checking for C++ compiler version" >&5
2788 > echo "$as_me:2788:" \
2789 >     "checking for Fortran compiler version" >&5
2790   ac_compiler=`set X $ac_compile; echo $2`
2791   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2792    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2775 | Line 2803 | ac_compiler=`set X $ac_compile; echo $2`
2803    ac_status=$?
2804    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2805    (exit $ac_status); }
2806 + rm -f a.out
2807  
2808 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2809 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2810 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2808 > # If we don't use `.F' as extension, the preprocessor is not run on the
2809 > # input file.  (Note that this only needs to work for GNU compilers.)
2810 > ac_save_ext=$ac_ext
2811 > ac_ext=F
2812 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2813 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2814 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2815    echo $ECHO_N "(cached) $ECHO_C" >&6
2816   else
2817    cat >conftest.$ac_ext <<_ACEOF
2818 < /* confdefs.h.  */
2786 < _ACEOF
2787 < cat confdefs.h >>conftest.$ac_ext
2788 < cat >>conftest.$ac_ext <<_ACEOF
2789 < /* end confdefs.h.  */
2790 <
2791 < int
2792 < main ()
2793 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2799 <  return 0;
2800 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2808 | Line 2831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2831    cat conftest.err >&5
2832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833    (exit $ac_status); } &&
2834 <         { ac_try='test -z "$ac_cxx_werror_flag"
2834 >         { ac_try='test -z "$ac_fc_werror_flag"
2835                           || test ! -s conftest.err'
2836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837    (eval $ac_try) 2>&5
# Line 2829 | Line 2852 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2852   ac_compiler_gnu=no
2853   fi
2854   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2855 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2855 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2856  
2857   fi
2858 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2859 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2860 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2861 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2862 < ac_save_CXXFLAGS=$CXXFLAGS
2863 < CXXFLAGS="-g"
2864 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2865 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2866 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2858 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2859 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2860 > ac_ext=$ac_save_ext
2861 > ac_test_FFLAGS=${FCFLAGS+set}
2862 > ac_save_FFLAGS=$FCFLAGS
2863 > FCFLAGS=
2864 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2865 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2866 > if test "${ac_cv_prog_fc_g+set}" = set; then
2867    echo $ECHO_N "(cached) $ECHO_C" >&6
2868   else
2869 <  cat >conftest.$ac_ext <<_ACEOF
2870 < /* confdefs.h.  */
2871 < _ACEOF
2849 < cat confdefs.h >>conftest.$ac_ext
2850 < cat >>conftest.$ac_ext <<_ACEOF
2851 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2854 < main ()
2855 < {
2856 <
2857 <  ;
2858 <  return 0;
2859 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2867 | Line 2881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2881    cat conftest.err >&5
2882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883    (exit $ac_status); } &&
2884 <         { ac_try='test -z "$ac_cxx_werror_flag"
2884 >         { ac_try='test -z "$ac_fc_werror_flag"
2885                           || test ! -s conftest.err'
2886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2887    (eval $ac_try) 2>&5
# Line 2880 | Line 2894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2894    ac_status=$?
2895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2896    (exit $ac_status); }; }; then
2897 <  ac_cv_prog_cxx_g=yes
2897 >  ac_cv_prog_fc_g=yes
2898   else
2899    echo "$as_me: failed program was:" >&5
2900   sed 's/^/| /' conftest.$ac_ext >&5
2901  
2902 < ac_cv_prog_cxx_g=no
2902 > ac_cv_prog_fc_g=no
2903   fi
2904   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2905 +
2906   fi
2907 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2908 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2909 < if test "$ac_test_CXXFLAGS" = set; then
2910 <  CXXFLAGS=$ac_save_CXXFLAGS
2911 < elif test $ac_cv_prog_cxx_g = yes; then
2912 <  if test "$GXX" = yes; then
2913 <    CXXFLAGS="-g -O2"
2907 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2908 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2909 > if test "$ac_test_FFLAGS" = set; then
2910 >  FCFLAGS=$ac_save_FFLAGS
2911 > elif test $ac_cv_prog_fc_g = yes; then
2912 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2913 >    FCFLAGS="-g -O2"
2914    else
2915 <    CXXFLAGS="-g"
2915 >    FCFLAGS="-g"
2916    fi
2917   else
2918 <  if test "$GXX" = yes; then
2919 <    CXXFLAGS="-O2"
2918 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2919 >    FCFLAGS="-O2"
2920    else
2921 <    CXXFLAGS=
2921 >    FCFLAGS=
2922    fi
2923   fi
2924 < for ac_declaration in \
2925 <   '' \
2926 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2927 <   'extern "C" void std::exit (int); using std::exit;' \
2928 <   'extern "C" void exit (int) throw ();' \
2929 <   'extern "C" void exit (int);' \
2930 <   'void exit (int);'
2924 >
2925 > ac_ext=c
2926 > ac_cpp='$CPP $CPPFLAGS'
2927 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2928 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2929 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2930 >
2931 > ac_ext=c
2932 > ac_cpp='$CPP $CPPFLAGS'
2933 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2934 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2935 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2936 > echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2937 > echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2938 > # On Suns, sometimes $CPP names a directory.
2939 > if test -n "$CPP" && test -d "$CPP"; then
2940 >  CPP=
2941 > fi
2942 > if test -z "$CPP"; then
2943 >  if test "${ac_cv_prog_CPP+set}" = set; then
2944 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2945 > else
2946 >      # Double quotes because CPP needs to be expanded
2947 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2948 >    do
2949 >      ac_preproc_ok=false
2950 > for ac_c_preproc_warn_flag in '' yes
2951   do
2952 +  # Use a header file that comes with gcc, so configuring glibc
2953 +  # with a fresh cross-compiler works.
2954 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2955 +  # <limits.h> exists even on freestanding compilers.
2956 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2957 +  # not just through cpp. "Syntax error" is here to catch this case.
2958    cat >conftest.$ac_ext <<_ACEOF
2959   /* confdefs.h.  */
2960   _ACEOF
2961   cat confdefs.h >>conftest.$ac_ext
2962   cat >>conftest.$ac_ext <<_ACEOF
2963   /* end confdefs.h.  */
2964 < $ac_declaration
2965 < #include <stdlib.h>
2966 < int
2967 < main ()
2968 < {
2969 < exit (42);
2929 <  ;
2930 <  return 0;
2931 < }
2964 > #ifdef __STDC__
2965 > # include <limits.h>
2966 > #else
2967 > # include <assert.h>
2968 > #endif
2969 >                     Syntax error
2970   _ACEOF
2971 < rm -f conftest.$ac_objext
2972 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2935 <  (eval $ac_compile) 2>conftest.er1
2971 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2972 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2973    ac_status=$?
2974    grep -v '^ *+' conftest.er1 >conftest.err
2975    rm -f conftest.er1
2976    cat conftest.err >&5
2977    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2978 <  (exit $ac_status); } &&
2979 <         { ac_try='test -z "$ac_cxx_werror_flag"
2980 <                         || test ! -s conftest.err'
2981 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2982 <  (eval $ac_try) 2>&5
2983 <  ac_status=$?
2984 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2985 <  (exit $ac_status); }; } &&
2986 <         { ac_try='test -s conftest.$ac_objext'
2987 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2988 <  (eval $ac_try) 2>&5
2952 <  ac_status=$?
2953 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2954 <  (exit $ac_status); }; }; then
2978 >  (exit $ac_status); } >/dev/null; then
2979 >  if test -s conftest.err; then
2980 >    ac_cpp_err=$ac_c_preproc_warn_flag
2981 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2982 >  else
2983 >    ac_cpp_err=
2984 >  fi
2985 > else
2986 >  ac_cpp_err=yes
2987 > fi
2988 > if test -z "$ac_cpp_err"; then
2989    :
2990   else
2991    echo "$as_me: failed program was:" >&5
2992   sed 's/^/| /' conftest.$ac_ext >&5
2993  
2994 +  # Broken: fails on valid input.
2995   continue
2996   fi
2997 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2997 > rm -f conftest.err conftest.$ac_ext
2998 >
2999 >  # OK, works on sane cases.  Now check whether non-existent headers
3000 >  # can be detected and how.
3001    cat >conftest.$ac_ext <<_ACEOF
3002   /* confdefs.h.  */
3003   _ACEOF
3004   cat confdefs.h >>conftest.$ac_ext
3005   cat >>conftest.$ac_ext <<_ACEOF
3006   /* end confdefs.h.  */
3007 < $ac_declaration
2970 < int
2971 < main ()
2972 < {
2973 < exit (42);
2974 <  ;
2975 <  return 0;
2976 < }
3007 > #include <ac_nonexistent.h>
3008   _ACEOF
3009 < rm -f conftest.$ac_objext
3010 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2980 <  (eval $ac_compile) 2>conftest.er1
3009 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3010 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3011    ac_status=$?
3012    grep -v '^ *+' conftest.er1 >conftest.err
3013    rm -f conftest.er1
3014    cat conftest.err >&5
3015    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3016 <  (exit $ac_status); } &&
3017 <         { ac_try='test -z "$ac_cxx_werror_flag"
3018 <                         || test ! -s conftest.err'
3019 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3020 <  (eval $ac_try) 2>&5
3016 >  (exit $ac_status); } >/dev/null; then
3017 >  if test -s conftest.err; then
3018 >    ac_cpp_err=$ac_c_preproc_warn_flag
3019 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3020 >  else
3021 >    ac_cpp_err=
3022 >  fi
3023 > else
3024 >  ac_cpp_err=yes
3025 > fi
3026 > if test -z "$ac_cpp_err"; then
3027 >  # Broken: success on invalid input.
3028 > continue
3029 > else
3030 >  echo "$as_me: failed program was:" >&5
3031 > sed 's/^/| /' conftest.$ac_ext >&5
3032 >
3033 >  # Passes both tests.
3034 > ac_preproc_ok=:
3035 > break
3036 > fi
3037 > rm -f conftest.err conftest.$ac_ext
3038 >
3039 > done
3040 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3041 > rm -f conftest.err conftest.$ac_ext
3042 > if $ac_preproc_ok; then
3043 >  break
3044 > fi
3045 >
3046 >    done
3047 >    ac_cv_prog_CPP=$CPP
3048 >
3049 > fi
3050 >  CPP=$ac_cv_prog_CPP
3051 > else
3052 >  ac_cv_prog_CPP=$CPP
3053 > fi
3054 > echo "$as_me:$LINENO: result: $CPP" >&5
3055 > echo "${ECHO_T}$CPP" >&6
3056 > ac_preproc_ok=false
3057 > for ac_c_preproc_warn_flag in '' yes
3058 > do
3059 >  # Use a header file that comes with gcc, so configuring glibc
3060 >  # with a fresh cross-compiler works.
3061 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3062 >  # <limits.h> exists even on freestanding compilers.
3063 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3064 >  # not just through cpp. "Syntax error" is here to catch this case.
3065 >  cat >conftest.$ac_ext <<_ACEOF
3066 > /* confdefs.h.  */
3067 > _ACEOF
3068 > cat confdefs.h >>conftest.$ac_ext
3069 > cat >>conftest.$ac_ext <<_ACEOF
3070 > /* end confdefs.h.  */
3071 > #ifdef __STDC__
3072 > # include <limits.h>
3073 > #else
3074 > # include <assert.h>
3075 > #endif
3076 >                     Syntax error
3077 > _ACEOF
3078 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3079 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3080    ac_status=$?
3081 +  grep -v '^ *+' conftest.er1 >conftest.err
3082 +  rm -f conftest.er1
3083 +  cat conftest.err >&5
3084    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3085 <  (exit $ac_status); }; } &&
3086 <         { ac_try='test -s conftest.$ac_objext'
3087 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3088 <  (eval $ac_try) 2>&5
3085 >  (exit $ac_status); } >/dev/null; then
3086 >  if test -s conftest.err; then
3087 >    ac_cpp_err=$ac_c_preproc_warn_flag
3088 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3089 >  else
3090 >    ac_cpp_err=
3091 >  fi
3092 > else
3093 >  ac_cpp_err=yes
3094 > fi
3095 > if test -z "$ac_cpp_err"; then
3096 >  :
3097 > else
3098 >  echo "$as_me: failed program was:" >&5
3099 > sed 's/^/| /' conftest.$ac_ext >&5
3100 >
3101 >  # Broken: fails on valid input.
3102 > continue
3103 > fi
3104 > rm -f conftest.err conftest.$ac_ext
3105 >
3106 >  # OK, works on sane cases.  Now check whether non-existent headers
3107 >  # can be detected and how.
3108 >  cat >conftest.$ac_ext <<_ACEOF
3109 > /* confdefs.h.  */
3110 > _ACEOF
3111 > cat confdefs.h >>conftest.$ac_ext
3112 > cat >>conftest.$ac_ext <<_ACEOF
3113 > /* end confdefs.h.  */
3114 > #include <ac_nonexistent.h>
3115 > _ACEOF
3116 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3117 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3118    ac_status=$?
3119 +  grep -v '^ *+' conftest.er1 >conftest.err
3120 +  rm -f conftest.er1
3121 +  cat conftest.err >&5
3122    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3123 <  (exit $ac_status); }; }; then
3124 <  break
3123 >  (exit $ac_status); } >/dev/null; then
3124 >  if test -s conftest.err; then
3125 >    ac_cpp_err=$ac_c_preproc_warn_flag
3126 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3127 >  else
3128 >    ac_cpp_err=
3129 >  fi
3130   else
3131 +  ac_cpp_err=yes
3132 + fi
3133 + if test -z "$ac_cpp_err"; then
3134 +  # Broken: success on invalid input.
3135 + continue
3136 + else
3137    echo "$as_me: failed program was:" >&5
3138   sed 's/^/| /' conftest.$ac_ext >&5
3139  
3140 +  # Passes both tests.
3141 + ac_preproc_ok=:
3142 + break
3143   fi
3144 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3144 > rm -f conftest.err conftest.$ac_ext
3145 >
3146   done
3147 < rm -f conftest*
3148 < if test -n "$ac_declaration"; then
3149 <  echo '#ifdef __cplusplus' >>confdefs.h
3150 <  echo $ac_declaration      >>confdefs.h
3151 <  echo '#endif'             >>confdefs.h
3147 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3148 > rm -f conftest.err conftest.$ac_ext
3149 > if $ac_preproc_ok; then
3150 >  :
3151 > else
3152 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3153 > See \`config.log' for more details." >&5
3154 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3155 > See \`config.log' for more details." >&2;}
3156 >   { (exit 1); exit 1; }; }
3157   fi
3158  
3159   ac_ext=c
# Line 3018 | Line 3162 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3162   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3163   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3164  
3165 + echo "$as_me:$LINENO: checking for egrep" >&5
3166 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3167 + if test "${ac_cv_prog_egrep+set}" = set; then
3168 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3169 + else
3170 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3171 +    then ac_cv_prog_egrep='grep -E'
3172 +    else ac_cv_prog_egrep='egrep'
3173 +    fi
3174 + fi
3175 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3176 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3177 + EGREP=$ac_cv_prog_egrep
3178  
3179 < OOPSE_TEMPLATE_FLAGS=""
3180 < if test $ac_cv_cxx_compiler_gnu = no; then
3181 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3182 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3183 <  echo 'void f(){}' > conftest.cc
3184 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3028 <    echo "$as_me:$LINENO: result: yes" >&5
3179 >
3180 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3181 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3182 > LN_S=$as_ln_s
3183 > if test "$LN_S" = "ln -s"; then
3184 >  echo "$as_me:$LINENO: result: yes" >&5
3185   echo "${ECHO_T}yes" >&6
3186 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3187 <  else
3188 <    echo "$as_me:$LINENO: result: no" >&5
3189 < echo "${ECHO_T}no" >&6
3190 <  fi
3191 <  rm -f conftest*
3192 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3193 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3194 <  echo 'void f(){}' > conftest.cc
3195 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3196 <    echo "$as_me:$LINENO: result: yes" >&5
3186 > else
3187 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3188 > echo "${ECHO_T}no, using $LN_S" >&6
3189 > fi
3190 >
3191 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3192 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3193 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3194 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3196 > else
3197 >  cat >conftest.make <<\_ACEOF
3198 > all:
3199 >        @echo 'ac_maketemp="$(MAKE)"'
3200 > _ACEOF
3201 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3202 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3203 > if test -n "$ac_maketemp"; then
3204 >  eval ac_cv_prog_make_${ac_make}_set=yes
3205 > else
3206 >  eval ac_cv_prog_make_${ac_make}_set=no
3207 > fi
3208 > rm -f conftest.make
3209 > fi
3210 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3211 >  echo "$as_me:$LINENO: result: yes" >&5
3212   echo "${ECHO_T}yes" >&6
3213 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3213 >  SET_MAKE=
3214 > else
3215 >  echo "$as_me:$LINENO: result: no" >&5
3216   echo "${ECHO_T}no" >&6
3217 +  SET_MAKE="MAKE=${MAKE-make}"
3218 + fi
3219 +
3220 + if test -n "$ac_tool_prefix"; then
3221 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3222 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3223 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3226 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3227 + else
3228 +  if test -n "$RANLIB"; then
3229 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3230 + else
3231 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 + for as_dir in $PATH
3233 + do
3234 +  IFS=$as_save_IFS
3235 +  test -z "$as_dir" && as_dir=.
3236 +  for ac_exec_ext in '' $ac_executable_extensions; do
3237 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3239 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240 +    break 2
3241    fi
3242 <  rm -f conftest*
3243 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3244 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3245 <  echo 'void f(){}' > conftest.cc
3246 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3247 <    echo "$as_me:$LINENO: result: yes" >&5
3248 < echo "${ECHO_T}yes" >&6
3249 <    OOPSE_TEMPLATE_FLAGS="-pto"
3250 <  else
3251 <    echo "$as_me:$LINENO: result: no" >&5
3242 > done
3243 > done
3244 >
3245 > fi
3246 > fi
3247 > RANLIB=$ac_cv_prog_RANLIB
3248 > if test -n "$RANLIB"; then
3249 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3250 > echo "${ECHO_T}$RANLIB" >&6
3251 > else
3252 >  echo "$as_me:$LINENO: result: no" >&5
3253   echo "${ECHO_T}no" >&6
3254 + fi
3255 +
3256 + fi
3257 + if test -z "$ac_cv_prog_RANLIB"; then
3258 +  ac_ct_RANLIB=$RANLIB
3259 +  # Extract the first word of "ranlib", so it can be a program name with args.
3260 + set dummy ranlib; ac_word=$2
3261 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3262 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3263 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3264 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3265 + else
3266 +  if test -n "$ac_ct_RANLIB"; then
3267 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3268 + else
3269 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3270 + for as_dir in $PATH
3271 + do
3272 +  IFS=$as_save_IFS
3273 +  test -z "$as_dir" && as_dir=.
3274 +  for ac_exec_ext in '' $ac_executable_extensions; do
3275 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3276 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3277 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3278 +    break 2
3279    fi
3280 <  rm -f conftest*
3281 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3061 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3062 <  echo 'void f(){}' > conftest.cc
3063 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3064 <    echo "$as_me:$LINENO: result: yes" >&5
3065 < echo "${ECHO_T}yes" >&6
3280 > done
3281 > done
3282  
3283 +  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284 + fi
3285 + fi
3286 + ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3287 + if test -n "$ac_ct_RANLIB"; then
3288 +  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3289 + echo "${ECHO_T}$ac_ct_RANLIB" >&6
3290 + else
3291 +  echo "$as_me:$LINENO: result: no" >&5
3292 + echo "${ECHO_T}no" >&6
3293 + fi
3294  
3295 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3296 <  else
3297 <    echo "$as_me:$LINENO: result: no" >&5
3295 >  RANLIB=$ac_ct_RANLIB
3296 > else
3297 >  RANLIB="$ac_cv_prog_RANLIB"
3298 > fi
3299 >
3300 >
3301 >   # Extract the first word of "perl", so it can be a program name with args.
3302 > set dummy perl; ac_word=$2
3303 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3304 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3305 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3307 > else
3308 >  case $PERLINTERP in
3309 >  [\\/]* | ?:[\\/]*)
3310 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3311 >  ;;
3312 >  *)
3313 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3314 > for as_dir in $PATH
3315 > do
3316 >  IFS=$as_save_IFS
3317 >  test -z "$as_dir" && as_dir=.
3318 >  for ac_exec_ext in '' $ac_executable_extensions; do
3319 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3320 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3321 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3322 >    break 2
3323 >  fi
3324 > done
3325 > done
3326 >
3327 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3328 >  ;;
3329 > esac
3330 > fi
3331 > PERLINTERP=$ac_cv_path_PERLINTERP
3332 >
3333 > if test -n "$PERLINTERP"; then
3334 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3335 > echo "${ECHO_T}$PERLINTERP" >&6
3336 > else
3337 >  echo "$as_me:$LINENO: result: no" >&5
3338   echo "${ECHO_T}no" >&6
3339 + fi
3340 +
3341 +   ac_cv_path_perlinterp="$PERLINTERP"
3342 +   _sHpB='#!'
3343 +
3344 +
3345 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3346 + if test "${with_perl_shebang+set}" = set; then
3347 +  withval="$with_perl_shebang"
3348 +  opt_perl_shebang="$withval"
3349 + else
3350 +                opt_perl_shebang="not_set"
3351 + fi;
3352 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3353 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3354 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3356 + else
3357 +   case "$opt_perl_shebang" in
3358 +                      not_set  ) ax_cv_opt_perl_shebang=''
3359 +                               ;;
3360 +                         *     )
3361 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3362 +                    esac
3363 +
3364 + fi
3365 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3366 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3367 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3368 +     then
3369 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3370 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3371 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3372 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3373 +
3374 + # Automatic detection of sharpbang formula starts here
3375 +     else
3376 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3377 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3378 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3379 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3380 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3381 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3382 + else
3383 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3384 +        if test "x$_somian_kspb_perl" == x
3385 +          then _somian_ksbp_warn_empty='durnit'
3386 +          else
3387 +          case "A$_somian_kspb_perl" in
3388 +                 A#!*perl* )
3389 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3390 +                        ;;
3391 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3392 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3393 +          esac
3394 +        fi
3395 +
3396 + fi
3397 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3398 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3399 + # The above prints Checking ... result message to user.
3400 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3401 +
3402 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3403 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3404 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3405 +    fi
3406 + # Inform user after printing result value
3407 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3408 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3409 + echo "$as_me: Maybe Not good -" >&6;}
3410 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3411 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3412 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3413 + echo "$as_me: OK Good result - " >&6;}
3414 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3415 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3416 +    fi
3417    fi
3418 +
3419 + # Find a good install program.  We prefer a C program (faster),
3420 + # so one script is as good as another.  But avoid the broken or
3421 + # incompatible versions:
3422 + # SysV /etc/install, /usr/sbin/install
3423 + # SunOS /usr/etc/install
3424 + # IRIX /sbin/install
3425 + # AIX /bin/install
3426 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3427 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3428 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3429 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3430 + # OS/2's system install, which has a completely different semantic
3431 + # ./install, which can be erroneously created by make from ./install.sh.
3432 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3433 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3434 + if test -z "$INSTALL"; then
3435 + if test "${ac_cv_path_install+set}" = set; then
3436 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3437 + else
3438 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3439 + for as_dir in $PATH
3440 + do
3441 +  IFS=$as_save_IFS
3442 +  test -z "$as_dir" && as_dir=.
3443 +  # Account for people who put trailing slashes in PATH elements.
3444 + case $as_dir/ in
3445 +  ./ | .// | /cC/* | \
3446 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3447 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3448 +  /usr/ucb/* ) ;;
3449 +  *)
3450 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3451 +    # Don't use installbsd from OSF since it installs stuff as root
3452 +    # by default.
3453 +    for ac_prog in ginstall scoinst install; do
3454 +      for ac_exec_ext in '' $ac_executable_extensions; do
3455 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3456 +          if test $ac_prog = install &&
3457 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3458 +            # AIX install.  It has an incompatible calling convention.
3459 +            :
3460 +          elif test $ac_prog = install &&
3461 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3462 +            # program-specific install script used by HP pwplus--don't use.
3463 +            :
3464 +          else
3465 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3466 +            break 3
3467 +          fi
3468 +        fi
3469 +      done
3470 +    done
3471 +    ;;
3472 + esac
3473 + done
3474 +
3475 +
3476   fi
3477 +  if test "${ac_cv_path_install+set}" = set; then
3478 +    INSTALL=$ac_cv_path_install
3479 +  else
3480 +    # As a last resort, use the slow shell script.  We don't cache a
3481 +    # path for INSTALL within a source directory, because that will
3482 +    # break other packages using the cache if that directory is
3483 +    # removed, or if the path is relative.
3484 +    INSTALL=$ac_install_sh
3485 +  fi
3486 + fi
3487 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3488 + echo "${ECHO_T}$INSTALL" >&6
3489  
3490 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3491 + # It thinks the first close brace ends the variable substitution.
3492 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3493  
3494 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3495  
3496 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3497  
3498 < ac_ext=f90
3499 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3500 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3501 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3502 < if test -n "$ac_tool_prefix"; then
3503 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3504 <  do
3085 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3086 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3498 > case "x$INSTALL" in
3499 >   x/*) ;;
3500 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3501 > esac
3502 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3503 > # Extract the first word of "ar", so it can be a program name with args.
3504 > set dummy ar; ac_word=$2
3505   echo "$as_me:$LINENO: checking for $ac_word" >&5
3506   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3507 < if test "${ac_cv_prog_F90+set}" = set; then
3507 > if test "${ac_cv_prog_AR+set}" = set; then
3508    echo $ECHO_N "(cached) $ECHO_C" >&6
3509   else
3510 <  if test -n "$F90"; then
3511 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3510 >  if test -n "$AR"; then
3511 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3512   else
3513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3514   for as_dir in $PATH
# Line 3099 | Line 3517 | do
3517    test -z "$as_dir" && as_dir=.
3518    for ac_exec_ext in '' $ac_executable_extensions; do
3519    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3520 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3520 >    ac_cv_prog_AR="ar"
3521      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3522      break 2
3523    fi
3524   done
3525   done
3526  
3527 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3528   fi
3529   fi
3530 < F90=$ac_cv_prog_F90
3531 < if test -n "$F90"; then
3532 <  echo "$as_me:$LINENO: result: $F90" >&5
3533 < echo "${ECHO_T}$F90" >&6
3530 > AR=$ac_cv_prog_AR
3531 > if test -n "$AR"; then
3532 >  echo "$as_me:$LINENO: result: $AR" >&5
3533 > echo "${ECHO_T}$AR" >&6
3534   else
3535    echo "$as_me:$LINENO: result: no" >&5
3536   echo "${ECHO_T}no" >&6
3537   fi
3538  
3539 <    test -n "$F90" && break
3540 <  done
3539 > if test "$AR" = "NONE"; then
3540 >  cat >confcache <<\_ACEOF
3541 > # This file is a shell script that caches the results of configure
3542 > # tests run on this system so they can be shared between configure
3543 > # scripts and configure runs, see configure's option --config-cache.
3544 > # It is not useful on other systems.  If it contains results you don't
3545 > # want to keep, you may remove or edit it.
3546 > #
3547 > # config.status only pays attention to the cache file if you give it
3548 > # the --recheck option to rerun configure.
3549 > #
3550 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3551 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3552 > # following values.
3553 >
3554 > _ACEOF
3555 >
3556 > # The following way of writing the cache mishandles newlines in values,
3557 > # but we know of no workaround that is simple, portable, and efficient.
3558 > # So, don't put newlines in cache variables' values.
3559 > # Ultrix sh set writes to stderr and can't be redirected directly,
3560 > # and sets the high bit in the cache file unless we assign to the vars.
3561 > {
3562 >  (set) 2>&1 |
3563 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3564 >    *ac_space=\ *)
3565 >      # `set' does not quote correctly, so add quotes (double-quote
3566 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3567 >      sed -n \
3568 >        "s/'/'\\\\''/g;
3569 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3570 >      ;;
3571 >    *)
3572 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3573 >      sed -n \
3574 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3575 >      ;;
3576 >    esac;
3577 > } |
3578 >  sed '
3579 >     t clear
3580 >     : clear
3581 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3582 >     t end
3583 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3584 >     : end' >>confcache
3585 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3586 >  if test -w $cache_file; then
3587 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3588 >    cat confcache >$cache_file
3589 >  else
3590 >    echo "not updating unwritable cache $cache_file"
3591 >  fi
3592   fi
3593 < if test -z "$F90"; then
3594 <  ac_ct_F90=$F90
3595 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3596 < do
3597 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3128 < set dummy $ac_prog; ac_word=$2
3593 > rm -f confcache
3594 >  exit 1
3595 > fi
3596 > # Extract the first word of "ps", so it can be a program name with args.
3597 > set dummy ps; ac_word=$2
3598   echo "$as_me:$LINENO: checking for $ac_word" >&5
3599   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3600 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3600 > if test "${ac_cv_path_PS+set}" = set; then
3601    echo $ECHO_N "(cached) $ECHO_C" >&6
3602   else
3603 <  if test -n "$ac_ct_F90"; then
3604 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3605 < else
3606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3603 >  case $PS in
3604 >  [\\/]* | ?:[\\/]*)
3605 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3606 >  ;;
3607 >  *)
3608 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3609   for as_dir in $PATH
3610   do
3611    IFS=$as_save_IFS
3612    test -z "$as_dir" && as_dir=.
3613    for ac_exec_ext in '' $ac_executable_extensions; do
3614    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3615 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3615 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3616      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3617      break 2
3618    fi
3619   done
3620   done
3621  
3622 +  ;;
3623 + esac
3624   fi
3625 < fi
3626 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3627 < if test -n "$ac_ct_F90"; then
3628 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3629 < echo "${ECHO_T}$ac_ct_F90" >&6
3625 > PS=$ac_cv_path_PS
3626 >
3627 > if test -n "$PS"; then
3628 >  echo "$as_me:$LINENO: result: $PS" >&5
3629 > echo "${ECHO_T}$PS" >&6
3630   else
3631    echo "$as_me:$LINENO: result: no" >&5
3632   echo "${ECHO_T}no" >&6
3633   fi
3634  
3635 <  test -n "$ac_ct_F90" && break
3636 < done
3635 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3636 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3637 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3639 > else
3640  
3641 <  F90=$ac_ct_F90
3641 >        if $PS ax -o rss > /dev/null 2>&1; then
3642 >                ac_cv_prog_ps_ax=yes
3643 >        else
3644 >                ac_cv_prog_ps_ax=no
3645 >        fi
3646 >        if $PS -ef -o rss > /dev/null 2>&1; then
3647 >                ac_cv_prog_ps_ef=yes
3648 >        else
3649 >                ac_cv_prog_ps_ef=no
3650 >        fi
3651 >        if test "$ac_cv_prog_ps_ax" = yes; then
3652 >                ac_cv_prog_ps_syntax=BSD
3653 >        else
3654 >                if test "$ac_cv_prog_ps_ef" = yes; then
3655 >                        ac_cv_prog_ps_syntax=POSIX
3656 >                else
3657 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3658 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3659 >   { (exit 1); exit 1; }; }
3660 >                fi
3661 >        fi
3662 >
3663   fi
3664 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3665 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3666  
3667 + cat >>confdefs.h <<_ACEOF
3668 + #define PSCOMMAND $PS
3669 + _ACEOF
3670  
3671 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3672 < # input file.
3673 < ac_save_ext=$ac_ext
3674 < ac_ext=F90
3675 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3676 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3175 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3176 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3671 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3672 >
3673 > cat >>confdefs.h <<\_ACEOF
3674 > #define PSTYPE_IS_BSD 1
3675 > _ACEOF
3676 >
3677   else
3678 <  cat >conftest.$ac_ext <<_ACEOF
3678 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679  
3680 < program main
3680 > cat >>confdefs.h <<\_ACEOF
3681 > #define PSTYPE_IS_POSIX 1
3682 > _ACEOF
3683  
3684 < #ifndef __GNUC__
3685 <       choke me
3686 < #endif
3684 >   else
3685 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3686 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3687 >   { (exit 1); exit 1; }; }
3688 >   fi
3689 > fi
3690  
3691 < end program main
3691 > ac_ext=${FC_SRCEXT-f}
3692 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3693 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3694 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3695 >
3696  
3697 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3698 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3699 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3700 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3701 + else
3702 +  ac_ext=F90
3703 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3704 + FCFLAGS_SRCEXT=""
3705 + ac_cv_fc_srcext_F90=unknown
3706 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3707 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3708 +  cat >conftest.$ac_ext <<_ACEOF
3709 +      program main
3710 +
3711 +      end
3712   _ACEOF
3713   rm -f conftest.$ac_objext
3714   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3195 | Line 3719 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3719    cat conftest.err >&5
3720    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3721    (exit $ac_status); } &&
3722 <         { ac_try='test -z "$ac_f90_werror_flag"
3722 >         { ac_try='test -z "$ac_fc_werror_flag"
3723                           || test ! -s conftest.err'
3724    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3725    (eval $ac_try) 2>&5
# Line 3208 | Line 3732 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3732    ac_status=$?
3733    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3734    (exit $ac_status); }; }; then
3735 <  ac_compiler_gnu=yes
3735 >  ac_cv_fc_srcext_F90=$ac_flag; break
3736   else
3737    echo "$as_me: failed program was:" >&5
3738   sed 's/^/| /' conftest.$ac_ext >&5
3739  
3216 ac_compiler_gnu=no
3740   fi
3741   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3742 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3742 > done
3743 > rm -f conftest.$ac_objext conftest.F90
3744 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3745  
3746   fi
3747 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3748 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3749 < ac_ext=$ac_save_ext
3750 < G95=`test $ac_compiler_gnu = yes && echo yes`
3751 < ac_ext=c
3752 < ac_cpp='$CPP $CPPFLAGS'
3753 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3754 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3747 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3748 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3749 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3750 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3751 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3752 >   { (exit 1); exit 1; }; }
3753 > else
3754 >  FC_SRCEXT=F90
3755 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3756 >    FCFLAGS_SRCEXT=""
3757 >    FCFLAGS_F90=""
3758 >  else
3759 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3760 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3761 >  fi
3762  
3763  
3764 + fi
3765  
3766  
3767  
3768 +
3769 +
3770   # Try to determine native compiler flags that allow us to use F90 suffix
3771   # for preprocessed f90 source.
3772  
# Line 3240 | Line 3774 | if test "$ac_test_PREPFLAG" != "set"; then
3774    PREPFLAG=""
3775    case "${host_cpu}-${host_os}" in
3776  
3777 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3777 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3778                      PREPFLAG="-fpp1 "
3779                  fi;;
3780 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3780 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3781                      PREPFLAG="-qsuffix=cpp=F90 "
3782                  fi;;
3783    *darwin*)
3784 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3784 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3785                  PREPFLAG="-qsuffix=cpp=F90 "
3786          fi;;
3787    esac
# Line 3262 | Line 3796 | echo $ECHO_N "checking to make sure F90 preprocessor f
3796   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3797  
3798  
3799 <  ac_ext=f90
3800 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3801 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3802 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3799 >  ac_ext=${FC_SRCEXT-f}
3800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3803  
3804    ac_save_ext=$ac_ext
3805    ac_ext=F90
3806 <  ac_save_F90FLAGS=$F90FLAGS
3806 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3807  
3808    if test "$PREPFLAG"; then
3809 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3809 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3810   fi
3811  
3812      cat >conftest.$ac_ext <<_ACEOF
3813  
3814  
3815 < program main
3282 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3286
3287 end program main
3288
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3296 | Line 3827 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827    cat conftest.err >&5
3828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3829    (exit $ac_status); } &&
3830 <         { ac_try='test -z "$ac_f90_werror_flag"
3830 >         { ac_try='test -z "$ac_fc_werror_flag"
3831                           || test ! -s conftest.err'
3832    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3833    (eval $ac_try) 2>&5
# Line 3318 | Line 3849 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3849   fi
3850   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3851  
3852 <  F90FLAGS=$ac_save_F90FLAGS
3852 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3853    ac_ext=$ac_save_ext
3854 <  ac_ext=c
3855 < ac_cpp='$CPP $CPPFLAGS'
3856 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3857 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3327 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3854 >  ac_ext=${FC_SRCEXT-f}
3855 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3856 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3857 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3858  
3859  
3860    if test "$prepflagworks" = 1; then
3861      echo "$as_me:$LINENO: result: yes" >&5
3862   echo "${ECHO_T}yes" >&6
3863 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3864  
3865    else
3866      echo "$as_me:$LINENO: result: no" >&5
# Line 3351 | Line 3882 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3882    PREPDEFFLAG=""
3883    case "${host_cpu}-${host_os}" in
3884  
3885 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3885 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3886                      PREPDEFFLAG=" "
3887                  fi;;
3888 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3888 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3889                      PREPDEFFLAG="-WF,"
3890                  fi;;
3891    *darwin*)
3892 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3892 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3893                  PREPDEFFLAG="-WF,"
3894          fi;;
3895    esac
# Line 3373 | Line 3904 | echo $ECHO_N "checking to make sure F90 preprocessor d
3904   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3905  
3906  
3907 <  ac_ext=f90
3908 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3909 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3907 >  ac_ext=${FC_SRCEXT-f}
3908 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3909 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3910 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3911  
3912    ac_save_ext=$ac_ext
3913    ac_ext=F90
3914 <  ac_save_F90FLAGS=$F90FLAGS
3914 >  ac_save_FCFLAGS=$FCFLAGS
3915  
3916    if test "$PREPDEFFLAG"; then
3917 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3917 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3918   fi
3919  
3920      cat >conftest.$ac_ext <<_ACEOF
3921  
3922  
3923 < program main
3393 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3401
3402 end program main
3403
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3411 | Line 3939 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3939    cat conftest.err >&5
3940    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3941    (exit $ac_status); } &&
3942 <         { ac_try='test -z "$ac_f90_werror_flag"
3942 >         { ac_try='test -z "$ac_fc_werror_flag"
3943                           || test ! -s conftest.err'
3944    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3945    (eval $ac_try) 2>&5
# Line 3433 | Line 3961 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3961   fi
3962   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3963  
3964 <  F90FLAGS=$ac_save_F90FLAGS
3964 >  FCFLAGS=$ac_save_FCFLAGS
3965    ac_ext=$ac_save_ext
3966 <  ac_ext=c
3967 < ac_cpp='$CPP $CPPFLAGS'
3968 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3969 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3442 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3966 >  ac_ext=${FC_SRCEXT-f}
3967 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3968 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3969 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3970  
3971  
3445
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3456 | Line 3982 | ac_ext=f90
3982    fi
3983   fi
3984  
3985 < ac_ext=f90
3986 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3987 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3988 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3989 <
3990 <
3991 <
3466 < ac_ext=f90
3467 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3468 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3469 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3470 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3471 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3472 < if test "${ac_cv_prog_f90_v+set}" = set; then
3985 > ac_ext=${FC_SRCEXT-f}
3986 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3987 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3988 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3989 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3990 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3991 > if test "${ac_cv_prog_fc_v+set}" = set; then
3992    echo $ECHO_N "(cached) $ECHO_C" >&6
3993   else
3994 +  cat >conftest.$ac_ext <<_ACEOF
3995 +      program main
3996  
3997 < cat >conftest.$ac_ext <<_ACEOF
3477 <
3478 < program main
3479 <
3480 <
3481 < end program main
3482 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3490 | Line 4005 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4005    cat conftest.err >&5
4006    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007    (exit $ac_status); } &&
4008 <         { ac_try='test -z "$ac_f90_werror_flag"
4008 >         { ac_try='test -z "$ac_fc_werror_flag"
4009                           || test ! -s conftest.err'
4010    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4011    (eval $ac_try) 2>&5
# Line 3503 | Line 4018 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018    ac_status=$?
4019    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020    (exit $ac_status); }; }; then
4021 <  ac_cv_prog_f90_v=
4021 >  ac_cv_prog_fc_v=
4022   # Try some options frequently used verbose output
4023   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4024 <  ac_ext=f90
4025 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3511 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3512 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3515 <
3516 < program main
3517 <
3518 <
3519 < end program main
3520 <
4027 >      end
4028   _ACEOF
4029  
4030   # Compile and link our simple test program by passing a flag (argument
4031 < # 1 to this macro) to the Fortran 90 compiler in order to get
4032 < # "verbose" output that we can then parse for the Fortran 90 linker
4031 > # 1 to this macro) to the Fortran compiler in order to get
4032 > # "verbose" output that we can then parse for the Fortran linker
4033   # flags.
4034 < ac_save_F90FLAGS=$F90FLAGS
4035 < F90FLAGS="$F90FLAGS $ac_verb"
4034 > ac_save_FFLAGS=$FCFLAGS
4035 > FCFLAGS="$FCFLAGS $ac_verb"
4036 > (eval echo $as_me:4036: \"$ac_link\") >&5
4037 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4038 > echo "$ac_fc_v_output" >&5
4039 > FCFLAGS=$ac_save_FFLAGS
4040  
4041 < (eval echo $as_me:3530: \"$ac_link\") >&5
3531 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3532 < echo "$ac_f90_v_output" >&5
3533 < F90FLAGS=$ac_save_F90FLAGS
4041 > rm -f conftest*
4042  
4043 < rm -f conftest.*
4044 < ac_ext=f90
4045 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4046 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4047 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4043 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4044 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4045 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4046 > ac_fc_v_output="`echo $ac_fc_v_output |
4047 >        grep 'LPATH is:' |
4048 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4049  
4050 < # If we are using xlf then replace all the commas with spaces.
4051 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4052 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4053 < fi
4050 > case $ac_fc_v_output in
4051 >  # If we are using xlf then replace all the commas with spaces.
4052 >  *xlfentry*)
4053 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4054  
4055 < # If we are using Cray Fortran then delete quotes.
4056 < # Use "\"" instead of '"' for font-lock-mode.
4057 < # FIXME: a more general fix for quoted arguments with spaces?
4058 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4059 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4060 < fi
4055 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4056 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4057 >  *mGLOB_options_string*)
4058 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4059 >
4060 >  # If we are using Cray Fortran then delete quotes.
4061 >  # Use "\"" instead of '"' for font-lock-mode.
4062 >  # FIXME: a more general fix for quoted arguments with spaces?
4063 >  *cft90*)
4064 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4065 > esac
4066 >
4067 >
4068    # look for -l* and *.a constructs in the output
4069 <  for ac_arg in $ac_f90_v_output; do
4069 >  for ac_arg in $ac_fc_v_output; do
4070       case $ac_arg in
4071          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4072 <          ac_cv_prog_f90_v=$ac_verb
4072 >          ac_cv_prog_fc_v=$ac_verb
4073            break 2 ;;
4074       esac
4075    done
4076   done
4077 < if test -z "$ac_cv_prog_f90_v"; then
4078 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4079 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4077 > if test -z "$ac_cv_prog_fc_v"; then
4078 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4079 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4080   fi
4081   else
4082    echo "$as_me: failed program was:" >&5
# Line 3572 | Line 4088 | echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4088   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089  
4090   fi
4091 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4092 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4093 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4094 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4095 < if test "${ac_cv_flibs+set}" = set; then
4091 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4092 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4093 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4094 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4095 > if test "${ac_cv_fc_libs+set}" = set; then
4096    echo $ECHO_N "(cached) $ECHO_C" >&6
4097   else
4098 <  if test "x$F90LIBS" != "x"; then
4099 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4098 >  if test "x$FCLIBS" != "x"; then
4099 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4100   else
4101  
3586 ac_ext=f90
3587 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3588 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3589 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3590
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3594 <
3595 <
3596 < end program main
3597 <
4105 >      end
4106   _ACEOF
4107  
4108   # Compile and link our simple test program by passing a flag (argument
4109 < # 1 to this macro) to the Fortran 90 compiler in order to get
4110 < # "verbose" output that we can then parse for the Fortran 90 linker
4109 > # 1 to this macro) to the Fortran compiler in order to get
4110 > # "verbose" output that we can then parse for the Fortran linker
4111   # flags.
4112 < ac_save_F90FLAGS=$F90FLAGS
4113 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4112 > ac_save_FFLAGS=$FCFLAGS
4113 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4114 > (eval echo $as_me:4114: \"$ac_link\") >&5
4115 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4116 > echo "$ac_fc_v_output" >&5
4117 > FCFLAGS=$ac_save_FFLAGS
4118  
4119 < (eval echo $as_me:3607: \"$ac_link\") >&5
3608 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3609 < echo "$ac_f90_v_output" >&5
3610 < F90FLAGS=$ac_save_F90FLAGS
4119 > rm -f conftest*
4120  
4121 < rm -f conftest.*
4122 < ac_ext=f90
4123 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4124 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4125 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4121 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4122 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4123 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4124 > ac_fc_v_output="`echo $ac_fc_v_output |
4125 >        grep 'LPATH is:' |
4126 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4127  
4128 < # If we are using xlf then replace all the commas with spaces.
4129 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4130 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4131 < fi
4128 > case $ac_fc_v_output in
4129 >  # If we are using xlf then replace all the commas with spaces.
4130 >  *xlfentry*)
4131 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4132  
4133 < # If we are using Cray Fortran then delete quotes.
4134 < # Use "\"" instead of '"' for font-lock-mode.
4135 < # FIXME: a more general fix for quoted arguments with spaces?
4136 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3627 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3628 < fi
4133 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4134 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4135 >  *mGLOB_options_string*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4137  
4138 < ac_cv_f90libs=
4138 >  # If we are using Cray Fortran then delete quotes.
4139 >  # Use "\"" instead of '"' for font-lock-mode.
4140 >  # FIXME: a more general fix for quoted arguments with spaces?
4141 >  *cft90*)
4142 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4143 > esac
4144  
4145 +
4146 +
4147 + ac_cv_fc_libs=
4148 +
4149   # Save positional arguments (if any)
4150   ac_save_positional="$@"
4151  
4152 < set X $ac_f90_v_output
4152 > set X $ac_fc_v_output
4153   while test $# != 1; do
4154    shift
4155    ac_arg=$1
4156    case $ac_arg in
4157          [\\/]*.a | ?:[\\/]*.a)
4158              ac_exists=false
4159 <  for ac_i in $ac_cv_f90libs; do
4159 >  for ac_i in $ac_cv_fc_libs; do
4160      if test x"$ac_arg" = x"$ac_i"; then
4161        ac_exists=true
4162        break
# Line 3649 | Line 4166 | else
4166    if test x"$ac_exists" = xtrue; then
4167    :
4168   else
4169 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4169 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4170   fi
4171  
4172            ;;
4173          -bI:*)
4174              ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_arg" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 3667 | Line 4184 | else
4184   else
4185    if test "$ac_compiler_gnu" = yes; then
4186    for ac_link_opt in $ac_arg; do
4187 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4187 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4188    done
4189   else
4190 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4190 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4191   fi
4192   fi
4193  
4194            ;;
4195            # Ignore these flags.
4196 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4196 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4197            ;;
4198          -lkernel32)
4199 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4199 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4200            ;;
4201          -[LRuY])
4202            # These flags, when seen by themselves, take an argument.
4203            # We remove the space between option and argument and re-iterate
4204            # unless we find an empty arg or a new option (starting with -)
4205            case $2 in
4206 <             "" | -*);;
4207 <             *)
4206 >             "" | -*);;
4207 >             *)
4208                  ac_arg="$ac_arg$2"
3692
4209                  shift; shift
4210                  set X $ac_arg "$@"
4211                  ;;
# Line 3698 | Line 4214 | fi
4214          -YP,*)
4215            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4216                ac_exists=false
4217 <  for ac_i in $ac_cv_f90libs; do
4217 >  for ac_i in $ac_cv_fc_libs; do
4218      if test x"$ac_j" = x"$ac_i"; then
4219        ac_exists=true
4220        break
# Line 3709 | Line 4225 | else
4225    :
4226   else
4227    ac_arg="$ac_arg $ac_j"
4228 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4228 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4229   fi
4230  
4231            done
4232            ;;
4233          -[lLR]*)
4234              ac_exists=false
4235 <  for ac_i in $ac_cv_f90libs; do
4235 >  for ac_i in $ac_cv_fc_libs; do
4236      if test x"$ac_arg" = x"$ac_i"; then
4237        ac_exists=true
4238        break
# Line 3726 | Line 4242 | else
4242    if test x"$ac_exists" = xtrue; then
4243    :
4244   else
4245 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4245 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4246   fi
4247  
4248            ;;
# Line 3741 | Line 4257 | case `(uname -sr) 2>/dev/null` in
4257   # must begin with a "/").
4258   case `(uname -sr) 2>/dev/null` in
4259     "SunOS 5"*)
4260 <      ac_ld_run_path=`echo $ac_f90_v_output |
4260 >      ac_ld_run_path=`echo $ac_fc_v_output |
4261                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4262        test "x$ac_ld_run_path" != x &&
3747
4263          if test "$ac_compiler_gnu" = yes; then
4264    for ac_link_opt in $ac_ld_run_path; do
4265 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4265 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4266    done
4267   else
4268 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4268 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4269   fi
4270        ;;
4271   esac
4272 < fi # test "x$F90LIBS" = "x"
4272 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4273  
4274   fi
4275 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4276 < echo "${ECHO_T}$ac_cv_flibs" >&6
4277 < F90LIBS="$ac_cv_f90libs"
4275 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4276 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4277 > FCLIBS="$ac_cv_fc_libs"
4278  
3764 ac_ext=f90
3765 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3766 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3767 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4279  
4280 + ac_ext=${FC_SRCEXT-f}
4281 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4282 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4283 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4284  
4285 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4286 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4287 < if test "${ac_cv_f90_mangling+set}" = set; then
4285 >
4286 > ac_ext=${FC_SRCEXT-f}
4287 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4288 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4289 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4290 >
4291 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4292 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4293 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4294    echo $ECHO_N "(cached) $ECHO_C" >&6
4295   else
4296 <  ac_ext=f90
4297 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4298 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4299 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4300 < cat >conftest.$ac_ext <<_ACEOF
4301 < subroutine foobar()
4302 < return
4303 < end
4304 < subroutine foo_bar()
4305 < return
4306 < end
4296 >  ac_fc_dm_save_LIBS=$LIBS
4297 > LIBS="$LIBS $FCLIBS"
4298 > ac_fortran_dm_var=FC_DUMMY_MAIN
4299 > ac_ext=c
4300 > ac_cpp='$CPP $CPPFLAGS'
4301 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4302 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4303 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4304 >
4305 > # First, try linking without a dummy main:
4306 > cat >conftest.$ac_ext <<_ACEOF
4307 > /* confdefs.h.  */
4308 > _ACEOF
4309 > cat confdefs.h >>conftest.$ac_ext
4310 > cat >>conftest.$ac_ext <<_ACEOF
4311 > /* end confdefs.h.  */
4312 >
4313 > #ifdef FC_DUMMY_MAIN
4314 > #ifndef FC_DUMMY_MAIN_EQ_F77
4315 > #  ifdef __cplusplus
4316 >     extern "C"
4317 > #  endif
4318 >   int FC_DUMMY_MAIN() { return 1; }
4319 > #endif
4320 > #endif
4321 > int
4322 > main ()
4323 > {
4324 >
4325 >  ;
4326 >  return 0;
4327 > }
4328 > _ACEOF
4329 > rm -f conftest.$ac_objext conftest$ac_exeext
4330 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4331 >  (eval $ac_link) 2>conftest.er1
4332 >  ac_status=$?
4333 >  grep -v '^ *+' conftest.er1 >conftest.err
4334 >  rm -f conftest.er1
4335 >  cat conftest.err >&5
4336 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4337 >  (exit $ac_status); } &&
4338 >         { ac_try='test -z "$ac_c_werror_flag"
4339 >                         || test ! -s conftest.err'
4340 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4341 >  (eval $ac_try) 2>&5
4342 >  ac_status=$?
4343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4344 >  (exit $ac_status); }; } &&
4345 >         { ac_try='test -s conftest$ac_exeext'
4346 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4347 >  (eval $ac_try) 2>&5
4348 >  ac_status=$?
4349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4350 >  (exit $ac_status); }; }; then
4351 >  ac_cv_fortran_dummy_main=none
4352 > else
4353 >  echo "$as_me: failed program was:" >&5
4354 > sed 's/^/| /' conftest.$ac_ext >&5
4355 >
4356 > ac_cv_fortran_dummy_main=unknown
4357 > fi
4358 > rm -f conftest.err conftest.$ac_objext \
4359 >      conftest$ac_exeext conftest.$ac_ext
4360 >
4361 > if test $ac_cv_fortran_dummy_main = unknown; then
4362 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4363 >     cat >conftest.$ac_ext <<_ACEOF
4364 > /* confdefs.h.  */
4365 > _ACEOF
4366 > cat confdefs.h >>conftest.$ac_ext
4367 > cat >>conftest.$ac_ext <<_ACEOF
4368 > /* end confdefs.h.  */
4369 > #define $ac_fortran_dm_var $ac_func
4370 > #ifdef FC_DUMMY_MAIN
4371 > #ifndef FC_DUMMY_MAIN_EQ_F77
4372 > #  ifdef __cplusplus
4373 >     extern "C"
4374 > #  endif
4375 >   int FC_DUMMY_MAIN() { return 1; }
4376 > #endif
4377 > #endif
4378 > int
4379 > main ()
4380 > {
4381 >
4382 >  ;
4383 >  return 0;
4384 > }
4385 > _ACEOF
4386 > rm -f conftest.$ac_objext conftest$ac_exeext
4387 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4388 >  (eval $ac_link) 2>conftest.er1
4389 >  ac_status=$?
4390 >  grep -v '^ *+' conftest.er1 >conftest.err
4391 >  rm -f conftest.er1
4392 >  cat conftest.err >&5
4393 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4394 >  (exit $ac_status); } &&
4395 >         { ac_try='test -z "$ac_c_werror_flag"
4396 >                         || test ! -s conftest.err'
4397 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4398 >  (eval $ac_try) 2>&5
4399 >  ac_status=$?
4400 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4401 >  (exit $ac_status); }; } &&
4402 >         { ac_try='test -s conftest$ac_exeext'
4403 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4404 >  (eval $ac_try) 2>&5
4405 >  ac_status=$?
4406 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4407 >  (exit $ac_status); }; }; then
4408 >  ac_cv_fortran_dummy_main=$ac_func; break
4409 > else
4410 >  echo "$as_me: failed program was:" >&5
4411 > sed 's/^/| /' conftest.$ac_ext >&5
4412 >
4413 > fi
4414 > rm -f conftest.err conftest.$ac_objext \
4415 >      conftest$ac_exeext conftest.$ac_ext
4416 >   done
4417 > fi
4418 > ac_ext=${FC_SRCEXT-f}
4419 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4420 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4421 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4422 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4423 > rm -f conftest*
4424 > LIBS=$ac_fc_dm_save_LIBS
4425 >
4426 > fi
4427 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4428 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4429 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4430 > if test "$FC_DUMMY_MAIN" != unknown; then
4431 >  if test $FC_DUMMY_MAIN != none; then
4432 >
4433 > cat >>confdefs.h <<_ACEOF
4434 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4435   _ACEOF
4436 +
4437 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4438 +
4439 + cat >>confdefs.h <<\_ACEOF
4440 + #define FC_DUMMY_MAIN_EQ_F77 1
4441 + _ACEOF
4442 +
4443 +  fi
4444 + fi
4445 + else
4446 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4447 + See \`config.log' for more details." >&5
4448 + echo "$as_me: error: linking to Fortran libraries from C fails
4449 + See \`config.log' for more details." >&2;}
4450 +   { (exit 1); exit 1; }; }
4451 + fi
4452 +
4453 +
4454 + ac_ext=${FC_SRCEXT-f}
4455 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4456 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4457 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4458 +
4459 + ac_ext=${FC_SRCEXT-f}
4460 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4461 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4462 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4463 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4464 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4465 + if test "${ac_cv_fc_mangling+set}" = set; then
4466 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4467 + else
4468 +  cat >conftest.$ac_ext <<_ACEOF
4469 +      subroutine foobar()
4470 +      return
4471 +      end
4472 +      subroutine foo_bar()
4473 +      return
4474 +      end
4475 + _ACEOF
4476   rm -f conftest.$ac_objext
4477   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4478    (eval $ac_compile) 2>conftest.er1
# Line 3793 | Line 4482 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4482    cat conftest.err >&5
4483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4484    (exit $ac_status); } &&
4485 <         { ac_try='test -z "$ac_f90_werror_flag"
4485 >         { ac_try='test -z "$ac_fc_werror_flag"
4486                           || test ! -s conftest.err'
4487    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4488    (eval $ac_try) 2>&5
# Line 3806 | Line 4495 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4495    ac_status=$?
4496    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4497    (exit $ac_status); }; }; then
4498 <  mv conftest.$ac_objext cf90_test.$ac_objext
4498 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4499  
4500 +  ac_save_LIBS=$LIBS
4501 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4502 +
4503    ac_ext=c
4504   ac_cpp='$CPP $CPPFLAGS'
4505   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4506   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4507   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3816
3817  ac_save_LIBS=$LIBS
3818  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3819
4508    ac_success=no
4509    for ac_foobar in foobar FOOBAR; do
4510      for ac_underscore in "" "_"; do
# Line 3835 | Line 4523 | int
4523   /* We use char because int might match the return type of a gcc2
4524     builtin and then its argument prototype would still apply.  */
4525   char $ac_func ();
4526 + #ifdef FC_DUMMY_MAIN
4527 + #ifndef FC_DUMMY_MAIN_EQ_F77
4528 + #  ifdef __cplusplus
4529 +     extern "C"
4530 + #  endif
4531 +   int FC_DUMMY_MAIN() { return 1; }
4532 + #endif
4533 + #endif
4534   int
4535   main ()
4536   {
# Line 3875 | Line 4571 | rm -f conftest.err conftest.$ac_objext \
4571        conftest$ac_exeext conftest.$ac_ext
4572      done
4573    done
4574 +  ac_ext=${FC_SRCEXT-f}
4575 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4576 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4577 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4578  
4579    if test "$ac_success" = "yes"; then
4580       case $ac_foobar in
4581 <        foobar)
4582 <           ac_case=lower
4583 <           ac_foo_bar=foo_bar
4584 <           ;;
4585 <        FOOBAR)
4586 <           ac_case=upper
4587 <           ac_foo_bar=FOO_BAR
4588 <           ;;
4581 >        foobar)
4582 >           ac_case=lower
4583 >           ac_foo_bar=foo_bar
4584 >           ;;
4585 >        FOOBAR)
4586 >           ac_case=upper
4587 >           ac_foo_bar=FOO_BAR
4588 >           ;;
4589       esac
4590  
4591 +     ac_ext=c
4592 + ac_cpp='$CPP $CPPFLAGS'
4593 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4594 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4595 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4596       ac_success_extra=no
4597       for ac_extra in "" "_"; do
4598 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 <
3895 <        cat >conftest.$ac_ext <<_ACEOF
4598 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 >        cat >conftest.$ac_ext <<_ACEOF
4600   /* confdefs.h.  */
4601   _ACEOF
4602   cat confdefs.h >>conftest.$ac_ext
# Line 3906 | Line 4610 | int
4610   /* We use char because int might match the return type of a gcc2
4611     builtin and then its argument prototype would still apply.  */
4612   char $ac_func ();
4613 + #ifdef FC_DUMMY_MAIN
4614 + #ifndef FC_DUMMY_MAIN_EQ_F77
4615 + #  ifdef __cplusplus
4616 +     extern "C"
4617 + #  endif
4618 +   int FC_DUMMY_MAIN() { return 1; }
4619 + #endif
4620 + #endif
4621   int
4622   main ()
4623   {
# Line 3945 | Line 4657 | rm -f conftest.err conftest.$ac_objext \
4657   rm -f conftest.err conftest.$ac_objext \
4658        conftest$ac_exeext conftest.$ac_ext
4659       done
4660 <
4661 <     if test "$ac_success_extra" = "yes"; then
4662 <        ac_cv_f90_mangling="$ac_case case"
4663 <        if test -z "$ac_underscore"; then
3952 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
3953 <        else
3954 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4660 >     ac_ext=${FC_SRCEXT-f}
4661 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664  
4665 +     if test "$ac_success_extra" = "yes"; then
4666 +        ac_cv_fc_mangling="$ac_case case"
4667 +        if test -z "$ac_underscore"; then
4668 +           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4669 +        else
4670 +           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4671          fi
4672          if test -z "$ac_extra"; then
4673 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4673 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4674          else
4675 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4675 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4676          fi
4677        else
4678 <        ac_cv_f90_mangling="unknown"
4678 >        ac_cv_fc_mangling="unknown"
4679        fi
4680    else
4681 <     ac_cv_f90_mangling="unknown"
3967 <
4681 >     ac_cv_fc_mangling="unknown"
4682    fi
4683  
4684    LIBS=$ac_save_LIBS
4685 <  ac_ext=f90
3972 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3973 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3974 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3975 <  rm -f cf90_test* conftest*
4685 >  rm -f cfortran_test* conftest*
4686   else
4687    echo "$as_me: failed program was:" >&5
4688   sed 's/^/| /' conftest.$ac_ext >&5
4689  
4690 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4691 + See \`config.log' for more details." >&5
4692 + echo "$as_me: error: cannot compile a simple Fortran program
4693 + See \`config.log' for more details." >&2;}
4694 +   { (exit 1); exit 1; }; }
4695   fi
4696   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3982 ac_ext=f90
3983 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3984 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3985 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4697  
4698   fi
4699 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4700 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4699 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4700 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4701  
4702 + ac_ext=${FC_SRCEXT-f}
4703 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4704 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4705 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4706  
4707 + ac_ext=${FC_SRCEXT-f}
4708 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4709 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4710 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4711  
4712 < case $ac_cv_f90_mangling in
4712 >
4713 > case $ac_cv_fc_mangling in
4714    "lower case, no underscore, no extra underscore")
4715            cat >>confdefs.h <<\_ACEOF
4716 < #define F90_FUNC(name,NAME) name
4716 > #define FC_FUNC(name,NAME) name
4717   _ACEOF
4718  
4719            cat >>confdefs.h <<\_ACEOF
4720 < #define F90_FUNC_(name,NAME) name
4720 > #define FC_FUNC_(name,NAME) name
4721   _ACEOF
4722   ;;
4723    "lower case, no underscore, extra underscore")
4724            cat >>confdefs.h <<\_ACEOF
4725 < #define F90_FUNC(name,NAME) name
4725 > #define FC_FUNC(name,NAME) name
4726   _ACEOF
4727  
4728            cat >>confdefs.h <<\_ACEOF
4729 < #define F90_FUNC_(name,NAME) name ## _
4729 > #define FC_FUNC_(name,NAME) name ## _
4730   _ACEOF
4731   ;;
4732    "lower case, underscore, no extra underscore")
4733            cat >>confdefs.h <<\_ACEOF
4734 < #define F90_FUNC(name,NAME) name ## _
4734 > #define FC_FUNC(name,NAME) name ## _
4735   _ACEOF
4736  
4737            cat >>confdefs.h <<\_ACEOF
4738 < #define F90_FUNC_(name,NAME) name ## _
4738 > #define FC_FUNC_(name,NAME) name ## _
4739   _ACEOF
4740   ;;
4741    "lower case, underscore, extra underscore")
4742            cat >>confdefs.h <<\_ACEOF
4743 < #define F90_FUNC(name,NAME) name ## _
4743 > #define FC_FUNC(name,NAME) name ## _
4744   _ACEOF
4745  
4746            cat >>confdefs.h <<\_ACEOF
4747 < #define F90_FUNC_(name,NAME) name ## __
4747 > #define FC_FUNC_(name,NAME) name ## __
4748   _ACEOF
4749   ;;
4750    "upper case, no underscore, no extra underscore")
4751            cat >>confdefs.h <<\_ACEOF
4752 < #define F90_FUNC(name,NAME) NAME
4752 > #define FC_FUNC(name,NAME) NAME
4753   _ACEOF
4754  
4755            cat >>confdefs.h <<\_ACEOF
4756 < #define F90_FUNC_(name,NAME) NAME
4756 > #define FC_FUNC_(name,NAME) NAME
4757   _ACEOF
4758   ;;
4759    "upper case, no underscore, extra underscore")
4760            cat >>confdefs.h <<\_ACEOF
4761 < #define F90_FUNC(name,NAME) NAME
4761 > #define FC_FUNC(name,NAME) NAME
4762   _ACEOF
4763  
4764            cat >>confdefs.h <<\_ACEOF
4765 < #define F90_FUNC_(name,NAME) NAME ## _
4765 > #define FC_FUNC_(name,NAME) NAME ## _
4766   _ACEOF
4767   ;;
4768    "upper case, underscore, no extra underscore")
4769            cat >>confdefs.h <<\_ACEOF
4770 < #define F90_FUNC(name,NAME) NAME ## _
4770 > #define FC_FUNC(name,NAME) NAME ## _
4771   _ACEOF
4772  
4773            cat >>confdefs.h <<\_ACEOF
4774 < #define F90_FUNC_(name,NAME) NAME ## _
4774 > #define FC_FUNC_(name,NAME) NAME ## _
4775   _ACEOF
4776   ;;
4777    "upper case, underscore, extra underscore")
4778            cat >>confdefs.h <<\_ACEOF
4779 < #define F90_FUNC(name,NAME) NAME ## _
4779 > #define FC_FUNC(name,NAME) NAME ## _
4780   _ACEOF
4781  
4782            cat >>confdefs.h <<\_ACEOF
4783 < #define F90_FUNC_(name,NAME) NAME ## __
4783 > #define FC_FUNC_(name,NAME) NAME ## __
4784   _ACEOF
4785   ;;
4786    *)
4787 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4788 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4787 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4788 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4789 >          ;;
4790 > esac
4791 >
4792 > ac_ext=${FC_SRCEXT-f}
4793 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4794 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4795 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4796 >
4797 >
4798 >
4799 > ac_ext=${FC_SRCEXT-f}
4800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4803 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4804 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4805 > if test "${ac_cv_prog_fc_v+set}" = set; then
4806 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4807 > else
4808 >  cat >conftest.$ac_ext <<_ACEOF
4809 >      program main
4810 >
4811 >      end
4812 > _ACEOF
4813 > rm -f conftest.$ac_objext
4814 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4815 >  (eval $ac_compile) 2>conftest.er1
4816 >  ac_status=$?
4817 >  grep -v '^ *+' conftest.er1 >conftest.err
4818 >  rm -f conftest.er1
4819 >  cat conftest.err >&5
4820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4821 >  (exit $ac_status); } &&
4822 >         { ac_try='test -z "$ac_fc_werror_flag"
4823 >                         || test ! -s conftest.err'
4824 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4825 >  (eval $ac_try) 2>&5
4826 >  ac_status=$?
4827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828 >  (exit $ac_status); }; } &&
4829 >         { ac_try='test -s conftest.$ac_objext'
4830 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4831 >  (eval $ac_try) 2>&5
4832 >  ac_status=$?
4833 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4834 >  (exit $ac_status); }; }; then
4835 >  ac_cv_prog_fc_v=
4836 > # Try some options frequently used verbose output
4837 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4838 >  cat >conftest.$ac_ext <<_ACEOF
4839 >      program main
4840 >
4841 >      end
4842 > _ACEOF
4843 >
4844 > # Compile and link our simple test program by passing a flag (argument
4845 > # 1 to this macro) to the Fortran compiler in order to get
4846 > # "verbose" output that we can then parse for the Fortran linker
4847 > # flags.
4848 > ac_save_FFLAGS=$FCFLAGS
4849 > FCFLAGS="$FCFLAGS $ac_verb"
4850 > (eval echo $as_me:4850: \"$ac_link\") >&5
4851 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4852 > echo "$ac_fc_v_output" >&5
4853 > FCFLAGS=$ac_save_FFLAGS
4854 >
4855 > rm -f conftest*
4856 >
4857 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4858 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4859 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4860 > ac_fc_v_output="`echo $ac_fc_v_output |
4861 >        grep 'LPATH is:' |
4862 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4863 >
4864 > case $ac_fc_v_output in
4865 >  # If we are using xlf then replace all the commas with spaces.
4866 >  *xlfentry*)
4867 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4868 >
4869 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4870 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4871 >  *mGLOB_options_string*)
4872 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4873 >
4874 >  # If we are using Cray Fortran then delete quotes.
4875 >  # Use "\"" instead of '"' for font-lock-mode.
4876 >  # FIXME: a more general fix for quoted arguments with spaces?
4877 >  *cft90*)
4878 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4879 > esac
4880 >
4881 >
4882 >  # look for -l* and *.a constructs in the output
4883 >  for ac_arg in $ac_fc_v_output; do
4884 >     case $ac_arg in
4885 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4886 >          ac_cv_prog_fc_v=$ac_verb
4887 >          break 2 ;;
4888 >     esac
4889 >  done
4890 > done
4891 > if test -z "$ac_cv_prog_fc_v"; then
4892 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4893 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4894 > fi
4895 > else
4896 >  echo "$as_me: failed program was:" >&5
4897 > sed 's/^/| /' conftest.$ac_ext >&5
4898 >
4899 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4900 > echo "$as_me: WARNING: compilation failed" >&2;}
4901 > fi
4902 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4903 >
4904 > fi
4905 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4906 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4907 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4908 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4909 > if test "${ac_cv_fc_libs+set}" = set; then
4910 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4911 > else
4912 >  if test "x$FCLIBS" != "x"; then
4913 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4914 > else
4915 >
4916 > cat >conftest.$ac_ext <<_ACEOF
4917 >      program main
4918 >
4919 >      end
4920 > _ACEOF
4921 >
4922 > # Compile and link our simple test program by passing a flag (argument
4923 > # 1 to this macro) to the Fortran compiler in order to get
4924 > # "verbose" output that we can then parse for the Fortran linker
4925 > # flags.
4926 > ac_save_FFLAGS=$FCFLAGS
4927 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4928 > (eval echo $as_me:4928: \"$ac_link\") >&5
4929 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4930 > echo "$ac_fc_v_output" >&5
4931 > FCFLAGS=$ac_save_FFLAGS
4932 >
4933 > rm -f conftest*
4934 >
4935 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4936 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4937 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4938 > ac_fc_v_output="`echo $ac_fc_v_output |
4939 >        grep 'LPATH is:' |
4940 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4941 >
4942 > case $ac_fc_v_output in
4943 >  # If we are using xlf then replace all the commas with spaces.
4944 >  *xlfentry*)
4945 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4946 >
4947 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4948 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4949 >  *mGLOB_options_string*)
4950 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4951 >
4952 >  # If we are using Cray Fortran then delete quotes.
4953 >  # Use "\"" instead of '"' for font-lock-mode.
4954 >  # FIXME: a more general fix for quoted arguments with spaces?
4955 >  *cft90*)
4956 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4957 > esac
4958 >
4959 >
4960 >
4961 > ac_cv_fc_libs=
4962 >
4963 > # Save positional arguments (if any)
4964 > ac_save_positional="$@"
4965 >
4966 > set X $ac_fc_v_output
4967 > while test $# != 1; do
4968 >  shift
4969 >  ac_arg=$1
4970 >  case $ac_arg in
4971 >        [\\/]*.a | ?:[\\/]*.a)
4972 >            ac_exists=false
4973 >  for ac_i in $ac_cv_fc_libs; do
4974 >    if test x"$ac_arg" = x"$ac_i"; then
4975 >      ac_exists=true
4976 >      break
4977 >    fi
4978 >  done
4979 >
4980 >  if test x"$ac_exists" = xtrue; then
4981 >  :
4982 > else
4983 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4984 > fi
4985 >
4986            ;;
4987 +        -bI:*)
4988 +            ac_exists=false
4989 +  for ac_i in $ac_cv_fc_libs; do
4990 +    if test x"$ac_arg" = x"$ac_i"; then
4991 +      ac_exists=true
4992 +      break
4993 +    fi
4994 +  done
4995 +
4996 +  if test x"$ac_exists" = xtrue; then
4997 +  :
4998 + else
4999 +  if test "$ac_compiler_gnu" = yes; then
5000 +  for ac_link_opt in $ac_arg; do
5001 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5002 +  done
5003 + else
5004 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5005 + fi
5006 + fi
5007 +
5008 +          ;;
5009 +          # Ignore these flags.
5010 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5011 +          ;;
5012 +        -lkernel32)
5013 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5014 +          ;;
5015 +        -[LRuY])
5016 +          # These flags, when seen by themselves, take an argument.
5017 +          # We remove the space between option and argument and re-iterate
5018 +          # unless we find an empty arg or a new option (starting with -)
5019 +          case $2 in
5020 +             "" | -*);;
5021 +             *)
5022 +                ac_arg="$ac_arg$2"
5023 +                shift; shift
5024 +                set X $ac_arg "$@"
5025 +                ;;
5026 +          esac
5027 +          ;;
5028 +        -YP,*)
5029 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5030 +              ac_exists=false
5031 +  for ac_i in $ac_cv_fc_libs; do
5032 +    if test x"$ac_j" = x"$ac_i"; then
5033 +      ac_exists=true
5034 +      break
5035 +    fi
5036 +  done
5037 +
5038 +  if test x"$ac_exists" = xtrue; then
5039 +  :
5040 + else
5041 +  ac_arg="$ac_arg $ac_j"
5042 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5043 + fi
5044 +
5045 +          done
5046 +          ;;
5047 +        -[lLR]*)
5048 +            ac_exists=false
5049 +  for ac_i in $ac_cv_fc_libs; do
5050 +    if test x"$ac_arg" = x"$ac_i"; then
5051 +      ac_exists=true
5052 +      break
5053 +    fi
5054 +  done
5055 +
5056 +  if test x"$ac_exists" = xtrue; then
5057 +  :
5058 + else
5059 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5060 + fi
5061 +
5062 +          ;;
5063 +          # Ignore everything else.
5064 +  esac
5065 + done
5066 + # restore positional arguments
5067 + set X $ac_save_positional; shift
5068 +
5069 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5070 + # then we insist that the "run path" must be an absolute path (i.e. it
5071 + # must begin with a "/").
5072 + case `(uname -sr) 2>/dev/null` in
5073 +   "SunOS 5"*)
5074 +      ac_ld_run_path=`echo $ac_fc_v_output |
5075 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5076 +      test "x$ac_ld_run_path" != x &&
5077 +        if test "$ac_compiler_gnu" = yes; then
5078 +  for ac_link_opt in $ac_ld_run_path; do
5079 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5080 +  done
5081 + else
5082 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5083 + fi
5084 +      ;;
5085   esac
5086 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5087 +
5088 + fi
5089 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5090 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5091 + FCLIBS="$ac_cv_fc_libs"
5092  
5093  
5094 + ac_ext=${FC_SRCEXT-f}
5095 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5096 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5097 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5098  
5099  
5100  
# Line 4078 | Line 5103 | cat >conftest.f90 <<EOF
5103   rm -f conftest*
5104   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5105   rm -f work*
5106 < cat >conftest.f90 <<EOF
5106 > cat >conftest.$ac_ext <<EOF
5107          module conftest
5108          integer n
5109          parameter (n=1)
# Line 4087 | Line 5112 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5112   # SGI and absoft compilers generates module name in upper case!
5113   testname="conftest"
5114   modcase="lower"
5115 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5116 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5115 > if (eval $ac_compile) 2>/dev/null ; then
5116 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5117      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5118      if test -z "$MOD" ; then
5119          MOD=`ls CONFTEST* 2>/dev/null \
5120 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5120 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5121          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5122          if test -n "$MOD" ; then
5123              testname="CONFTEST"
# Line 4132 | Line 5157 | cat >conftest.f90 <<EOF
5157   rm -f conftest*
5158   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5159   rm -f work*
5160 < cat >conftest.f90 <<EOF
5160 > cat >conftest.$ac_ext <<EOF
5161          module conftest
5162          integer n
5163          parameter (n=1)
# Line 4140 | Line 5165 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5165   EOF
5166   # SGI and absoft compilers generates module name in upper case!
5167   testname="conftest"
5168 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5169 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5168 > if (eval $ac_compile) 2>/dev/null ; then
5169 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5170     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5171     if test -n "$mod" ; then
5172        testname="CONFTEST"
# Line 4150 | Line 5175 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5175     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5176     cp $testname.$MOD conf
5177     rm -f conftest* CONFTEST*
5178 <   cat >conftest1.f90 <<EOF
5178 >   cat >conftest1.$ac_ext <<EOF
5179          program main
5180          use conftest
5181          print *, n
# Line 4158 | Line 5183 | EOF
5183   EOF
5184     F90_WORK_FILES_ARG=""
5185     F90MODINCSPEC=""
5186 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5186 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5187         MODDIRFLAG="-I"
5188         F90MODINCSPEC="-I<dir>"
5189         echo "$as_me:$LINENO: result: -I" >&5
5190   echo "${ECHO_T}-I" >&6
5191 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5191 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5192         MODDIRFLAG="-M"
5193         F90MODINCSPEC="-M<dir>"
5194         echo "$as_me:$LINENO: result: -M" >&5
5195   echo "${ECHO_T}-M" >&6
5196 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5196 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5197         MODDIRFLAG="-p"
5198         F90MODINCSPEC="-p<dir>"
5199         echo "$as_me:$LINENO: result: -p" >&5
# Line 4177 | Line 5202 | echo "${ECHO_T}-p" >&6
5202          cp work.pc conf/mpimod.pc
5203          echo "mpimod.pc" > conf/mpimod.pcl
5204          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5205 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5205 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5206              MODDIRFLAG='-cl,mpimod.pcl'
5207              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5208   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4202 | Line 5227 | ac_ext=c
5227   fi
5228  
5229  
5230 < ac_ext=c
5231 < ac_cpp='$CPP $CPPFLAGS'
5232 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4208 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4209 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4210 <
4211 <
4212 < ac_ext=c
4213 < ac_cpp='$CPP $CPPFLAGS'
4214 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4215 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4216 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4217 <
4218 < ac_ext=c
4219 < ac_cpp='$CPP $CPPFLAGS'
4220 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4221 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4222 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4223 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4224 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4225 < # On Suns, sometimes $CPP names a directory.
4226 < if test -n "$CPP" && test -d "$CPP"; then
4227 <  CPP=
4228 < fi
4229 < if test -z "$CPP"; then
4230 <  if test "${ac_cv_prog_CPP+set}" = set; then
5230 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5231 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5232 > if test "${ac_cv_f90_module_names+set}" = set; then
5233    echo $ECHO_N "(cached) $ECHO_C" >&6
5234   else
5235 <      # Double quotes because CPP needs to be expanded
5236 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5237 <    do
5238 <      ac_preproc_ok=false
5239 < for ac_c_preproc_warn_flag in '' yes
5240 < do
5241 <  # Use a header file that comes with gcc, so configuring glibc
5242 <  # with a fresh cross-compiler works.
5243 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5244 <  # <limits.h> exists even on freestanding compilers.
5245 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4244 <  # not just through cpp. "Syntax error" is here to catch this case.
4245 <  cat >conftest.$ac_ext <<_ACEOF
4246 < /* confdefs.h.  */
5235 >  ac_ext=${FC_SRCEXT-f}
5236 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5237 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5238 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5239 >
5240 > # carry out the test in a new directory, so that we don't miss anything
5241 > mkdir conftest
5242 > cd conftest
5243 > cat >conftest.$ac_ext <<_ACEOF
5244 > MODULE Bar
5245 > END MODULE Bar
5246   _ACEOF
5247 < cat confdefs.h >>conftest.$ac_ext
5248 < cat >>conftest.$ac_ext <<_ACEOF
5249 < /* end confdefs.h.  */
4251 < #ifdef __STDC__
4252 < # include <limits.h>
4253 < #else
4254 < # include <assert.h>
4255 < #endif
4256 <                     Syntax error
4257 < _ACEOF
4258 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4259 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5247 > rm -f conftest.$ac_objext
5248 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5249 >  (eval $ac_compile) 2>conftest.er1
5250    ac_status=$?
5251    grep -v '^ *+' conftest.er1 >conftest.err
5252    rm -f conftest.er1
5253    cat conftest.err >&5
5254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5255 <  (exit $ac_status); } >/dev/null; then
5256 <  if test -s conftest.err; then
5257 <    ac_cpp_err=$ac_c_preproc_warn_flag
5258 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5259 <  else
5260 <    ac_cpp_err=
5261 <  fi
5262 < else
5263 <  ac_cpp_err=yes
5264 < fi
5265 < if test -z "$ac_cpp_err"; then
5266 <  :
5267 < else
5268 <  echo "$as_me: failed program was:" >&5
5269 < sed 's/^/| /' conftest.$ac_ext >&5
5270 <
5271 <  # Broken: fails on valid input.
5272 < continue
5273 < fi
5274 < rm -f conftest.err conftest.$ac_ext
5275 <
5276 <  # OK, works on sane cases.  Now check whether non-existent headers
5277 <  # can be detected and how.
5278 <  cat >conftest.$ac_ext <<_ACEOF
5279 < /* confdefs.h.  */
5280 < _ACEOF
5281 < cat confdefs.h >>conftest.$ac_ext
5282 < cat >>conftest.$ac_ext <<_ACEOF
5283 < /* end confdefs.h.  */
5284 < #include <ac_nonexistent.h>
5285 < _ACEOF
5286 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5287 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5288 <  ac_status=$?
5289 <  grep -v '^ *+' conftest.er1 >conftest.err
5290 <  rm -f conftest.er1
5291 <  cat conftest.err >&5
5292 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5293 <  (exit $ac_status); } >/dev/null; then
5294 <  if test -s conftest.err; then
5295 <    ac_cpp_err=$ac_c_preproc_warn_flag
5296 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5297 <  else
5298 <    ac_cpp_err=
5299 <  fi
5300 < else
5301 <  ac_cpp_err=yes
5302 < fi
5303 < if test -z "$ac_cpp_err"; then
5304 <  # Broken: success on invalid input.
5305 < continue
5306 < else
5307 <  echo "$as_me: failed program was:" >&5
5308 < sed 's/^/| /' conftest.$ac_ext >&5
5309 <
5310 <  # Passes both tests.
5311 < ac_preproc_ok=:
5312 < break
5313 < fi
5314 < rm -f conftest.err conftest.$ac_ext
5315 <
5316 < done
5317 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5318 < rm -f conftest.err conftest.$ac_ext
5319 < if $ac_preproc_ok; then
5320 <  break
5321 < fi
5322 <
5323 <    done
5324 <    ac_cv_prog_CPP=$CPP
5325 <
5326 < fi
5327 <  CPP=$ac_cv_prog_CPP
5328 < else
5329 <  ac_cv_prog_CPP=$CPP
5330 < fi
5331 < echo "$as_me:$LINENO: result: $CPP" >&5
5332 < echo "${ECHO_T}$CPP" >&6
5333 < ac_preproc_ok=false
5334 < for ac_c_preproc_warn_flag in '' yes
5335 < do
5336 <  # Use a header file that comes with gcc, so configuring glibc
5337 <  # with a fresh cross-compiler works.
5338 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5339 <  # <limits.h> exists even on freestanding compilers.
5340 <  # On the NeXT, cc -E runs the code through the compiler's parser,
5341 <  # not just through cpp. "Syntax error" is here to catch this case.
5342 <  cat >conftest.$ac_ext <<_ACEOF
5343 < /* confdefs.h.  */
5344 < _ACEOF
5345 < cat confdefs.h >>conftest.$ac_ext
5346 < cat >>conftest.$ac_ext <<_ACEOF
5347 < /* end confdefs.h.  */
5348 < #ifdef __STDC__
5349 < # include <limits.h>
5350 < #else
5351 < # include <assert.h>
5352 < #endif
5353 <                     Syntax error
5354 < _ACEOF
5355 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5356 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5357 <  ac_status=$?
5358 <  grep -v '^ *+' conftest.er1 >conftest.err
5359 <  rm -f conftest.er1
5360 <  cat conftest.err >&5
5361 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5362 <  (exit $ac_status); } >/dev/null; then
5363 <  if test -s conftest.err; then
5364 <    ac_cpp_err=$ac_c_preproc_warn_flag
5365 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5366 <  else
5367 <    ac_cpp_err=
5368 <  fi
5369 < else
5370 <  ac_cpp_err=yes
5371 < fi
5372 < if test -z "$ac_cpp_err"; then
5373 <  :
5374 < else
5375 <  echo "$as_me: failed program was:" >&5
5376 < sed 's/^/| /' conftest.$ac_ext >&5
5377 <
5378 <  # Broken: fails on valid input.
5379 < continue
5380 < fi
5381 < rm -f conftest.err conftest.$ac_ext
5382 <
5383 <  # OK, works on sane cases.  Now check whether non-existent headers
5384 <  # can be detected and how.
5385 <  cat >conftest.$ac_ext <<_ACEOF
5386 < /* confdefs.h.  */
5387 < _ACEOF
5388 < cat confdefs.h >>conftest.$ac_ext
5389 < cat >>conftest.$ac_ext <<_ACEOF
5390 < /* end confdefs.h.  */
5391 < #include <ac_nonexistent.h>
5392 < _ACEOF
5393 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5394 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5395 <  ac_status=$?
5396 <  grep -v '^ *+' conftest.er1 >conftest.err
5397 <  rm -f conftest.er1
5398 <  cat conftest.err >&5
5399 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5400 <  (exit $ac_status); } >/dev/null; then
5401 <  if test -s conftest.err; then
5402 <    ac_cpp_err=$ac_c_preproc_warn_flag
5403 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5404 <  else
5405 <    ac_cpp_err=
5406 <  fi
5407 < else
5408 <  ac_cpp_err=yes
5409 < fi
5410 < if test -z "$ac_cpp_err"; then
5411 <  # Broken: success on invalid input.
5412 < continue
5413 < else
5414 <  echo "$as_me: failed program was:" >&5
5415 < sed 's/^/| /' conftest.$ac_ext >&5
5416 <
5417 <  # Passes both tests.
5418 < ac_preproc_ok=:
5419 < break
5420 < fi
5421 < rm -f conftest.err conftest.$ac_ext
5422 <
5423 < done
5424 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5425 < rm -f conftest.err conftest.$ac_ext
5426 < if $ac_preproc_ok; then
5427 <  :
5428 < else
5429 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5430 < See \`config.log' for more details." >&5
5431 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5432 < See \`config.log' for more details." >&2;}
5433 <   { (exit 1); exit 1; }; }
5434 < fi
5435 <
5436 < ac_ext=c
5437 < ac_cpp='$CPP $CPPFLAGS'
5438 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5439 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5440 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5441 <
5442 <
5443 < echo "$as_me:$LINENO: checking for egrep" >&5
5444 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5445 < if test "${ac_cv_prog_egrep+set}" = set; then
5446 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5447 < else
5448 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5449 <    then ac_cv_prog_egrep='grep -E'
5450 <    else ac_cv_prog_egrep='egrep'
5451 <    fi
5452 < fi
5453 < echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5454 < echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5455 < EGREP=$ac_cv_prog_egrep
5456 <
5457 <
5458 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5459 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5460 < if test "${ac_cv_header_stdc+set}" = set; then
5461 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5462 < else
5463 <  cat >conftest.$ac_ext <<_ACEOF
5464 < /* confdefs.h.  */
5465 < _ACEOF
5466 < cat confdefs.h >>conftest.$ac_ext
5467 < cat >>conftest.$ac_ext <<_ACEOF
5468 < /* end confdefs.h.  */
5469 < #include <stdlib.h>
5470 < #include <stdarg.h>
5471 < #include <string.h>
5472 < #include <float.h>
5473 <
5474 < int
5475 < main ()
5476 < {
5477 <
5478 <  ;
5479 <  return 0;
5480 < }
5481 < _ACEOF
5482 < rm -f conftest.$ac_objext
5483 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5484 <  (eval $ac_compile) 2>conftest.er1
5485 <  ac_status=$?
5486 <  grep -v '^ *+' conftest.er1 >conftest.err
5487 <  rm -f conftest.er1
5488 <  cat conftest.err >&5
5489 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5490 <  (exit $ac_status); } &&
5491 <         { ac_try='test -z "$ac_c_werror_flag"
5492 <                         || test ! -s conftest.err'
5493 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5494 <  (eval $ac_try) 2>&5
5495 <  ac_status=$?
5496 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5497 <  (exit $ac_status); }; } &&
5498 <         { ac_try='test -s conftest.$ac_objext'
5499 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5500 <  (eval $ac_try) 2>&5
5501 <  ac_status=$?
5502 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5503 <  (exit $ac_status); }; }; then
5504 <  ac_cv_header_stdc=yes
5505 < else
5506 <  echo "$as_me: failed program was:" >&5
5507 < sed 's/^/| /' conftest.$ac_ext >&5
5508 <
5509 < ac_cv_header_stdc=no
5510 < fi
5511 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5512 <
5513 < if test $ac_cv_header_stdc = yes; then
5514 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5515 <  cat >conftest.$ac_ext <<_ACEOF
5516 < /* confdefs.h.  */
5517 < _ACEOF
5518 < cat confdefs.h >>conftest.$ac_ext
5519 < cat >>conftest.$ac_ext <<_ACEOF
5520 < /* end confdefs.h.  */
5521 < #include <string.h>
5522 <
5523 < _ACEOF
5524 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5525 <  $EGREP "memchr" >/dev/null 2>&1; then
5526 <  :
5527 < else
5528 <  ac_cv_header_stdc=no
5529 < fi
5530 < rm -f conftest*
5531 <
5532 < fi
5533 <
5534 < if test $ac_cv_header_stdc = yes; then
5535 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5536 <  cat >conftest.$ac_ext <<_ACEOF
5537 < /* confdefs.h.  */
5538 < _ACEOF
5539 < cat confdefs.h >>conftest.$ac_ext
5540 < cat >>conftest.$ac_ext <<_ACEOF
5541 < /* end confdefs.h.  */
5542 < #include <stdlib.h>
5543 <
5544 < _ACEOF
5545 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5546 <  $EGREP "free" >/dev/null 2>&1; then
5547 <  :
5548 < else
5549 <  ac_cv_header_stdc=no
5550 < fi
5551 < rm -f conftest*
5552 <
5553 < fi
5554 <
5555 < if test $ac_cv_header_stdc = yes; then
5556 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5557 <  if test "$cross_compiling" = yes; then
5558 <  :
5559 < else
5560 <  cat >conftest.$ac_ext <<_ACEOF
5561 < /* confdefs.h.  */
5562 < _ACEOF
5563 < cat confdefs.h >>conftest.$ac_ext
5564 < cat >>conftest.$ac_ext <<_ACEOF
5565 < /* end confdefs.h.  */
5566 < #include <ctype.h>
5567 < #if ((' ' & 0x0FF) == 0x020)
5568 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5569 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5570 < #else
5571 < # define ISLOWER(c) \
5572 <                   (('a' <= (c) && (c) <= 'i') \
5573 <                     || ('j' <= (c) && (c) <= 'r') \
5574 <                     || ('s' <= (c) && (c) <= 'z'))
5575 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5576 < #endif
5577 <
5578 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5579 < int
5580 < main ()
5581 < {
5582 <  int i;
5583 <  for (i = 0; i < 256; i++)
5584 <    if (XOR (islower (i), ISLOWER (i))
5585 <        || toupper (i) != TOUPPER (i))
5586 <      exit(2);
5587 <  exit (0);
5588 < }
5589 < _ACEOF
5590 < rm -f conftest$ac_exeext
5591 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5592 <  (eval $ac_link) 2>&5
5593 <  ac_status=$?
5594 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5595 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5596 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5597 <  (eval $ac_try) 2>&5
5598 <  ac_status=$?
5599 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5600 <  (exit $ac_status); }; }; then
5601 <  :
5602 < else
5603 <  echo "$as_me: program exited with status $ac_status" >&5
5604 < echo "$as_me: failed program was:" >&5
5605 < sed 's/^/| /' conftest.$ac_ext >&5
5606 <
5607 < ( exit $ac_status )
5608 < ac_cv_header_stdc=no
5609 < fi
5610 < rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5611 < fi
5612 < fi
5613 < fi
5614 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5615 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
5616 < if test $ac_cv_header_stdc = yes; then
5617 <
5618 < cat >>confdefs.h <<\_ACEOF
5619 < #define STDC_HEADERS 1
5620 < _ACEOF
5621 <
5622 < fi
5623 <
5624 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5625 <
5626 <
5627 <
5628 <
5629 <
5630 <
5631 <
5632 <
5633 <
5634 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5635 <                  inttypes.h stdint.h unistd.h
5636 < do
5637 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5638 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5639 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5640 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5641 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5642 < else
5643 <  cat >conftest.$ac_ext <<_ACEOF
5644 < /* confdefs.h.  */
5645 < _ACEOF
5646 < cat confdefs.h >>conftest.$ac_ext
5647 < cat >>conftest.$ac_ext <<_ACEOF
5648 < /* end confdefs.h.  */
5649 < $ac_includes_default
5650 <
5651 < #include <$ac_header>
5652 < _ACEOF
5653 < rm -f conftest.$ac_objext
5654 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5655 <  (eval $ac_compile) 2>conftest.er1
5656 <  ac_status=$?
5657 <  grep -v '^ *+' conftest.er1 >conftest.err
5658 <  rm -f conftest.er1
5659 <  cat conftest.err >&5
5660 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5661 <  (exit $ac_status); } &&
5662 <         { ac_try='test -z "$ac_c_werror_flag"
5663 <                         || test ! -s conftest.err'
5664 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5665 <  (eval $ac_try) 2>&5
5666 <  ac_status=$?
5667 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5668 <  (exit $ac_status); }; } &&
5669 <         { ac_try='test -s conftest.$ac_objext'
5670 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5671 <  (eval $ac_try) 2>&5
5672 <  ac_status=$?
5673 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5674 <  (exit $ac_status); }; }; then
5675 <  eval "$as_ac_Header=yes"
5676 < else
5677 <  echo "$as_me: failed program was:" >&5
5678 < sed 's/^/| /' conftest.$ac_ext >&5
5679 <
5680 < eval "$as_ac_Header=no"
5681 < fi
5682 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5683 < fi
5684 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5685 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5686 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5687 <  cat >>confdefs.h <<_ACEOF
5688 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5689 < _ACEOF
5690 <
5691 < fi
5692 <
5693 < done
5694 <
5695 <
5696 <  # clean out junk possibly left behind by a previous configuration
5697 <  rm -f utils/getopt.h
5698 <  # Check for getopt_long support
5699 <
5700 < for ac_header in getopt.h
5701 < do
5702 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5703 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5704 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5705 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5706 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5707 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5708 < fi
5709 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5710 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5711 < else
5712 <  # Is the header compilable?
5713 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5714 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5715 < cat >conftest.$ac_ext <<_ACEOF
5716 < /* confdefs.h.  */
5717 < _ACEOF
5718 < cat confdefs.h >>conftest.$ac_ext
5719 < cat >>conftest.$ac_ext <<_ACEOF
5720 < /* end confdefs.h.  */
5721 < $ac_includes_default
5722 < #include <$ac_header>
5723 < _ACEOF
5724 < rm -f conftest.$ac_objext
5725 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5726 <  (eval $ac_compile) 2>conftest.er1
5727 <  ac_status=$?
5728 <  grep -v '^ *+' conftest.er1 >conftest.err
5729 <  rm -f conftest.er1
5730 <  cat conftest.err >&5
5731 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732 <  (exit $ac_status); } &&
5733 <         { ac_try='test -z "$ac_c_werror_flag"
5734 <                         || test ! -s conftest.err'
5735 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5736 <  (eval $ac_try) 2>&5
5737 <  ac_status=$?
5738 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5739 <  (exit $ac_status); }; } &&
5740 <         { ac_try='test -s conftest.$ac_objext'
5741 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5742 <  (eval $ac_try) 2>&5
5743 <  ac_status=$?
5744 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5745 <  (exit $ac_status); }; }; then
5746 <  ac_header_compiler=yes
5747 < else
5748 <  echo "$as_me: failed program was:" >&5
5749 < sed 's/^/| /' conftest.$ac_ext >&5
5750 <
5751 < ac_header_compiler=no
5752 < fi
5753 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5754 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5755 < echo "${ECHO_T}$ac_header_compiler" >&6
5756 <
5757 < # Is the header present?
5758 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
5759 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5760 < cat >conftest.$ac_ext <<_ACEOF
5761 < /* confdefs.h.  */
5762 < _ACEOF
5763 < cat confdefs.h >>conftest.$ac_ext
5764 < cat >>conftest.$ac_ext <<_ACEOF
5765 < /* end confdefs.h.  */
5766 < #include <$ac_header>
5767 < _ACEOF
5768 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5769 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5770 <  ac_status=$?
5771 <  grep -v '^ *+' conftest.er1 >conftest.err
5772 <  rm -f conftest.er1
5773 <  cat conftest.err >&5
5774 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5775 <  (exit $ac_status); } >/dev/null; then
5776 <  if test -s conftest.err; then
5777 <    ac_cpp_err=$ac_c_preproc_warn_flag
5778 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5779 <  else
5780 <    ac_cpp_err=
5781 <  fi
5782 < else
5783 <  ac_cpp_err=yes
5784 < fi
5785 < if test -z "$ac_cpp_err"; then
5786 <  ac_header_preproc=yes
5787 < else
5788 <  echo "$as_me: failed program was:" >&5
5789 < sed 's/^/| /' conftest.$ac_ext >&5
5790 <
5791 <  ac_header_preproc=no
5792 < fi
5793 < rm -f conftest.err conftest.$ac_ext
5794 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5795 < echo "${ECHO_T}$ac_header_preproc" >&6
5796 <
5797 < # So?  What about this header?
5798 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5799 <  yes:no: )
5800 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5801 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5802 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5803 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5804 <    ac_header_preproc=yes
5805 <    ;;
5806 <  no:yes:* )
5807 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5808 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5809 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5810 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5811 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5812 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5813 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5814 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5815 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5816 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5817 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5818 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5819 <    (
5820 <      cat <<\_ASBOX
5821 < ## ------------------------------ ##
5822 < ## Report this to gezelter@nd.edu ##
5823 < ## ------------------------------ ##
5824 < _ASBOX
5825 <    ) |
5826 <      sed "s/^/$as_me: WARNING:     /" >&2
5827 <    ;;
5828 < esac
5829 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5830 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5831 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5832 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5833 < else
5834 <  eval "$as_ac_Header=\$ac_header_preproc"
5835 < fi
5836 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5837 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5838 <
5839 < fi
5840 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5841 <  cat >>confdefs.h <<_ACEOF
5842 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5843 < _ACEOF
5844 <
5845 < fi
5846 <
5847 < done
5848 <
5849 <
5850 < for ac_func in getopt_long
5851 < do
5852 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5853 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5854 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5855 < if eval "test \"\${$as_ac_var+set}\" = set"; then
5856 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5857 < else
5858 <  cat >conftest.$ac_ext <<_ACEOF
5859 < /* confdefs.h.  */
5860 < _ACEOF
5861 < cat confdefs.h >>conftest.$ac_ext
5862 < cat >>conftest.$ac_ext <<_ACEOF
5863 < /* end confdefs.h.  */
5864 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5865 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5866 < #define $ac_func innocuous_$ac_func
5867 <
5868 < /* System header to define __stub macros and hopefully few prototypes,
5869 <    which can conflict with char $ac_func (); below.
5870 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5871 <    <limits.h> exists even on freestanding compilers.  */
5872 <
5873 < #ifdef __STDC__
5874 < # include <limits.h>
5875 < #else
5876 < # include <assert.h>
5877 < #endif
5878 <
5879 < #undef $ac_func
5880 <
5881 < /* Override any gcc2 internal prototype to avoid an error.  */
5882 < #ifdef __cplusplus
5883 < extern "C"
5884 < {
5885 < #endif
5886 < /* We use char because int might match the return type of a gcc2
5887 <   builtin and then its argument prototype would still apply.  */
5888 < char $ac_func ();
5889 < /* The GNU C library defines this for functions which it implements
5890 <    to always fail with ENOSYS.  Some functions are actually named
5891 <    something starting with __ and the normal name is an alias.  */
5892 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5893 < choke me
5894 < #else
5895 < char (*f) () = $ac_func;
5255 >  (exit $ac_status); } &&
5256 >         { ac_try='test -z "$ac_fc_werror_flag"
5257 >                         || test ! -s conftest.err'
5258 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5259 >  (eval $ac_try) 2>&5
5260 >  ac_status=$?
5261 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5262 >  (exit $ac_status); }; } &&
5263 >         { ac_try='test -s conftest.$ac_objext'
5264 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5265 >  (eval $ac_try) 2>&5
5266 >  ac_status=$?
5267 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5268 >  (exit $ac_status); }; }; then
5269 >  ac_cv_f90_module_names=
5270 > ac_file_list=*
5271 > for ac_file in $ac_file_list; do
5272 >   case $ac_file in
5273 >      # don't care for original source and object files
5274 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5275 >          :
5276 >          ;;
5277 >      # look for new files derived from the file name
5278 >      *conftest*)
5279 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5280 >            ac_exists=false
5281 >  for ac_i in $ac_cv_f90_module_names; do
5282 >    if test x"$ac_pat" = x"$ac_i"; then
5283 >      ac_exists=true
5284 >      break
5285 >    fi
5286 >  done
5287 >
5288 >  if test x"$ac_exists" = xtrue; then
5289 >  :
5290 > else
5291 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5292 > fi
5293 >
5294 >          ;;
5295 >      # look for new files derived from the module name,
5296 >      # with different case translation schemes
5297 >      *Bar*)
5298 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5299 >            ac_exists=false
5300 >  for ac_i in $ac_cv_f90_module_names; do
5301 >    if test x"$ac_pat" = x"$ac_i"; then
5302 >      ac_exists=true
5303 >      break
5304 >    fi
5305 >  done
5306 >
5307 >  if test x"$ac_exists" = xtrue; then
5308 >  :
5309 > else
5310 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5311 > fi
5312 >
5313 >          ;;
5314 >      *bar*)
5315 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5316 >            ac_exists=false
5317 >  for ac_i in $ac_cv_f90_module_names; do
5318 >    if test x"$ac_pat" = x"$ac_i"; then
5319 >      ac_exists=true
5320 >      break
5321 >    fi
5322 >  done
5323 >
5324 >  if test x"$ac_exists" = xtrue; then
5325 >  :
5326 > else
5327 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5328 > fi
5329 >
5330 >          ;;
5331 >      *BAR*)
5332 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5333 >            ac_exists=false
5334 >  for ac_i in $ac_cv_f90_module_names; do
5335 >    if test x"$ac_pat" = x"$ac_i"; then
5336 >      ac_exists=true
5337 >      break
5338 >    fi
5339 >  done
5340 >
5341 >  if test x"$ac_exists" = xtrue; then
5342 >  :
5343 > else
5344 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5345 > fi
5346 >
5347 >          ;;
5348 >       # Other files - we have no idea how they are generated
5349 >       *)
5350 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5351 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5352 >          ;;
5353 >   esac
5354 > done
5355 > if test "x$ac_cv_f90_module_names" = "x"; then
5356 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5357 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5358 > fi
5359 >
5360 > else
5361 >  echo "$as_me: failed program was:" >&5
5362 > sed 's/^/| /' conftest.$ac_ext >&5
5363 >
5364 > ac_cv_f90_module_names=
5365 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5366 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5367 > fi
5368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5369 > cd ..
5370 > # cleanup
5371 > rm -rf conftest
5372 > ac_ext=${FC_SRCEXT-f}
5373 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5374 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5375 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5376 >
5377 > fi
5378 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5379 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5380 >
5381 > # We now generate a shell script that will help us to figure out the correct
5382 > # module file names, using the value of ac_cv_f90_module_names
5383 >
5384 > echo "Generating shell script modnam"
5385 >
5386 > cat > scripts/modnam << EOF
5387 > #! /bin/sh
5388 > # This script is auto-generated by configure
5389 > #
5390 > usage="\\
5391 > Usage: \$0 [FILES]
5392 >
5393 > [FILES] are Fortran 90 source files.
5394 > The output is a list of module file names that the Fortran 90 compiler
5395 > generates when compiling [FILES]."
5396 >
5397 > list=
5398 > empty=
5399 >
5400 > if test \$# -eq 0; then
5401 >   echo "\$usage"; exit 0
5402 > fi
5403 >
5404 > while test \$# != 0; do
5405 >
5406 >  file=\$1
5407 >  shift
5408 >
5409 > # strip suffix
5410 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5411 >
5412 >  test ! -f \$file && continue
5413 >
5414 > # Look for module definitions and transform them to upper / lower case
5415 >  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/'\`
5416 >  upper=\`echo \$mods | tr a-z A-Z\`
5417 >  lower=\`echo \$mods | tr A-Z a-z\`
5418 >
5419 > # Here, the patterns for generating module file names were inserted by configure
5420 >  for trans in $ac_cv_f90_module_names; do
5421 >
5422 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5423 >    var=empty
5424 >    case \$pat in
5425 >       %MODULE%)
5426 >          var=upper ;;
5427 >       %Module%)
5428 >          var=mods ;;
5429 >       %module%)
5430 >          var=lower ;;
5431 >       %FILE%)
5432 >          test -n "\$mods" && var=base ;;
5433 >    esac
5434 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5435 >    list="\$list \$new"
5436 >  done
5437 > done
5438 >
5439 > echo \$list
5440 > # end of configure-generated script
5441 > EOF
5442 > chmod 755 scripts/modnam
5443 >
5444 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5445 > F90_MODULE_NAMES=empty
5446 > case $pat in
5447 >       %MODULE%)
5448 >          F90_MODULE_NAMES=UPPER ;;
5449 >       %Module%)
5450 >          F90_MODULE_NAMES=Mixed ;;
5451 >       %module%)
5452 >          F90_MODULE_NAMES=lower ;;
5453 >       *)
5454 >          F90_MODULE_NAMES=unknown ;;
5455 > esac
5456 >
5457 > ac_ext=c
5458 > ac_cpp='$CPP $CPPFLAGS'
5459 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5460 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5461 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5462 >
5463 >
5464 > ac_ext=c
5465 > ac_cpp='$CPP $CPPFLAGS'
5466 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5467 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5468 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5469 >
5470 >
5471 >
5472 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5473 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5474 > if test "${ac_cv_lib_m_asin+set}" = set; then
5475 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5476 > else
5477 >  ac_check_lib_save_LIBS=$LIBS
5478 > LIBS="-lm  $LIBS"
5479 > cat >conftest.$ac_ext <<_ACEOF
5480 > /* confdefs.h.  */
5481 > _ACEOF
5482 > cat confdefs.h >>conftest.$ac_ext
5483 > cat >>conftest.$ac_ext <<_ACEOF
5484 > /* end confdefs.h.  */
5485 >
5486 > /* Override any gcc2 internal prototype to avoid an error.  */
5487 > #ifdef __cplusplus
5488 > extern "C"
5489 > #endif
5490 > /* We use char because int might match the return type of a gcc2
5491 >   builtin and then its argument prototype would still apply.  */
5492 > char asin ();
5493 > #ifdef FC_DUMMY_MAIN
5494 > #ifndef FC_DUMMY_MAIN_EQ_F77
5495 > #  ifdef __cplusplus
5496 >     extern "C"
5497 > #  endif
5498 >   int FC_DUMMY_MAIN() { return 1; }
5499 > #endif
5500 > #endif
5501 > int
5502 > main ()
5503 > {
5504 > asin ();
5505 >  ;
5506 >  return 0;
5507 > }
5508 > _ACEOF
5509 > rm -f conftest.$ac_objext conftest$ac_exeext
5510 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5511 >  (eval $ac_link) 2>conftest.er1
5512 >  ac_status=$?
5513 >  grep -v '^ *+' conftest.er1 >conftest.err
5514 >  rm -f conftest.er1
5515 >  cat conftest.err >&5
5516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5517 >  (exit $ac_status); } &&
5518 >         { ac_try='test -z "$ac_c_werror_flag"
5519 >                         || test ! -s conftest.err'
5520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5521 >  (eval $ac_try) 2>&5
5522 >  ac_status=$?
5523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5524 >  (exit $ac_status); }; } &&
5525 >         { ac_try='test -s conftest$ac_exeext'
5526 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5527 >  (eval $ac_try) 2>&5
5528 >  ac_status=$?
5529 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5530 >  (exit $ac_status); }; }; then
5531 >  ac_cv_lib_m_asin=yes
5532 > else
5533 >  echo "$as_me: failed program was:" >&5
5534 > sed 's/^/| /' conftest.$ac_ext >&5
5535 >
5536 > ac_cv_lib_m_asin=no
5537 > fi
5538 > rm -f conftest.err conftest.$ac_objext \
5539 >      conftest$ac_exeext conftest.$ac_ext
5540 > LIBS=$ac_check_lib_save_LIBS
5541 > fi
5542 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5543 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5544 > if test $ac_cv_lib_m_asin = yes; then
5545 >  cat >>confdefs.h <<_ACEOF
5546 > #define HAVE_LIBM 1
5547 > _ACEOF
5548 >
5549 >  LIBS="-lm $LIBS"
5550 >
5551 > else
5552 >  exit
5553 > fi
5554 >
5555 >
5556 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5557 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5558 > if test "${ac_cv_header_stdc+set}" = set; then
5559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5560 > else
5561 >  cat >conftest.$ac_ext <<_ACEOF
5562 > /* confdefs.h.  */
5563 > _ACEOF
5564 > cat confdefs.h >>conftest.$ac_ext
5565 > cat >>conftest.$ac_ext <<_ACEOF
5566 > /* end confdefs.h.  */
5567 > #include <stdlib.h>
5568 > #include <stdarg.h>
5569 > #include <string.h>
5570 > #include <float.h>
5571 >
5572 > #ifdef FC_DUMMY_MAIN
5573 > #ifndef FC_DUMMY_MAIN_EQ_F77
5574 > #  ifdef __cplusplus
5575 >     extern "C"
5576 > #  endif
5577 >   int FC_DUMMY_MAIN() { return 1; }
5578 > #endif
5579 > #endif
5580 > int
5581 > main ()
5582 > {
5583 >
5584 >  ;
5585 >  return 0;
5586 > }
5587 > _ACEOF
5588 > rm -f conftest.$ac_objext
5589 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5590 >  (eval $ac_compile) 2>conftest.er1
5591 >  ac_status=$?
5592 >  grep -v '^ *+' conftest.er1 >conftest.err
5593 >  rm -f conftest.er1
5594 >  cat conftest.err >&5
5595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5596 >  (exit $ac_status); } &&
5597 >         { ac_try='test -z "$ac_c_werror_flag"
5598 >                         || test ! -s conftest.err'
5599 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5600 >  (eval $ac_try) 2>&5
5601 >  ac_status=$?
5602 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603 >  (exit $ac_status); }; } &&
5604 >         { ac_try='test -s conftest.$ac_objext'
5605 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5606 >  (eval $ac_try) 2>&5
5607 >  ac_status=$?
5608 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5609 >  (exit $ac_status); }; }; then
5610 >  ac_cv_header_stdc=yes
5611 > else
5612 >  echo "$as_me: failed program was:" >&5
5613 > sed 's/^/| /' conftest.$ac_ext >&5
5614 >
5615 > ac_cv_header_stdc=no
5616 > fi
5617 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5618 >
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5621 >  cat >conftest.$ac_ext <<_ACEOF
5622 > /* confdefs.h.  */
5623 > _ACEOF
5624 > cat confdefs.h >>conftest.$ac_ext
5625 > cat >>conftest.$ac_ext <<_ACEOF
5626 > /* end confdefs.h.  */
5627 > #include <string.h>
5628 >
5629 > _ACEOF
5630 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5631 >  $EGREP "memchr" >/dev/null 2>&1; then
5632 >  :
5633 > else
5634 >  ac_cv_header_stdc=no
5635 > fi
5636 > rm -f conftest*
5637 >
5638 > fi
5639 >
5640 > if test $ac_cv_header_stdc = yes; then
5641 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5642 >  cat >conftest.$ac_ext <<_ACEOF
5643 > /* confdefs.h.  */
5644 > _ACEOF
5645 > cat confdefs.h >>conftest.$ac_ext
5646 > cat >>conftest.$ac_ext <<_ACEOF
5647 > /* end confdefs.h.  */
5648 > #include <stdlib.h>
5649 >
5650 > _ACEOF
5651 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5652 >  $EGREP "free" >/dev/null 2>&1; then
5653 >  :
5654 > else
5655 >  ac_cv_header_stdc=no
5656 > fi
5657 > rm -f conftest*
5658 >
5659 > fi
5660 >
5661 > if test $ac_cv_header_stdc = yes; then
5662 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5663 >  if test "$cross_compiling" = yes; then
5664 >  :
5665 > else
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 <ctype.h>
5673 > #if ((' ' & 0x0FF) == 0x020)
5674 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5675 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5676 > #else
5677 > # define ISLOWER(c) \
5678 >                   (('a' <= (c) && (c) <= 'i') \
5679 >                     || ('j' <= (c) && (c) <= 'r') \
5680 >                     || ('s' <= (c) && (c) <= 'z'))
5681 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5682 > #endif
5683 >
5684 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5685 > int
5686 > main ()
5687 > {
5688 >  int i;
5689 >  for (i = 0; i < 256; i++)
5690 >    if (XOR (islower (i), ISLOWER (i))
5691 >        || toupper (i) != TOUPPER (i))
5692 >      exit(2);
5693 >  exit (0);
5694 > }
5695 > _ACEOF
5696 > rm -f conftest$ac_exeext
5697 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5698 >  (eval $ac_link) 2>&5
5699 >  ac_status=$?
5700 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5701 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5702 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5703 >  (eval $ac_try) 2>&5
5704 >  ac_status=$?
5705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5706 >  (exit $ac_status); }; }; then
5707 >  :
5708 > else
5709 >  echo "$as_me: program exited with status $ac_status" >&5
5710 > echo "$as_me: failed program was:" >&5
5711 > sed 's/^/| /' conftest.$ac_ext >&5
5712 >
5713 > ( exit $ac_status )
5714 > ac_cv_header_stdc=no
5715 > fi
5716 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5717 > fi
5718 > fi
5719 > fi
5720 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5721 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5722 > if test $ac_cv_header_stdc = yes; then
5723 >
5724 > cat >>confdefs.h <<\_ACEOF
5725 > #define STDC_HEADERS 1
5726 > _ACEOF
5727 >
5728 > fi
5729 >
5730 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5731 >
5732 >
5733 >
5734 >
5735 >
5736 >
5737 >
5738 >
5739 >
5740 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5741 >                  inttypes.h stdint.h unistd.h
5742 > do
5743 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5744 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5745 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5746 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5747 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5748 > else
5749 >  cat >conftest.$ac_ext <<_ACEOF
5750 > /* confdefs.h.  */
5751 > _ACEOF
5752 > cat confdefs.h >>conftest.$ac_ext
5753 > cat >>conftest.$ac_ext <<_ACEOF
5754 > /* end confdefs.h.  */
5755 > $ac_includes_default
5756 >
5757 > #include <$ac_header>
5758 > _ACEOF
5759 > rm -f conftest.$ac_objext
5760 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5761 >  (eval $ac_compile) 2>conftest.er1
5762 >  ac_status=$?
5763 >  grep -v '^ *+' conftest.er1 >conftest.err
5764 >  rm -f conftest.er1
5765 >  cat conftest.err >&5
5766 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5767 >  (exit $ac_status); } &&
5768 >         { ac_try='test -z "$ac_c_werror_flag"
5769 >                         || test ! -s conftest.err'
5770 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5771 >  (eval $ac_try) 2>&5
5772 >  ac_status=$?
5773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5774 >  (exit $ac_status); }; } &&
5775 >         { ac_try='test -s conftest.$ac_objext'
5776 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5777 >  (eval $ac_try) 2>&5
5778 >  ac_status=$?
5779 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5780 >  (exit $ac_status); }; }; then
5781 >  eval "$as_ac_Header=yes"
5782 > else
5783 >  echo "$as_me: failed program was:" >&5
5784 > sed 's/^/| /' conftest.$ac_ext >&5
5785 >
5786 > eval "$as_ac_Header=no"
5787 > fi
5788 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5789 > fi
5790 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5791 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5792 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5793 >  cat >>confdefs.h <<_ACEOF
5794 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5795 > _ACEOF
5796 >
5797 > fi
5798 >
5799 > done
5800 >
5801 >
5802 > #
5803 > # Handle user hints
5804 > #
5805 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5806 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5807 >
5808 > # Check whether --with-zlib or --without-zlib was given.
5809 > if test "${with_zlib+set}" = set; then
5810 >  withval="$with_zlib"
5811 >  if test "$withval" != no ; then
5812 >  echo "$as_me:$LINENO: result: yes" >&5
5813 > echo "${ECHO_T}yes" >&6
5814 >  if test -d "$withval"
5815 >  then
5816 >    ZLIB_HOME="$withval"
5817 >  else
5818 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5819 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5820 >  fi
5821 > else
5822 >  echo "$as_me:$LINENO: result: no" >&5
5823 > echo "${ECHO_T}no" >&6
5824 > fi
5825 > fi;
5826 >
5827 > ZLIB_HOME=/usr/local
5828 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5829 > then
5830 >        ZLIB_HOME=/usr
5831 > fi
5832 >
5833 > #
5834 > # Locate zlib, if wanted
5835 > #
5836 > if test -n "${ZLIB_HOME}"
5837 > then
5838 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5839 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5840 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5841 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5842 >
5843 >
5844 >        ac_ext=c
5845 > ac_cpp='$CPP $CPPFLAGS'
5846 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5847 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5848 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5849 >
5850 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5851 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5852 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5853 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5854 > else
5855 >  ac_check_lib_save_LIBS=$LIBS
5856 > LIBS="-lz  $LIBS"
5857 > cat >conftest.$ac_ext <<_ACEOF
5858 > /* confdefs.h.  */
5859 > _ACEOF
5860 > cat confdefs.h >>conftest.$ac_ext
5861 > cat >>conftest.$ac_ext <<_ACEOF
5862 > /* end confdefs.h.  */
5863 >
5864 > /* Override any gcc2 internal prototype to avoid an error.  */
5865 > #ifdef __cplusplus
5866 > extern "C"
5867 > #endif
5868 > /* We use char because int might match the return type of a gcc2
5869 >   builtin and then its argument prototype would still apply.  */
5870 > char inflateEnd ();
5871 > #ifdef FC_DUMMY_MAIN
5872 > #ifndef FC_DUMMY_MAIN_EQ_F77
5873 > #  ifdef __cplusplus
5874 >     extern "C"
5875 > #  endif
5876 >   int FC_DUMMY_MAIN() { return 1; }
5877 > #endif
5878 > #endif
5879 > int
5880 > main ()
5881 > {
5882 > inflateEnd ();
5883 >  ;
5884 >  return 0;
5885 > }
5886 > _ACEOF
5887 > rm -f conftest.$ac_objext conftest$ac_exeext
5888 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5889 >  (eval $ac_link) 2>conftest.er1
5890 >  ac_status=$?
5891 >  grep -v '^ *+' conftest.er1 >conftest.err
5892 >  rm -f conftest.er1
5893 >  cat conftest.err >&5
5894 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5895 >  (exit $ac_status); } &&
5896 >         { ac_try='test -z "$ac_c_werror_flag"
5897 >                         || test ! -s conftest.err'
5898 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5899 >  (eval $ac_try) 2>&5
5900 >  ac_status=$?
5901 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5902 >  (exit $ac_status); }; } &&
5903 >         { ac_try='test -s conftest$ac_exeext'
5904 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5905 >  (eval $ac_try) 2>&5
5906 >  ac_status=$?
5907 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5908 >  (exit $ac_status); }; }; then
5909 >  ac_cv_lib_z_inflateEnd=yes
5910 > else
5911 >  echo "$as_me: failed program was:" >&5
5912 > sed 's/^/| /' conftest.$ac_ext >&5
5913 >
5914 > ac_cv_lib_z_inflateEnd=no
5915 > fi
5916 > rm -f conftest.err conftest.$ac_objext \
5917 >      conftest$ac_exeext conftest.$ac_ext
5918 > LIBS=$ac_check_lib_save_LIBS
5919 > fi
5920 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5921 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5922 > if test $ac_cv_lib_z_inflateEnd = yes; then
5923 >  zlib_cv_libz=yes
5924 > else
5925 >  zlib_cv_libz=no
5926 > fi
5927 >
5928 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5929 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5930 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5931 > if test "${ac_cv_header_zlib_h+set}" = set; then
5932 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5933 > fi
5934 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5935 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5936 > else
5937 >  # Is the header compilable?
5938 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5939 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5940 > cat >conftest.$ac_ext <<_ACEOF
5941 > /* confdefs.h.  */
5942 > _ACEOF
5943 > cat confdefs.h >>conftest.$ac_ext
5944 > cat >>conftest.$ac_ext <<_ACEOF
5945 > /* end confdefs.h.  */
5946 > $ac_includes_default
5947 > #include <zlib.h>
5948 > _ACEOF
5949 > rm -f conftest.$ac_objext
5950 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5951 >  (eval $ac_compile) 2>conftest.er1
5952 >  ac_status=$?
5953 >  grep -v '^ *+' conftest.er1 >conftest.err
5954 >  rm -f conftest.er1
5955 >  cat conftest.err >&5
5956 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5957 >  (exit $ac_status); } &&
5958 >         { ac_try='test -z "$ac_c_werror_flag"
5959 >                         || test ! -s conftest.err'
5960 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5961 >  (eval $ac_try) 2>&5
5962 >  ac_status=$?
5963 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5964 >  (exit $ac_status); }; } &&
5965 >         { ac_try='test -s conftest.$ac_objext'
5966 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5967 >  (eval $ac_try) 2>&5
5968 >  ac_status=$?
5969 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5970 >  (exit $ac_status); }; }; then
5971 >  ac_header_compiler=yes
5972 > else
5973 >  echo "$as_me: failed program was:" >&5
5974 > sed 's/^/| /' conftest.$ac_ext >&5
5975 >
5976 > ac_header_compiler=no
5977 > fi
5978 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5979 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5980 > echo "${ECHO_T}$ac_header_compiler" >&6
5981 >
5982 > # Is the header present?
5983 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5984 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5985 > cat >conftest.$ac_ext <<_ACEOF
5986 > /* confdefs.h.  */
5987 > _ACEOF
5988 > cat confdefs.h >>conftest.$ac_ext
5989 > cat >>conftest.$ac_ext <<_ACEOF
5990 > /* end confdefs.h.  */
5991 > #include <zlib.h>
5992 > _ACEOF
5993 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5994 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5995 >  ac_status=$?
5996 >  grep -v '^ *+' conftest.er1 >conftest.err
5997 >  rm -f conftest.er1
5998 >  cat conftest.err >&5
5999 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6000 >  (exit $ac_status); } >/dev/null; then
6001 >  if test -s conftest.err; then
6002 >    ac_cpp_err=$ac_c_preproc_warn_flag
6003 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6004 >  else
6005 >    ac_cpp_err=
6006 >  fi
6007 > else
6008 >  ac_cpp_err=yes
6009 > fi
6010 > if test -z "$ac_cpp_err"; then
6011 >  ac_header_preproc=yes
6012 > else
6013 >  echo "$as_me: failed program was:" >&5
6014 > sed 's/^/| /' conftest.$ac_ext >&5
6015 >
6016 >  ac_header_preproc=no
6017 > fi
6018 > rm -f conftest.err conftest.$ac_ext
6019 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6020 > echo "${ECHO_T}$ac_header_preproc" >&6
6021 >
6022 > # So?  What about this header?
6023 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6024 >  yes:no: )
6025 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6026 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6027 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6028 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6029 >    ac_header_preproc=yes
6030 >    ;;
6031 >  no:yes:* )
6032 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6033 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6034 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6035 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6036 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6037 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6038 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6039 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6040 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6041 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6042 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6043 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6044 >    (
6045 >      cat <<\_ASBOX
6046 > ## ------------------------------ ##
6047 > ## Report this to gezelter@nd.edu ##
6048 > ## ------------------------------ ##
6049 > _ASBOX
6050 >    ) |
6051 >      sed "s/^/$as_me: WARNING:     /" >&2
6052 >    ;;
6053 > esac
6054 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6055 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6056 > if test "${ac_cv_header_zlib_h+set}" = set; then
6057 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6058 > else
6059 >  ac_cv_header_zlib_h=$ac_header_preproc
6060 > fi
6061 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6062 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6063 >
6064 > fi
6065 > if test $ac_cv_header_zlib_h = yes; then
6066 >  zlib_cv_zlib_h=yes
6067 > else
6068 >  zlib_cv_zlib_h=no
6069 > fi
6070 >
6071 >
6072 >        ac_ext=c
6073 > ac_cpp='$CPP $CPPFLAGS'
6074 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6075 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6076 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6077 >
6078 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6079 >        then
6080 >                #
6081 >                # If both library and header were found, use them
6082 >                #
6083 >
6084 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6085 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6086 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6087 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6088 > else
6089 >  ac_check_lib_save_LIBS=$LIBS
6090 > LIBS="-lz  $LIBS"
6091 > cat >conftest.$ac_ext <<_ACEOF
6092 > /* confdefs.h.  */
6093 > _ACEOF
6094 > cat confdefs.h >>conftest.$ac_ext
6095 > cat >>conftest.$ac_ext <<_ACEOF
6096 > /* end confdefs.h.  */
6097 >
6098 > /* Override any gcc2 internal prototype to avoid an error.  */
6099 > #ifdef __cplusplus
6100 > extern "C"
6101 > #endif
6102 > /* We use char because int might match the return type of a gcc2
6103 >   builtin and then its argument prototype would still apply.  */
6104 > char inflateEnd ();
6105 > #ifdef FC_DUMMY_MAIN
6106 > #ifndef FC_DUMMY_MAIN_EQ_F77
6107 > #  ifdef __cplusplus
6108 >     extern "C"
6109 > #  endif
6110 >   int FC_DUMMY_MAIN() { return 1; }
6111 > #endif
6112 > #endif
6113 > int
6114 > main ()
6115 > {
6116 > inflateEnd ();
6117 >  ;
6118 >  return 0;
6119 > }
6120 > _ACEOF
6121 > rm -f conftest.$ac_objext conftest$ac_exeext
6122 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6123 >  (eval $ac_link) 2>conftest.er1
6124 >  ac_status=$?
6125 >  grep -v '^ *+' conftest.er1 >conftest.err
6126 >  rm -f conftest.er1
6127 >  cat conftest.err >&5
6128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6129 >  (exit $ac_status); } &&
6130 >         { ac_try='test -z "$ac_c_werror_flag"
6131 >                         || test ! -s conftest.err'
6132 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6133 >  (eval $ac_try) 2>&5
6134 >  ac_status=$?
6135 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6136 >  (exit $ac_status); }; } &&
6137 >         { ac_try='test -s conftest$ac_exeext'
6138 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6139 >  (eval $ac_try) 2>&5
6140 >  ac_status=$?
6141 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6142 >  (exit $ac_status); }; }; then
6143 >  ac_cv_lib_z_inflateEnd=yes
6144 > else
6145 >  echo "$as_me: failed program was:" >&5
6146 > sed 's/^/| /' conftest.$ac_ext >&5
6147 >
6148 > ac_cv_lib_z_inflateEnd=no
6149 > fi
6150 > rm -f conftest.err conftest.$ac_objext \
6151 >      conftest$ac_exeext conftest.$ac_ext
6152 > LIBS=$ac_check_lib_save_LIBS
6153 > fi
6154 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6155 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6156 > if test $ac_cv_lib_z_inflateEnd = yes; then
6157 >  cat >>confdefs.h <<_ACEOF
6158 > #define HAVE_LIBZ 1
6159 > _ACEOF
6160 >
6161 >  LIBS="-lz $LIBS"
6162 >
6163 > fi
6164 >
6165 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6166 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6167 >                echo "$as_me:$LINENO: result: ok" >&5
6168 > echo "${ECHO_T}ok" >&6
6169 >        else
6170 >                #
6171 >                # If either header or library was not found, revert and bomb
6172 >                #
6173 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6174 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6175 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6176 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6177 >                echo "$as_me:$LINENO: result: failed" >&5
6178 > echo "${ECHO_T}failed" >&6
6179 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6180 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6181 >   { (exit 1); exit 1; }; }
6182 >        fi
6183 > fi
6184 >
6185 >
6186 > #
6187 > # Handle user hints
6188 > #
6189 >
6190 > # Check whether --with-fftw or --without-fftw was given.
6191 > if test "${with_fftw+set}" = set; then
6192 >  withval="$with_fftw"
6193 >  fftw_dir="$withval"
6194 > else
6195 >                fftw_dir="not_set"
6196 > fi;
6197 > if test "$fftw_dir" != "no"; then
6198 >
6199 > if test "$fftw_dir" != "not_set" ; then
6200 >  if test -d "$fftw_dir"
6201 >  then
6202 >    FFTW_HOME="$fftw_dir"
6203 >  else
6204 >    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6205 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6206 >  fi
6207 > fi
6208 >
6209 > FFTW_HOME=/usr/local
6210 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6211 > then
6212 >        FFTW_HOME=/usr
6213 > fi
6214 >
6215 > #
6216 > # Locate fftw, if wanted
6217 > #
6218 > if test -n "${FFTW_HOME}"
6219 > then
6220 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6221 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6222 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6223 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6224 >
6225 >
6226 >        ac_ext=c
6227 > ac_cpp='$CPP $CPPFLAGS'
6228 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6229 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6230 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6231 >
6232 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6233 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6234 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6235 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6236 > else
6237 >  ac_check_lib_save_LIBS=$LIBS
6238 > LIBS="-lfftw3  $LIBS"
6239 > cat >conftest.$ac_ext <<_ACEOF
6240 > /* confdefs.h.  */
6241 > _ACEOF
6242 > cat confdefs.h >>conftest.$ac_ext
6243 > cat >>conftest.$ac_ext <<_ACEOF
6244 > /* end confdefs.h.  */
6245 >
6246 > /* Override any gcc2 internal prototype to avoid an error.  */
6247 > #ifdef __cplusplus
6248 > extern "C"
6249 > #endif
6250 > /* We use char because int might match the return type of a gcc2
6251 >   builtin and then its argument prototype would still apply.  */
6252 > char fftw_execute ();
6253 > #ifdef FC_DUMMY_MAIN
6254 > #ifndef FC_DUMMY_MAIN_EQ_F77
6255 > #  ifdef __cplusplus
6256 >     extern "C"
6257 > #  endif
6258 >   int FC_DUMMY_MAIN() { return 1; }
6259 > #endif
6260 > #endif
6261 > int
6262 > main ()
6263 > {
6264 > fftw_execute ();
6265 >  ;
6266 >  return 0;
6267 > }
6268 > _ACEOF
6269 > rm -f conftest.$ac_objext conftest$ac_exeext
6270 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6271 >  (eval $ac_link) 2>conftest.er1
6272 >  ac_status=$?
6273 >  grep -v '^ *+' conftest.er1 >conftest.err
6274 >  rm -f conftest.er1
6275 >  cat conftest.err >&5
6276 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6277 >  (exit $ac_status); } &&
6278 >         { ac_try='test -z "$ac_c_werror_flag"
6279 >                         || test ! -s conftest.err'
6280 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6281 >  (eval $ac_try) 2>&5
6282 >  ac_status=$?
6283 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6284 >  (exit $ac_status); }; } &&
6285 >         { ac_try='test -s conftest$ac_exeext'
6286 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6287 >  (eval $ac_try) 2>&5
6288 >  ac_status=$?
6289 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6290 >  (exit $ac_status); }; }; then
6291 >  ac_cv_lib_fftw3_fftw_execute=yes
6292 > else
6293 >  echo "$as_me: failed program was:" >&5
6294 > sed 's/^/| /' conftest.$ac_ext >&5
6295 >
6296 > ac_cv_lib_fftw3_fftw_execute=no
6297 > fi
6298 > rm -f conftest.err conftest.$ac_objext \
6299 >      conftest$ac_exeext conftest.$ac_ext
6300 > LIBS=$ac_check_lib_save_LIBS
6301 > fi
6302 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6303 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6304 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6305 >  fftw_cv_libfftw3=yes
6306 > else
6307 >  fftw_cv_libfftw3=no
6308 > fi
6309 >
6310 >        if test "${ac_cv_header_fftw3_h+set}" = set; then
6311 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6312 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6313 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6314 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6315 > fi
6316 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6317 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6318 > else
6319 >  # Is the header compilable?
6320 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6321 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6322 > cat >conftest.$ac_ext <<_ACEOF
6323 > /* confdefs.h.  */
6324 > _ACEOF
6325 > cat confdefs.h >>conftest.$ac_ext
6326 > cat >>conftest.$ac_ext <<_ACEOF
6327 > /* end confdefs.h.  */
6328 > $ac_includes_default
6329 > #include <fftw3.h>
6330 > _ACEOF
6331 > rm -f conftest.$ac_objext
6332 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6333 >  (eval $ac_compile) 2>conftest.er1
6334 >  ac_status=$?
6335 >  grep -v '^ *+' conftest.er1 >conftest.err
6336 >  rm -f conftest.er1
6337 >  cat conftest.err >&5
6338 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6339 >  (exit $ac_status); } &&
6340 >         { ac_try='test -z "$ac_c_werror_flag"
6341 >                         || test ! -s conftest.err'
6342 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6343 >  (eval $ac_try) 2>&5
6344 >  ac_status=$?
6345 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6346 >  (exit $ac_status); }; } &&
6347 >         { ac_try='test -s conftest.$ac_objext'
6348 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6349 >  (eval $ac_try) 2>&5
6350 >  ac_status=$?
6351 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6352 >  (exit $ac_status); }; }; then
6353 >  ac_header_compiler=yes
6354 > else
6355 >  echo "$as_me: failed program was:" >&5
6356 > sed 's/^/| /' conftest.$ac_ext >&5
6357 >
6358 > ac_header_compiler=no
6359 > fi
6360 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6361 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6362 > echo "${ECHO_T}$ac_header_compiler" >&6
6363 >
6364 > # Is the header present?
6365 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6366 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6367 > cat >conftest.$ac_ext <<_ACEOF
6368 > /* confdefs.h.  */
6369 > _ACEOF
6370 > cat confdefs.h >>conftest.$ac_ext
6371 > cat >>conftest.$ac_ext <<_ACEOF
6372 > /* end confdefs.h.  */
6373 > #include <fftw3.h>
6374 > _ACEOF
6375 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6376 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6377 >  ac_status=$?
6378 >  grep -v '^ *+' conftest.er1 >conftest.err
6379 >  rm -f conftest.er1
6380 >  cat conftest.err >&5
6381 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6382 >  (exit $ac_status); } >/dev/null; then
6383 >  if test -s conftest.err; then
6384 >    ac_cpp_err=$ac_c_preproc_warn_flag
6385 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6386 >  else
6387 >    ac_cpp_err=
6388 >  fi
6389 > else
6390 >  ac_cpp_err=yes
6391 > fi
6392 > if test -z "$ac_cpp_err"; then
6393 >  ac_header_preproc=yes
6394 > else
6395 >  echo "$as_me: failed program was:" >&5
6396 > sed 's/^/| /' conftest.$ac_ext >&5
6397 >
6398 >  ac_header_preproc=no
6399 > fi
6400 > rm -f conftest.err conftest.$ac_ext
6401 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6402 > echo "${ECHO_T}$ac_header_preproc" >&6
6403 >
6404 > # So?  What about this header?
6405 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6406 >  yes:no: )
6407 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6408 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6409 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6410 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6411 >    ac_header_preproc=yes
6412 >    ;;
6413 >  no:yes:* )
6414 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6415 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6416 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6417 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6418 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6419 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6420 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6421 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6422 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6423 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6424 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6425 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6426 >    (
6427 >      cat <<\_ASBOX
6428 > ## ------------------------------ ##
6429 > ## Report this to gezelter@nd.edu ##
6430 > ## ------------------------------ ##
6431 > _ASBOX
6432 >    ) |
6433 >      sed "s/^/$as_me: WARNING:     /" >&2
6434 >    ;;
6435 > esac
6436 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6437 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6438 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6439 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6440 > else
6441 >  ac_cv_header_fftw3_h=$ac_header_preproc
6442 > fi
6443 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6444 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6445 >
6446 > fi
6447 > if test $ac_cv_header_fftw3_h = yes; then
6448 >  fftw_cv_fftw3_h=yes
6449 > else
6450 >  fftw_cv_fftw3_h=no
6451 > fi
6452 >
6453 >
6454 >        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6455 >        then
6456 >                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6457 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6458 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6459 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6460 > else
6461 >  ac_check_lib_save_LIBS=$LIBS
6462 > LIBS="-lfftw  $LIBS"
6463 > cat >conftest.$ac_ext <<_ACEOF
6464 > /* confdefs.h.  */
6465 > _ACEOF
6466 > cat confdefs.h >>conftest.$ac_ext
6467 > cat >>conftest.$ac_ext <<_ACEOF
6468 > /* end confdefs.h.  */
6469 >
6470 > /* Override any gcc2 internal prototype to avoid an error.  */
6471 > #ifdef __cplusplus
6472 > extern "C"
6473 > #endif
6474 > /* We use char because int might match the return type of a gcc2
6475 >   builtin and then its argument prototype would still apply.  */
6476 > char fftwnd_one ();
6477 > #ifdef FC_DUMMY_MAIN
6478 > #ifndef FC_DUMMY_MAIN_EQ_F77
6479 > #  ifdef __cplusplus
6480 >     extern "C"
6481 > #  endif
6482 >   int FC_DUMMY_MAIN() { return 1; }
6483 > #endif
6484 > #endif
6485 > int
6486 > main ()
6487 > {
6488 > fftwnd_one ();
6489 >  ;
6490 >  return 0;
6491 > }
6492 > _ACEOF
6493 > rm -f conftest.$ac_objext conftest$ac_exeext
6494 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6495 >  (eval $ac_link) 2>conftest.er1
6496 >  ac_status=$?
6497 >  grep -v '^ *+' conftest.er1 >conftest.err
6498 >  rm -f conftest.er1
6499 >  cat conftest.err >&5
6500 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6501 >  (exit $ac_status); } &&
6502 >         { ac_try='test -z "$ac_c_werror_flag"
6503 >                         || test ! -s conftest.err'
6504 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6505 >  (eval $ac_try) 2>&5
6506 >  ac_status=$?
6507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508 >  (exit $ac_status); }; } &&
6509 >         { ac_try='test -s conftest$ac_exeext'
6510 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6511 >  (eval $ac_try) 2>&5
6512 >  ac_status=$?
6513 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6514 >  (exit $ac_status); }; }; then
6515 >  ac_cv_lib_fftw_fftwnd_one=yes
6516 > else
6517 >  echo "$as_me: failed program was:" >&5
6518 > sed 's/^/| /' conftest.$ac_ext >&5
6519 >
6520 > ac_cv_lib_fftw_fftwnd_one=no
6521 > fi
6522 > rm -f conftest.err conftest.$ac_objext \
6523 >      conftest$ac_exeext conftest.$ac_ext
6524 > LIBS=$ac_check_lib_save_LIBS
6525 > fi
6526 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6527 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6528 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6529 >  fftw_cv_libfftw=yes
6530 > else
6531 >  fftw_cv_libfftw=no
6532 > fi
6533 >
6534 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6535 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6536 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6537 > if test "${ac_cv_header_fftw_h+set}" = set; then
6538 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6539 > fi
6540 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6541 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6542 > else
6543 >  # Is the header compilable?
6544 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6545 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6546 > cat >conftest.$ac_ext <<_ACEOF
6547 > /* confdefs.h.  */
6548 > _ACEOF
6549 > cat confdefs.h >>conftest.$ac_ext
6550 > cat >>conftest.$ac_ext <<_ACEOF
6551 > /* end confdefs.h.  */
6552 > $ac_includes_default
6553 > #include <fftw.h>
6554 > _ACEOF
6555 > rm -f conftest.$ac_objext
6556 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6557 >  (eval $ac_compile) 2>conftest.er1
6558 >  ac_status=$?
6559 >  grep -v '^ *+' conftest.er1 >conftest.err
6560 >  rm -f conftest.er1
6561 >  cat conftest.err >&5
6562 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6563 >  (exit $ac_status); } &&
6564 >         { ac_try='test -z "$ac_c_werror_flag"
6565 >                         || test ! -s conftest.err'
6566 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6567 >  (eval $ac_try) 2>&5
6568 >  ac_status=$?
6569 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6570 >  (exit $ac_status); }; } &&
6571 >         { ac_try='test -s conftest.$ac_objext'
6572 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6573 >  (eval $ac_try) 2>&5
6574 >  ac_status=$?
6575 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6576 >  (exit $ac_status); }; }; then
6577 >  ac_header_compiler=yes
6578 > else
6579 >  echo "$as_me: failed program was:" >&5
6580 > sed 's/^/| /' conftest.$ac_ext >&5
6581 >
6582 > ac_header_compiler=no
6583 > fi
6584 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6585 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6586 > echo "${ECHO_T}$ac_header_compiler" >&6
6587 >
6588 > # Is the header present?
6589 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6590 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6591 > cat >conftest.$ac_ext <<_ACEOF
6592 > /* confdefs.h.  */
6593 > _ACEOF
6594 > cat confdefs.h >>conftest.$ac_ext
6595 > cat >>conftest.$ac_ext <<_ACEOF
6596 > /* end confdefs.h.  */
6597 > #include <fftw.h>
6598 > _ACEOF
6599 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6600 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6601 >  ac_status=$?
6602 >  grep -v '^ *+' conftest.er1 >conftest.err
6603 >  rm -f conftest.er1
6604 >  cat conftest.err >&5
6605 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6606 >  (exit $ac_status); } >/dev/null; then
6607 >  if test -s conftest.err; then
6608 >    ac_cpp_err=$ac_c_preproc_warn_flag
6609 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6610 >  else
6611 >    ac_cpp_err=
6612 >  fi
6613 > else
6614 >  ac_cpp_err=yes
6615 > fi
6616 > if test -z "$ac_cpp_err"; then
6617 >  ac_header_preproc=yes
6618 > else
6619 >  echo "$as_me: failed program was:" >&5
6620 > sed 's/^/| /' conftest.$ac_ext >&5
6621 >
6622 >  ac_header_preproc=no
6623 > fi
6624 > rm -f conftest.err conftest.$ac_ext
6625 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6626 > echo "${ECHO_T}$ac_header_preproc" >&6
6627 >
6628 > # So?  What about this header?
6629 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6630 >  yes:no: )
6631 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6632 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6633 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6634 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6635 >    ac_header_preproc=yes
6636 >    ;;
6637 >  no:yes:* )
6638 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6639 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6640 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6641 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6642 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6643 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6644 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6645 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6646 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6647 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6648 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6649 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6650 >    (
6651 >      cat <<\_ASBOX
6652 > ## ------------------------------ ##
6653 > ## Report this to gezelter@nd.edu ##
6654 > ## ------------------------------ ##
6655 > _ASBOX
6656 >    ) |
6657 >      sed "s/^/$as_me: WARNING:     /" >&2
6658 >    ;;
6659 > esac
6660 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6661 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6662 > if test "${ac_cv_header_fftw_h+set}" = set; then
6663 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6664 > else
6665 >  ac_cv_header_fftw_h=$ac_header_preproc
6666 > fi
6667 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6668 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6669 >
6670 > fi
6671 > if test $ac_cv_header_fftw_h = yes; then
6672 >  fftw_cv_fftw_h=yes
6673 > else
6674 >  fftw_cv_fftw_h=no
6675 > fi
6676 >
6677 >
6678 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6679 >                then
6680 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6681 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6682 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6683 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6684 > else
6685 >  ac_check_lib_save_LIBS=$LIBS
6686 > LIBS="-ldfftw  $LIBS"
6687 > cat >conftest.$ac_ext <<_ACEOF
6688 > /* confdefs.h.  */
6689 > _ACEOF
6690 > cat confdefs.h >>conftest.$ac_ext
6691 > cat >>conftest.$ac_ext <<_ACEOF
6692 > /* end confdefs.h.  */
6693 >
6694 > /* Override any gcc2 internal prototype to avoid an error.  */
6695 > #ifdef __cplusplus
6696 > extern "C"
6697 > #endif
6698 > /* We use char because int might match the return type of a gcc2
6699 >   builtin and then its argument prototype would still apply.  */
6700 > char fftwnd_one ();
6701 > #ifdef FC_DUMMY_MAIN
6702 > #ifndef FC_DUMMY_MAIN_EQ_F77
6703 > #  ifdef __cplusplus
6704 >     extern "C"
6705 > #  endif
6706 >   int FC_DUMMY_MAIN() { return 1; }
6707 > #endif
6708 > #endif
6709 > int
6710 > main ()
6711 > {
6712 > fftwnd_one ();
6713 >  ;
6714 >  return 0;
6715 > }
6716 > _ACEOF
6717 > rm -f conftest.$ac_objext conftest$ac_exeext
6718 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6719 >  (eval $ac_link) 2>conftest.er1
6720 >  ac_status=$?
6721 >  grep -v '^ *+' conftest.er1 >conftest.err
6722 >  rm -f conftest.er1
6723 >  cat conftest.err >&5
6724 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6725 >  (exit $ac_status); } &&
6726 >         { ac_try='test -z "$ac_c_werror_flag"
6727 >                         || test ! -s conftest.err'
6728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6729 >  (eval $ac_try) 2>&5
6730 >  ac_status=$?
6731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6732 >  (exit $ac_status); }; } &&
6733 >         { ac_try='test -s conftest$ac_exeext'
6734 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6735 >  (eval $ac_try) 2>&5
6736 >  ac_status=$?
6737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738 >  (exit $ac_status); }; }; then
6739 >  ac_cv_lib_dfftw_fftwnd_one=yes
6740 > else
6741 >  echo "$as_me: failed program was:" >&5
6742 > sed 's/^/| /' conftest.$ac_ext >&5
6743 >
6744 > ac_cv_lib_dfftw_fftwnd_one=no
6745 > fi
6746 > rm -f conftest.err conftest.$ac_objext \
6747 >      conftest$ac_exeext conftest.$ac_ext
6748 > LIBS=$ac_check_lib_save_LIBS
6749 > fi
6750 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6751 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6752 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6753 >  fftw_cv_libdfftw=yes
6754 > else
6755 >  fftw_cv_libdfftw=no
6756 > fi
6757 >
6758 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6759 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6760 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6761 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6762 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6763 > fi
6764 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6765 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6766 > else
6767 >  # Is the header compilable?
6768 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6769 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6770 > cat >conftest.$ac_ext <<_ACEOF
6771 > /* confdefs.h.  */
6772 > _ACEOF
6773 > cat confdefs.h >>conftest.$ac_ext
6774 > cat >>conftest.$ac_ext <<_ACEOF
6775 > /* end confdefs.h.  */
6776 > $ac_includes_default
6777 > #include <dfftw.h>
6778 > _ACEOF
6779 > rm -f conftest.$ac_objext
6780 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6781 >  (eval $ac_compile) 2>conftest.er1
6782 >  ac_status=$?
6783 >  grep -v '^ *+' conftest.er1 >conftest.err
6784 >  rm -f conftest.er1
6785 >  cat conftest.err >&5
6786 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6787 >  (exit $ac_status); } &&
6788 >         { ac_try='test -z "$ac_c_werror_flag"
6789 >                         || test ! -s conftest.err'
6790 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6791 >  (eval $ac_try) 2>&5
6792 >  ac_status=$?
6793 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6794 >  (exit $ac_status); }; } &&
6795 >         { ac_try='test -s conftest.$ac_objext'
6796 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6797 >  (eval $ac_try) 2>&5
6798 >  ac_status=$?
6799 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800 >  (exit $ac_status); }; }; then
6801 >  ac_header_compiler=yes
6802 > else
6803 >  echo "$as_me: failed program was:" >&5
6804 > sed 's/^/| /' conftest.$ac_ext >&5
6805 >
6806 > ac_header_compiler=no
6807 > fi
6808 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6809 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6810 > echo "${ECHO_T}$ac_header_compiler" >&6
6811 >
6812 > # Is the header present?
6813 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6814 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6815 > cat >conftest.$ac_ext <<_ACEOF
6816 > /* confdefs.h.  */
6817 > _ACEOF
6818 > cat confdefs.h >>conftest.$ac_ext
6819 > cat >>conftest.$ac_ext <<_ACEOF
6820 > /* end confdefs.h.  */
6821 > #include <dfftw.h>
6822 > _ACEOF
6823 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6824 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6825 >  ac_status=$?
6826 >  grep -v '^ *+' conftest.er1 >conftest.err
6827 >  rm -f conftest.er1
6828 >  cat conftest.err >&5
6829 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6830 >  (exit $ac_status); } >/dev/null; then
6831 >  if test -s conftest.err; then
6832 >    ac_cpp_err=$ac_c_preproc_warn_flag
6833 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6834 >  else
6835 >    ac_cpp_err=
6836 >  fi
6837 > else
6838 >  ac_cpp_err=yes
6839 > fi
6840 > if test -z "$ac_cpp_err"; then
6841 >  ac_header_preproc=yes
6842 > else
6843 >  echo "$as_me: failed program was:" >&5
6844 > sed 's/^/| /' conftest.$ac_ext >&5
6845 >
6846 >  ac_header_preproc=no
6847 > fi
6848 > rm -f conftest.err conftest.$ac_ext
6849 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6850 > echo "${ECHO_T}$ac_header_preproc" >&6
6851 >
6852 > # So?  What about this header?
6853 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6854 >  yes:no: )
6855 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6856 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6857 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6858 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6859 >    ac_header_preproc=yes
6860 >    ;;
6861 >  no:yes:* )
6862 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6863 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6864 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6865 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6866 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6867 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6868 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6869 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6870 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6871 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6872 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6873 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6874 >    (
6875 >      cat <<\_ASBOX
6876 > ## ------------------------------ ##
6877 > ## Report this to gezelter@nd.edu ##
6878 > ## ------------------------------ ##
6879 > _ASBOX
6880 >    ) |
6881 >      sed "s/^/$as_me: WARNING:     /" >&2
6882 >    ;;
6883 > esac
6884 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6885 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6886 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6887 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6888 > else
6889 >  ac_cv_header_dfftw_h=$ac_header_preproc
6890 > fi
6891 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6892 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6893 >
6894 > fi
6895 > if test $ac_cv_header_dfftw_h = yes; then
6896 >  fftw_cv_dfftw_h=yes
6897 > else
6898 >  fftw_cv_dfftw_h=no
6899 > fi
6900 >
6901 >
6902 >                fi
6903 >        fi
6904 >        ac_ext=c
6905 > ac_cpp='$CPP $CPPFLAGS'
6906 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6907 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6908 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6909 >
6910 >
6911 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6912 >        then
6913 >
6914 > cat >>confdefs.h <<\_ACEOF
6915 > #define HAVE_FFTW3_H 1
6916 > _ACEOF
6917 >
6918 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6919 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6920 >                FFTW_LIBS="-lfftw3"
6921 >        else
6922 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6923 >        then
6924 >
6925 > cat >>confdefs.h <<\_ACEOF
6926 > #define HAVE_FFTW_H 1
6927 > _ACEOF
6928 >
6929 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6930 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6931 >                FFTW_LIBS="-lfftw"
6932 >        else
6933 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6934 >        then
6935 >
6936 > cat >>confdefs.h <<\_ACEOF
6937 > #define HAVE_DFFTW_H 1
6938 > _ACEOF
6939 >
6940 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6941 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6942 >                FFTW_LIBS="-ldfftw"
6943 >        else
6944 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6945 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6946 >                FFTW_INC_DIR=
6947 >                FFTW_LIB_DIR=
6948 >                FFTW_LIBS=
6949 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6950 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6951 >                echo "$as_me:$LINENO: result: failed" >&5
6952 > echo "${ECHO_T}failed" >&6
6953 >        echo ""
6954 >        echo "*********************************************************"
6955 >        echo "* WARNING: Could not find a working FFTW installation   *"
6956 >        echo "* If you need the staticProps program to be able to     *"
6957 >        echo "* compute undulation spectra, be sure to specify a      *"
6958 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6959 >        echo "*                                                       *"
6960 >        echo "* OOPSE will still work without fftw installed.         *"
6961 >        echo "*********************************************************"
6962 >        echo ""
6963 >        fi
6964 >        fi
6965 >        fi
6966 >
6967 >
6968 >
6969 > fi
6970 > fi
6971 >
6972 >
6973 >
6974 > # Checks for header files.
6975 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6976 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6977 > if test "${ac_cv_header_stdc+set}" = set; then
6978 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6979 > else
6980 >  cat >conftest.$ac_ext <<_ACEOF
6981 > /* confdefs.h.  */
6982 > _ACEOF
6983 > cat confdefs.h >>conftest.$ac_ext
6984 > cat >>conftest.$ac_ext <<_ACEOF
6985 > /* end confdefs.h.  */
6986 > #include <stdlib.h>
6987 > #include <stdarg.h>
6988 > #include <string.h>
6989 > #include <float.h>
6990 >
6991 > #ifdef FC_DUMMY_MAIN
6992 > #ifndef FC_DUMMY_MAIN_EQ_F77
6993 > #  ifdef __cplusplus
6994 >     extern "C"
6995 > #  endif
6996 >   int FC_DUMMY_MAIN() { return 1; }
6997 > #endif
6998 > #endif
6999 > int
7000 > main ()
7001 > {
7002 >
7003 >  ;
7004 >  return 0;
7005 > }
7006 > _ACEOF
7007 > rm -f conftest.$ac_objext
7008 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7009 >  (eval $ac_compile) 2>conftest.er1
7010 >  ac_status=$?
7011 >  grep -v '^ *+' conftest.er1 >conftest.err
7012 >  rm -f conftest.er1
7013 >  cat conftest.err >&5
7014 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7015 >  (exit $ac_status); } &&
7016 >         { ac_try='test -z "$ac_c_werror_flag"
7017 >                         || test ! -s conftest.err'
7018 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7019 >  (eval $ac_try) 2>&5
7020 >  ac_status=$?
7021 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7022 >  (exit $ac_status); }; } &&
7023 >         { ac_try='test -s conftest.$ac_objext'
7024 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7025 >  (eval $ac_try) 2>&5
7026 >  ac_status=$?
7027 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7028 >  (exit $ac_status); }; }; then
7029 >  ac_cv_header_stdc=yes
7030 > else
7031 >  echo "$as_me: failed program was:" >&5
7032 > sed 's/^/| /' conftest.$ac_ext >&5
7033 >
7034 > ac_cv_header_stdc=no
7035 > fi
7036 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7037 >
7038 > if test $ac_cv_header_stdc = yes; then
7039 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7040 >  cat >conftest.$ac_ext <<_ACEOF
7041 > /* confdefs.h.  */
7042 > _ACEOF
7043 > cat confdefs.h >>conftest.$ac_ext
7044 > cat >>conftest.$ac_ext <<_ACEOF
7045 > /* end confdefs.h.  */
7046 > #include <string.h>
7047 >
7048 > _ACEOF
7049 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7050 >  $EGREP "memchr" >/dev/null 2>&1; then
7051 >  :
7052 > else
7053 >  ac_cv_header_stdc=no
7054 > fi
7055 > rm -f conftest*
7056 >
7057 > fi
7058 >
7059 > if test $ac_cv_header_stdc = yes; then
7060 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7061 >  cat >conftest.$ac_ext <<_ACEOF
7062 > /* confdefs.h.  */
7063 > _ACEOF
7064 > cat confdefs.h >>conftest.$ac_ext
7065 > cat >>conftest.$ac_ext <<_ACEOF
7066 > /* end confdefs.h.  */
7067 > #include <stdlib.h>
7068 >
7069 > _ACEOF
7070 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7071 >  $EGREP "free" >/dev/null 2>&1; then
7072 >  :
7073 > else
7074 >  ac_cv_header_stdc=no
7075 > fi
7076 > rm -f conftest*
7077 >
7078 > fi
7079 >
7080 > if test $ac_cv_header_stdc = yes; then
7081 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7082 >  if test "$cross_compiling" = yes; then
7083 >  :
7084 > else
7085 >  cat >conftest.$ac_ext <<_ACEOF
7086 > /* confdefs.h.  */
7087 > _ACEOF
7088 > cat confdefs.h >>conftest.$ac_ext
7089 > cat >>conftest.$ac_ext <<_ACEOF
7090 > /* end confdefs.h.  */
7091 > #include <ctype.h>
7092 > #if ((' ' & 0x0FF) == 0x020)
7093 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7094 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7095 > #else
7096 > # define ISLOWER(c) \
7097 >                   (('a' <= (c) && (c) <= 'i') \
7098 >                     || ('j' <= (c) && (c) <= 'r') \
7099 >                     || ('s' <= (c) && (c) <= 'z'))
7100 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7101 > #endif
7102 >
7103 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7104 > int
7105 > main ()
7106 > {
7107 >  int i;
7108 >  for (i = 0; i < 256; i++)
7109 >    if (XOR (islower (i), ISLOWER (i))
7110 >        || toupper (i) != TOUPPER (i))
7111 >      exit(2);
7112 >  exit (0);
7113 > }
7114 > _ACEOF
7115 > rm -f conftest$ac_exeext
7116 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7117 >  (eval $ac_link) 2>&5
7118 >  ac_status=$?
7119 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7120 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122 >  (eval $ac_try) 2>&5
7123 >  ac_status=$?
7124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125 >  (exit $ac_status); }; }; then
7126 >  :
7127 > else
7128 >  echo "$as_me: program exited with status $ac_status" >&5
7129 > echo "$as_me: failed program was:" >&5
7130 > sed 's/^/| /' conftest.$ac_ext >&5
7131 >
7132 > ( exit $ac_status )
7133 > ac_cv_header_stdc=no
7134 > fi
7135 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7136 > fi
7137 > fi
7138 > fi
7139 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7140 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7141 > if test $ac_cv_header_stdc = yes; then
7142 >
7143 > cat >>confdefs.h <<\_ACEOF
7144 > #define STDC_HEADERS 1
7145 > _ACEOF
7146 >
7147 > fi
7148 >
7149 >
7150 >
7151 >
7152 >
7153 >
7154 >
7155 >
7156 >
7157 >
7158 >
7159 >
7160 >
7161 >
7162 >
7163 >
7164 >
7165 >
7166 >
7167 >
7168 >
7169 >
7170 >
7171 >
7172 >
7173 >
7174 > 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
7175 > do
7176 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7177 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7178 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7179 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7180 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7181 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7182 > fi
7183 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7184 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7185 > else
7186 >  # Is the header compilable?
7187 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7188 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7189 > cat >conftest.$ac_ext <<_ACEOF
7190 > /* confdefs.h.  */
7191 > _ACEOF
7192 > cat confdefs.h >>conftest.$ac_ext
7193 > cat >>conftest.$ac_ext <<_ACEOF
7194 > /* end confdefs.h.  */
7195 > $ac_includes_default
7196 > #include <$ac_header>
7197 > _ACEOF
7198 > rm -f conftest.$ac_objext
7199 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7200 >  (eval $ac_compile) 2>conftest.er1
7201 >  ac_status=$?
7202 >  grep -v '^ *+' conftest.er1 >conftest.err
7203 >  rm -f conftest.er1
7204 >  cat conftest.err >&5
7205 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7206 >  (exit $ac_status); } &&
7207 >         { ac_try='test -z "$ac_c_werror_flag"
7208 >                         || test ! -s conftest.err'
7209 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7210 >  (eval $ac_try) 2>&5
7211 >  ac_status=$?
7212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7213 >  (exit $ac_status); }; } &&
7214 >         { ac_try='test -s conftest.$ac_objext'
7215 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7216 >  (eval $ac_try) 2>&5
7217 >  ac_status=$?
7218 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7219 >  (exit $ac_status); }; }; then
7220 >  ac_header_compiler=yes
7221 > else
7222 >  echo "$as_me: failed program was:" >&5
7223 > sed 's/^/| /' conftest.$ac_ext >&5
7224 >
7225 > ac_header_compiler=no
7226 > fi
7227 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7228 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7229 > echo "${ECHO_T}$ac_header_compiler" >&6
7230 >
7231 > # Is the header present?
7232 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7233 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7234 > cat >conftest.$ac_ext <<_ACEOF
7235 > /* confdefs.h.  */
7236 > _ACEOF
7237 > cat confdefs.h >>conftest.$ac_ext
7238 > cat >>conftest.$ac_ext <<_ACEOF
7239 > /* end confdefs.h.  */
7240 > #include <$ac_header>
7241 > _ACEOF
7242 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7243 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7244 >  ac_status=$?
7245 >  grep -v '^ *+' conftest.er1 >conftest.err
7246 >  rm -f conftest.er1
7247 >  cat conftest.err >&5
7248 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7249 >  (exit $ac_status); } >/dev/null; then
7250 >  if test -s conftest.err; then
7251 >    ac_cpp_err=$ac_c_preproc_warn_flag
7252 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7253 >  else
7254 >    ac_cpp_err=
7255 >  fi
7256 > else
7257 >  ac_cpp_err=yes
7258 > fi
7259 > if test -z "$ac_cpp_err"; then
7260 >  ac_header_preproc=yes
7261 > else
7262 >  echo "$as_me: failed program was:" >&5
7263 > sed 's/^/| /' conftest.$ac_ext >&5
7264 >
7265 >  ac_header_preproc=no
7266 > fi
7267 > rm -f conftest.err conftest.$ac_ext
7268 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7269 > echo "${ECHO_T}$ac_header_preproc" >&6
7270 >
7271 > # So?  What about this header?
7272 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7273 >  yes:no: )
7274 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7275 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7276 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7277 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7278 >    ac_header_preproc=yes
7279 >    ;;
7280 >  no:yes:* )
7281 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7282 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7283 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7284 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7285 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7286 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7287 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7288 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7289 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7290 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7291 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7292 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7293 >    (
7294 >      cat <<\_ASBOX
7295 > ## ------------------------------ ##
7296 > ## Report this to gezelter@nd.edu ##
7297 > ## ------------------------------ ##
7298 > _ASBOX
7299 >    ) |
7300 >      sed "s/^/$as_me: WARNING:     /" >&2
7301 >    ;;
7302 > esac
7303 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7304 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7305 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7307 > else
7308 >  eval "$as_ac_Header=\$ac_header_preproc"
7309 > fi
7310 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7311 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7312 >
7313 > fi
7314 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7315 >  cat >>confdefs.h <<_ACEOF
7316 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7317 > _ACEOF
7318 >
7319 > fi
7320 >
7321 > done
7322 >
7323 >
7324 > # Checks for typedefs, structures, and compiler characteristics.
7325 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7326 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7327 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7328 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7329 > else
7330 >  cat >conftest.$ac_ext <<_ACEOF
7331 > /* confdefs.h.  */
7332 > _ACEOF
7333 > cat confdefs.h >>conftest.$ac_ext
7334 > cat >>conftest.$ac_ext <<_ACEOF
7335 > /* end confdefs.h.  */
7336 >
7337 > #include <stdbool.h>
7338 > #ifndef bool
7339 > # error bool is not defined
7340 > #endif
7341 > #ifndef false
7342 > # error false is not defined
7343 > #endif
7344 > #if false
7345 > # error false is not 0
7346 > #endif
7347 > #ifndef true
7348 > # error true is not defined
7349 > #endif
7350 > #if true != 1
7351 > # error true is not 1
7352 > #endif
7353 > #ifndef __bool_true_false_are_defined
7354 > # error __bool_true_false_are_defined is not defined
7355 > #endif
7356 >
7357 >        struct s { _Bool s: 1; _Bool t; } s;
7358 >
7359 >        char a[true == 1 ? 1 : -1];
7360 >        char b[false == 0 ? 1 : -1];
7361 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7362 >        char d[(bool) -0.5 == true ? 1 : -1];
7363 >        bool e = &s;
7364 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7365 >        char g[true];
7366 >        char h[sizeof (_Bool)];
7367 >        char i[sizeof s.t];
7368 >
7369 > #ifdef FC_DUMMY_MAIN
7370 > #ifndef FC_DUMMY_MAIN_EQ_F77
7371 > #  ifdef __cplusplus
7372 >     extern "C"
7373 > #  endif
7374 >   int FC_DUMMY_MAIN() { return 1; }
7375 > #endif
7376 > #endif
7377 > int
7378 > main ()
7379 > {
7380 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7381 >  ;
7382 >  return 0;
7383 > }
7384 > _ACEOF
7385 > rm -f conftest.$ac_objext
7386 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7387 >  (eval $ac_compile) 2>conftest.er1
7388 >  ac_status=$?
7389 >  grep -v '^ *+' conftest.er1 >conftest.err
7390 >  rm -f conftest.er1
7391 >  cat conftest.err >&5
7392 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7393 >  (exit $ac_status); } &&
7394 >         { ac_try='test -z "$ac_c_werror_flag"
7395 >                         || test ! -s conftest.err'
7396 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7397 >  (eval $ac_try) 2>&5
7398 >  ac_status=$?
7399 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7400 >  (exit $ac_status); }; } &&
7401 >         { ac_try='test -s conftest.$ac_objext'
7402 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7403 >  (eval $ac_try) 2>&5
7404 >  ac_status=$?
7405 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7406 >  (exit $ac_status); }; }; then
7407 >  ac_cv_header_stdbool_h=yes
7408 > else
7409 >  echo "$as_me: failed program was:" >&5
7410 > sed 's/^/| /' conftest.$ac_ext >&5
7411 >
7412 > ac_cv_header_stdbool_h=no
7413 > fi
7414 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7415 > fi
7416 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7417 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7418 > echo "$as_me:$LINENO: checking for _Bool" >&5
7419 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7420 > if test "${ac_cv_type__Bool+set}" = set; then
7421 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7422 > else
7423 >  cat >conftest.$ac_ext <<_ACEOF
7424 > /* confdefs.h.  */
7425 > _ACEOF
7426 > cat confdefs.h >>conftest.$ac_ext
7427 > cat >>conftest.$ac_ext <<_ACEOF
7428 > /* end confdefs.h.  */
7429 > $ac_includes_default
7430 > #ifdef FC_DUMMY_MAIN
7431 > #ifndef FC_DUMMY_MAIN_EQ_F77
7432 > #  ifdef __cplusplus
7433 >     extern "C"
7434 > #  endif
7435 >   int FC_DUMMY_MAIN() { return 1; }
7436 > #endif
7437 > #endif
7438 > int
7439 > main ()
7440 > {
7441 > if ((_Bool *) 0)
7442 >  return 0;
7443 > if (sizeof (_Bool))
7444 >  return 0;
7445 >  ;
7446 >  return 0;
7447 > }
7448 > _ACEOF
7449 > rm -f conftest.$ac_objext
7450 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451 >  (eval $ac_compile) 2>conftest.er1
7452 >  ac_status=$?
7453 >  grep -v '^ *+' conftest.er1 >conftest.err
7454 >  rm -f conftest.er1
7455 >  cat conftest.err >&5
7456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457 >  (exit $ac_status); } &&
7458 >         { ac_try='test -z "$ac_c_werror_flag"
7459 >                         || test ! -s conftest.err'
7460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461 >  (eval $ac_try) 2>&5
7462 >  ac_status=$?
7463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464 >  (exit $ac_status); }; } &&
7465 >         { ac_try='test -s conftest.$ac_objext'
7466 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467 >  (eval $ac_try) 2>&5
7468 >  ac_status=$?
7469 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470 >  (exit $ac_status); }; }; then
7471 >  ac_cv_type__Bool=yes
7472 > else
7473 >  echo "$as_me: failed program was:" >&5
7474 > sed 's/^/| /' conftest.$ac_ext >&5
7475 >
7476 > ac_cv_type__Bool=no
7477 > fi
7478 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479 > fi
7480 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7481 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7482 > if test $ac_cv_type__Bool = yes; then
7483 >
7484 > cat >>confdefs.h <<_ACEOF
7485 > #define HAVE__BOOL 1
7486 > _ACEOF
7487 >
7488 >
7489 > fi
7490 >
7491 > if test $ac_cv_header_stdbool_h = yes; then
7492 >
7493 > cat >>confdefs.h <<\_ACEOF
7494 > #define HAVE_STDBOOL_H 1
7495 > _ACEOF
7496 >
7497 > fi
7498 >
7499 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7500 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7501 > if test "${ac_cv_c_const+set}" = set; then
7502 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7503 > else
7504 >  cat >conftest.$ac_ext <<_ACEOF
7505 > /* confdefs.h.  */
7506 > _ACEOF
7507 > cat confdefs.h >>conftest.$ac_ext
7508 > cat >>conftest.$ac_ext <<_ACEOF
7509 > /* end confdefs.h.  */
7510 >
7511 > #ifdef FC_DUMMY_MAIN
7512 > #ifndef FC_DUMMY_MAIN_EQ_F77
7513 > #  ifdef __cplusplus
7514 >     extern "C"
7515 > #  endif
7516 >   int FC_DUMMY_MAIN() { return 1; }
7517 > #endif
7518 > #endif
7519 > int
7520 > main ()
7521 > {
7522 > /* FIXME: Include the comments suggested by Paul. */
7523 > #ifndef __cplusplus
7524 >  /* Ultrix mips cc rejects this.  */
7525 >  typedef int charset[2];
7526 >  const charset x;
7527 >  /* SunOS 4.1.1 cc rejects this.  */
7528 >  char const *const *ccp;
7529 >  char **p;
7530 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7531 >  struct point {int x, y;};
7532 >  static struct point const zero = {0,0};
7533 >  /* AIX XL C 1.02.0.0 rejects this.
7534 >     It does not let you subtract one const X* pointer from another in
7535 >     an arm of an if-expression whose if-part is not a constant
7536 >     expression */
7537 >  const char *g = "string";
7538 >  ccp = &g + (g ? g-g : 0);
7539 >  /* HPUX 7.0 cc rejects these. */
7540 >  ++ccp;
7541 >  p = (char**) ccp;
7542 >  ccp = (char const *const *) p;
7543 >  { /* SCO 3.2v4 cc rejects this.  */
7544 >    char *t;
7545 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7546 >
7547 >    *t++ = 0;
7548 >  }
7549 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7550 >    int x[] = {25, 17};
7551 >    const int *foo = &x[0];
7552 >    ++foo;
7553 >  }
7554 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7555 >    typedef const int *iptr;
7556 >    iptr p = 0;
7557 >    ++p;
7558 >  }
7559 >  { /* AIX XL C 1.02.0.0 rejects this saying
7560 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7561 >    struct s { int j; const int *ap[3]; };
7562 >    struct s *b; b->j = 5;
7563 >  }
7564 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7565 >    const int foo = 10;
7566 >  }
7567 > #endif
7568 >
7569 >  ;
7570 >  return 0;
7571 > }
7572 > _ACEOF
7573 > rm -f conftest.$ac_objext
7574 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7575 >  (eval $ac_compile) 2>conftest.er1
7576 >  ac_status=$?
7577 >  grep -v '^ *+' conftest.er1 >conftest.err
7578 >  rm -f conftest.er1
7579 >  cat conftest.err >&5
7580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7581 >  (exit $ac_status); } &&
7582 >         { ac_try='test -z "$ac_c_werror_flag"
7583 >                         || test ! -s conftest.err'
7584 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7585 >  (eval $ac_try) 2>&5
7586 >  ac_status=$?
7587 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7588 >  (exit $ac_status); }; } &&
7589 >         { ac_try='test -s conftest.$ac_objext'
7590 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7591 >  (eval $ac_try) 2>&5
7592 >  ac_status=$?
7593 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7594 >  (exit $ac_status); }; }; then
7595 >  ac_cv_c_const=yes
7596 > else
7597 >  echo "$as_me: failed program was:" >&5
7598 > sed 's/^/| /' conftest.$ac_ext >&5
7599 >
7600 > ac_cv_c_const=no
7601 > fi
7602 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7603 > fi
7604 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7605 > echo "${ECHO_T}$ac_cv_c_const" >&6
7606 > if test $ac_cv_c_const = no; then
7607 >
7608 > cat >>confdefs.h <<\_ACEOF
7609 > #define const
7610 > _ACEOF
7611 >
7612 > fi
7613 >
7614 > echo "$as_me:$LINENO: checking for inline" >&5
7615 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7616 > if test "${ac_cv_c_inline+set}" = set; then
7617 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7618 > else
7619 >  ac_cv_c_inline=no
7620 > for ac_kw in inline __inline__ __inline; do
7621 >  cat >conftest.$ac_ext <<_ACEOF
7622 > /* confdefs.h.  */
7623 > _ACEOF
7624 > cat confdefs.h >>conftest.$ac_ext
7625 > cat >>conftest.$ac_ext <<_ACEOF
7626 > /* end confdefs.h.  */
7627 > #ifndef __cplusplus
7628 > typedef int foo_t;
7629 > static $ac_kw foo_t static_foo () {return 0; }
7630 > $ac_kw foo_t foo () {return 0; }
7631 > #endif
7632 >
7633 > _ACEOF
7634 > rm -f conftest.$ac_objext
7635 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7636 >  (eval $ac_compile) 2>conftest.er1
7637 >  ac_status=$?
7638 >  grep -v '^ *+' conftest.er1 >conftest.err
7639 >  rm -f conftest.er1
7640 >  cat conftest.err >&5
7641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7642 >  (exit $ac_status); } &&
7643 >         { ac_try='test -z "$ac_c_werror_flag"
7644 >                         || test ! -s conftest.err'
7645 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7646 >  (eval $ac_try) 2>&5
7647 >  ac_status=$?
7648 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7649 >  (exit $ac_status); }; } &&
7650 >         { ac_try='test -s conftest.$ac_objext'
7651 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7652 >  (eval $ac_try) 2>&5
7653 >  ac_status=$?
7654 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7655 >  (exit $ac_status); }; }; then
7656 >  ac_cv_c_inline=$ac_kw; break
7657 > else
7658 >  echo "$as_me: failed program was:" >&5
7659 > sed 's/^/| /' conftest.$ac_ext >&5
7660 >
7661 > fi
7662 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7663 > done
7664 >
7665 > fi
7666 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7667 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7668 >
7669 >
7670 > case $ac_cv_c_inline in
7671 >  inline | yes) ;;
7672 >  *)
7673 >    case $ac_cv_c_inline in
7674 >      no) ac_val=;;
7675 >      *) ac_val=$ac_cv_c_inline;;
7676 >    esac
7677 >    cat >>confdefs.h <<_ACEOF
7678 > #ifndef __cplusplus
7679 > #define inline $ac_val
7680 > #endif
7681 > _ACEOF
7682 >    ;;
7683 > esac
7684 >
7685 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7686 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7687 > if test "${ac_cv_c_restrict+set}" = set; then
7688 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7689 > else
7690 >  ac_cv_c_restrict=no
7691 >   # Try the official restrict keyword, then gcc's __restrict, and
7692 >   # the less common variants.
7693 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7694 >     cat >conftest.$ac_ext <<_ACEOF
7695 > /* confdefs.h.  */
7696 > _ACEOF
7697 > cat confdefs.h >>conftest.$ac_ext
7698 > cat >>conftest.$ac_ext <<_ACEOF
7699 > /* end confdefs.h.  */
7700 > float * $ac_kw x;
7701 > _ACEOF
7702 > rm -f conftest.$ac_objext
7703 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7704 >  (eval $ac_compile) 2>conftest.er1
7705 >  ac_status=$?
7706 >  grep -v '^ *+' conftest.er1 >conftest.err
7707 >  rm -f conftest.er1
7708 >  cat conftest.err >&5
7709 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7710 >  (exit $ac_status); } &&
7711 >         { ac_try='test -z "$ac_c_werror_flag"
7712 >                         || test ! -s conftest.err'
7713 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7714 >  (eval $ac_try) 2>&5
7715 >  ac_status=$?
7716 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7717 >  (exit $ac_status); }; } &&
7718 >         { ac_try='test -s conftest.$ac_objext'
7719 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7720 >  (eval $ac_try) 2>&5
7721 >  ac_status=$?
7722 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7723 >  (exit $ac_status); }; }; then
7724 >  ac_cv_c_restrict=$ac_kw; break
7725 > else
7726 >  echo "$as_me: failed program was:" >&5
7727 > sed 's/^/| /' conftest.$ac_ext >&5
7728 >
7729 > fi
7730 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7731 >   done
7732 >
7733 > fi
7734 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7735 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7736 > case $ac_cv_c_restrict in
7737 >   restrict) ;;
7738 >   no)
7739 > cat >>confdefs.h <<\_ACEOF
7740 > #define restrict
7741 > _ACEOF
7742 > ;;
7743 >   *)  cat >>confdefs.h <<_ACEOF
7744 > #define restrict $ac_cv_c_restrict
7745 > _ACEOF
7746 > ;;
7747 > esac
7748 >
7749 > echo "$as_me:$LINENO: checking for size_t" >&5
7750 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7751 > if test "${ac_cv_type_size_t+set}" = set; then
7752 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7753 > else
7754 >  cat >conftest.$ac_ext <<_ACEOF
7755 > /* confdefs.h.  */
7756 > _ACEOF
7757 > cat confdefs.h >>conftest.$ac_ext
7758 > cat >>conftest.$ac_ext <<_ACEOF
7759 > /* end confdefs.h.  */
7760 > $ac_includes_default
7761 > #ifdef FC_DUMMY_MAIN
7762 > #ifndef FC_DUMMY_MAIN_EQ_F77
7763 > #  ifdef __cplusplus
7764 >     extern "C"
7765 > #  endif
7766 >   int FC_DUMMY_MAIN() { return 1; }
7767 > #endif
7768 > #endif
7769 > int
7770 > main ()
7771 > {
7772 > if ((size_t *) 0)
7773 >  return 0;
7774 > if (sizeof (size_t))
7775 >  return 0;
7776 >  ;
7777 >  return 0;
7778 > }
7779 > _ACEOF
7780 > rm -f conftest.$ac_objext
7781 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7782 >  (eval $ac_compile) 2>conftest.er1
7783 >  ac_status=$?
7784 >  grep -v '^ *+' conftest.er1 >conftest.err
7785 >  rm -f conftest.er1
7786 >  cat conftest.err >&5
7787 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7788 >  (exit $ac_status); } &&
7789 >         { ac_try='test -z "$ac_c_werror_flag"
7790 >                         || test ! -s conftest.err'
7791 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7792 >  (eval $ac_try) 2>&5
7793 >  ac_status=$?
7794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7795 >  (exit $ac_status); }; } &&
7796 >         { ac_try='test -s conftest.$ac_objext'
7797 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7798 >  (eval $ac_try) 2>&5
7799 >  ac_status=$?
7800 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7801 >  (exit $ac_status); }; }; then
7802 >  ac_cv_type_size_t=yes
7803 > else
7804 >  echo "$as_me: failed program was:" >&5
7805 > sed 's/^/| /' conftest.$ac_ext >&5
7806 >
7807 > ac_cv_type_size_t=no
7808 > fi
7809 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7810 > fi
7811 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7812 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7813 > if test $ac_cv_type_size_t = yes; then
7814 >  :
7815 > else
7816 >
7817 > cat >>confdefs.h <<_ACEOF
7818 > #define size_t unsigned
7819 > _ACEOF
7820 >
7821 > fi
7822 >
7823 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7824 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7825 > if test "${ac_cv_header_time+set}" = set; then
7826 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7827 > else
7828 >  cat >conftest.$ac_ext <<_ACEOF
7829 > /* confdefs.h.  */
7830 > _ACEOF
7831 > cat confdefs.h >>conftest.$ac_ext
7832 > cat >>conftest.$ac_ext <<_ACEOF
7833 > /* end confdefs.h.  */
7834 > #include <sys/types.h>
7835 > #include <sys/time.h>
7836 > #include <time.h>
7837 >
7838 > #ifdef FC_DUMMY_MAIN
7839 > #ifndef FC_DUMMY_MAIN_EQ_F77
7840 > #  ifdef __cplusplus
7841 >     extern "C"
7842 > #  endif
7843 >   int FC_DUMMY_MAIN() { return 1; }
7844 > #endif
7845 > #endif
7846 > int
7847 > main ()
7848 > {
7849 > if ((struct tm *) 0)
7850 > return 0;
7851 >  ;
7852 >  return 0;
7853 > }
7854 > _ACEOF
7855 > rm -f conftest.$ac_objext
7856 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7857 >  (eval $ac_compile) 2>conftest.er1
7858 >  ac_status=$?
7859 >  grep -v '^ *+' conftest.er1 >conftest.err
7860 >  rm -f conftest.er1
7861 >  cat conftest.err >&5
7862 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7863 >  (exit $ac_status); } &&
7864 >         { ac_try='test -z "$ac_c_werror_flag"
7865 >                         || test ! -s conftest.err'
7866 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7867 >  (eval $ac_try) 2>&5
7868 >  ac_status=$?
7869 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7870 >  (exit $ac_status); }; } &&
7871 >         { ac_try='test -s conftest.$ac_objext'
7872 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7873 >  (eval $ac_try) 2>&5
7874 >  ac_status=$?
7875 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7876 >  (exit $ac_status); }; }; then
7877 >  ac_cv_header_time=yes
7878 > else
7879 >  echo "$as_me: failed program was:" >&5
7880 > sed 's/^/| /' conftest.$ac_ext >&5
7881 >
7882 > ac_cv_header_time=no
7883 > fi
7884 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7885 > fi
7886 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7887 > echo "${ECHO_T}$ac_cv_header_time" >&6
7888 > if test $ac_cv_header_time = yes; then
7889 >
7890 > cat >>confdefs.h <<\_ACEOF
7891 > #define TIME_WITH_SYS_TIME 1
7892 > _ACEOF
7893 >
7894 > fi
7895 >
7896 > echo "$as_me:$LINENO: checking for clock_t" >&5
7897 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7898 > if test "${ac_cv_type_clock_t+set}" = set; then
7899 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7900 > else
7901 >  cat >conftest.$ac_ext <<_ACEOF
7902 > /* confdefs.h.  */
7903 > _ACEOF
7904 > cat confdefs.h >>conftest.$ac_ext
7905 > cat >>conftest.$ac_ext <<_ACEOF
7906 > /* end confdefs.h.  */
7907 > $ac_includes_default
7908 > #ifdef FC_DUMMY_MAIN
7909 > #ifndef FC_DUMMY_MAIN_EQ_F77
7910 > #  ifdef __cplusplus
7911 >     extern "C"
7912 > #  endif
7913 >   int FC_DUMMY_MAIN() { return 1; }
7914 > #endif
7915 > #endif
7916 > int
7917 > main ()
7918 > {
7919 > if ((clock_t *) 0)
7920 >  return 0;
7921 > if (sizeof (clock_t))
7922 >  return 0;
7923 >  ;
7924 >  return 0;
7925 > }
7926 > _ACEOF
7927 > rm -f conftest.$ac_objext
7928 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7929 >  (eval $ac_compile) 2>conftest.er1
7930 >  ac_status=$?
7931 >  grep -v '^ *+' conftest.er1 >conftest.err
7932 >  rm -f conftest.er1
7933 >  cat conftest.err >&5
7934 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7935 >  (exit $ac_status); } &&
7936 >         { ac_try='test -z "$ac_c_werror_flag"
7937 >                         || test ! -s conftest.err'
7938 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7939 >  (eval $ac_try) 2>&5
7940 >  ac_status=$?
7941 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7942 >  (exit $ac_status); }; } &&
7943 >         { ac_try='test -s conftest.$ac_objext'
7944 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7945 >  (eval $ac_try) 2>&5
7946 >  ac_status=$?
7947 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7948 >  (exit $ac_status); }; }; then
7949 >  ac_cv_type_clock_t=yes
7950 > else
7951 >  echo "$as_me: failed program was:" >&5
7952 > sed 's/^/| /' conftest.$ac_ext >&5
7953 >
7954 > ac_cv_type_clock_t=no
7955 > fi
7956 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7957 > fi
7958 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7959 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7960 > if test $ac_cv_type_clock_t = yes; then
7961 >
7962 > cat >>confdefs.h <<_ACEOF
7963 > #define HAVE_CLOCK_T 1
7964 > _ACEOF
7965 >
7966 >
7967 > fi
7968 >
7969 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7970 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7971 > if test "${ac_cv_c_const+set}" = set; then
7972 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7973 > else
7974 >  cat >conftest.$ac_ext <<_ACEOF
7975 > /* confdefs.h.  */
7976 > _ACEOF
7977 > cat confdefs.h >>conftest.$ac_ext
7978 > cat >>conftest.$ac_ext <<_ACEOF
7979 > /* end confdefs.h.  */
7980 >
7981 > #ifdef FC_DUMMY_MAIN
7982 > #ifndef FC_DUMMY_MAIN_EQ_F77
7983 > #  ifdef __cplusplus
7984 >     extern "C"
7985 > #  endif
7986 >   int FC_DUMMY_MAIN() { return 1; }
7987 > #endif
7988 > #endif
7989 > int
7990 > main ()
7991 > {
7992 > /* FIXME: Include the comments suggested by Paul. */
7993 > #ifndef __cplusplus
7994 >  /* Ultrix mips cc rejects this.  */
7995 >  typedef int charset[2];
7996 >  const charset x;
7997 >  /* SunOS 4.1.1 cc rejects this.  */
7998 >  char const *const *ccp;
7999 >  char **p;
8000 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8001 >  struct point {int x, y;};
8002 >  static struct point const zero = {0,0};
8003 >  /* AIX XL C 1.02.0.0 rejects this.
8004 >     It does not let you subtract one const X* pointer from another in
8005 >     an arm of an if-expression whose if-part is not a constant
8006 >     expression */
8007 >  const char *g = "string";
8008 >  ccp = &g + (g ? g-g : 0);
8009 >  /* HPUX 7.0 cc rejects these. */
8010 >  ++ccp;
8011 >  p = (char**) ccp;
8012 >  ccp = (char const *const *) p;
8013 >  { /* SCO 3.2v4 cc rejects this.  */
8014 >    char *t;
8015 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8016 >
8017 >    *t++ = 0;
8018 >  }
8019 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8020 >    int x[] = {25, 17};
8021 >    const int *foo = &x[0];
8022 >    ++foo;
8023 >  }
8024 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8025 >    typedef const int *iptr;
8026 >    iptr p = 0;
8027 >    ++p;
8028 >  }
8029 >  { /* AIX XL C 1.02.0.0 rejects this saying
8030 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8031 >    struct s { int j; const int *ap[3]; };
8032 >    struct s *b; b->j = 5;
8033 >  }
8034 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8035 >    const int foo = 10;
8036 >  }
8037 > #endif
8038 >
8039 >  ;
8040 >  return 0;
8041 > }
8042 > _ACEOF
8043 > rm -f conftest.$ac_objext
8044 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8045 >  (eval $ac_compile) 2>conftest.er1
8046 >  ac_status=$?
8047 >  grep -v '^ *+' conftest.er1 >conftest.err
8048 >  rm -f conftest.er1
8049 >  cat conftest.err >&5
8050 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8051 >  (exit $ac_status); } &&
8052 >         { ac_try='test -z "$ac_c_werror_flag"
8053 >                         || test ! -s conftest.err'
8054 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8055 >  (eval $ac_try) 2>&5
8056 >  ac_status=$?
8057 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8058 >  (exit $ac_status); }; } &&
8059 >         { ac_try='test -s conftest.$ac_objext'
8060 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8061 >  (eval $ac_try) 2>&5
8062 >  ac_status=$?
8063 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8064 >  (exit $ac_status); }; }; then
8065 >  ac_cv_c_const=yes
8066 > else
8067 >  echo "$as_me: failed program was:" >&5
8068 > sed 's/^/| /' conftest.$ac_ext >&5
8069 >
8070 > ac_cv_c_const=no
8071 > fi
8072 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8073 > fi
8074 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8075 > echo "${ECHO_T}$ac_cv_c_const" >&6
8076 > if test $ac_cv_c_const = no; then
8077 >
8078 > cat >>confdefs.h <<\_ACEOF
8079 > #define const
8080 > _ACEOF
8081 >
8082 > fi
8083 >
8084 > echo "$as_me:$LINENO: checking for inline" >&5
8085 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8086 > if test "${ac_cv_c_inline+set}" = set; then
8087 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8088 > else
8089 >  ac_cv_c_inline=no
8090 > for ac_kw in inline __inline__ __inline; do
8091 >  cat >conftest.$ac_ext <<_ACEOF
8092 > /* confdefs.h.  */
8093 > _ACEOF
8094 > cat confdefs.h >>conftest.$ac_ext
8095 > cat >>conftest.$ac_ext <<_ACEOF
8096 > /* end confdefs.h.  */
8097 > #ifndef __cplusplus
8098 > typedef int foo_t;
8099 > static $ac_kw foo_t static_foo () {return 0; }
8100 > $ac_kw foo_t foo () {return 0; }
8101 > #endif
8102 >
8103 > _ACEOF
8104 > rm -f conftest.$ac_objext
8105 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8106 >  (eval $ac_compile) 2>conftest.er1
8107 >  ac_status=$?
8108 >  grep -v '^ *+' conftest.er1 >conftest.err
8109 >  rm -f conftest.er1
8110 >  cat conftest.err >&5
8111 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8112 >  (exit $ac_status); } &&
8113 >         { ac_try='test -z "$ac_c_werror_flag"
8114 >                         || test ! -s conftest.err'
8115 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8116 >  (eval $ac_try) 2>&5
8117 >  ac_status=$?
8118 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8119 >  (exit $ac_status); }; } &&
8120 >         { ac_try='test -s conftest.$ac_objext'
8121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8122 >  (eval $ac_try) 2>&5
8123 >  ac_status=$?
8124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8125 >  (exit $ac_status); }; }; then
8126 >  ac_cv_c_inline=$ac_kw; break
8127 > else
8128 >  echo "$as_me: failed program was:" >&5
8129 > sed 's/^/| /' conftest.$ac_ext >&5
8130 >
8131 > fi
8132 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8133 > done
8134 >
8135 > fi
8136 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8137 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8138 >
8139 >
8140 > case $ac_cv_c_inline in
8141 >  inline | yes) ;;
8142 >  *)
8143 >    case $ac_cv_c_inline in
8144 >      no) ac_val=;;
8145 >      *) ac_val=$ac_cv_c_inline;;
8146 >    esac
8147 >    cat >>confdefs.h <<_ACEOF
8148 > #ifndef __cplusplus
8149 > #define inline $ac_val
8150 > #endif
8151 > _ACEOF
8152 >    ;;
8153 > esac
8154 >
8155 >
8156 > # Checks for library functions.
8157 >
8158 > for ac_header in stdlib.h
8159 > do
8160 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8161 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8162 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8163 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8164 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8165 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8166 > fi
8167 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8168 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8169 > else
8170 >  # Is the header compilable?
8171 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8172 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8173 > cat >conftest.$ac_ext <<_ACEOF
8174 > /* confdefs.h.  */
8175 > _ACEOF
8176 > cat confdefs.h >>conftest.$ac_ext
8177 > cat >>conftest.$ac_ext <<_ACEOF
8178 > /* end confdefs.h.  */
8179 > $ac_includes_default
8180 > #include <$ac_header>
8181 > _ACEOF
8182 > rm -f conftest.$ac_objext
8183 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8184 >  (eval $ac_compile) 2>conftest.er1
8185 >  ac_status=$?
8186 >  grep -v '^ *+' conftest.er1 >conftest.err
8187 >  rm -f conftest.er1
8188 >  cat conftest.err >&5
8189 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8190 >  (exit $ac_status); } &&
8191 >         { ac_try='test -z "$ac_c_werror_flag"
8192 >                         || test ! -s conftest.err'
8193 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8194 >  (eval $ac_try) 2>&5
8195 >  ac_status=$?
8196 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8197 >  (exit $ac_status); }; } &&
8198 >         { ac_try='test -s conftest.$ac_objext'
8199 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8200 >  (eval $ac_try) 2>&5
8201 >  ac_status=$?
8202 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8203 >  (exit $ac_status); }; }; then
8204 >  ac_header_compiler=yes
8205 > else
8206 >  echo "$as_me: failed program was:" >&5
8207 > sed 's/^/| /' conftest.$ac_ext >&5
8208 >
8209 > ac_header_compiler=no
8210 > fi
8211 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8212 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8213 > echo "${ECHO_T}$ac_header_compiler" >&6
8214 >
8215 > # Is the header present?
8216 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8217 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8218 > cat >conftest.$ac_ext <<_ACEOF
8219 > /* confdefs.h.  */
8220 > _ACEOF
8221 > cat confdefs.h >>conftest.$ac_ext
8222 > cat >>conftest.$ac_ext <<_ACEOF
8223 > /* end confdefs.h.  */
8224 > #include <$ac_header>
8225 > _ACEOF
8226 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8227 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8228 >  ac_status=$?
8229 >  grep -v '^ *+' conftest.er1 >conftest.err
8230 >  rm -f conftest.er1
8231 >  cat conftest.err >&5
8232 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8233 >  (exit $ac_status); } >/dev/null; then
8234 >  if test -s conftest.err; then
8235 >    ac_cpp_err=$ac_c_preproc_warn_flag
8236 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8237 >  else
8238 >    ac_cpp_err=
8239 >  fi
8240 > else
8241 >  ac_cpp_err=yes
8242 > fi
8243 > if test -z "$ac_cpp_err"; then
8244 >  ac_header_preproc=yes
8245 > else
8246 >  echo "$as_me: failed program was:" >&5
8247 > sed 's/^/| /' conftest.$ac_ext >&5
8248 >
8249 >  ac_header_preproc=no
8250 > fi
8251 > rm -f conftest.err conftest.$ac_ext
8252 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8253 > echo "${ECHO_T}$ac_header_preproc" >&6
8254 >
8255 > # So?  What about this header?
8256 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8257 >  yes:no: )
8258 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8259 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8260 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8261 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8262 >    ac_header_preproc=yes
8263 >    ;;
8264 >  no:yes:* )
8265 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8266 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8267 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8268 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8269 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8270 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8271 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8272 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8273 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8274 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8275 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8276 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8277 >    (
8278 >      cat <<\_ASBOX
8279 > ## ------------------------------ ##
8280 > ## Report this to gezelter@nd.edu ##
8281 > ## ------------------------------ ##
8282 > _ASBOX
8283 >    ) |
8284 >      sed "s/^/$as_me: WARNING:     /" >&2
8285 >    ;;
8286 > esac
8287 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8288 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8289 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8290 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8291 > else
8292 >  eval "$as_ac_Header=\$ac_header_preproc"
8293 > fi
8294 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8295 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8296 >
8297 > fi
8298 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8299 >  cat >>confdefs.h <<_ACEOF
8300 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8301 > _ACEOF
8302 >
8303 > fi
8304 >
8305 > done
8306 >
8307 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8308 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8309 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8310 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8311 > else
8312 >  if test "$cross_compiling" = yes; then
8313 >  ac_cv_func_malloc_0_nonnull=no
8314 > else
8315 >  cat >conftest.$ac_ext <<_ACEOF
8316 > /* confdefs.h.  */
8317 > _ACEOF
8318 > cat confdefs.h >>conftest.$ac_ext
8319 > cat >>conftest.$ac_ext <<_ACEOF
8320 > /* end confdefs.h.  */
8321 > #if STDC_HEADERS || HAVE_STDLIB_H
8322 > # include <stdlib.h>
8323 > #else
8324 > char *malloc ();
8325 > #endif
8326 >
8327 > #ifdef FC_DUMMY_MAIN
8328 > #ifndef FC_DUMMY_MAIN_EQ_F77
8329 > #  ifdef __cplusplus
8330 >     extern "C"
8331 > #  endif
8332 >   int FC_DUMMY_MAIN() { return 1; }
8333 > #endif
8334 > #endif
8335 > int
8336 > main ()
8337 > {
8338 > exit (malloc (0) ? 0 : 1);
8339 >  ;
8340 >  return 0;
8341 > }
8342 > _ACEOF
8343 > rm -f conftest$ac_exeext
8344 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8345 >  (eval $ac_link) 2>&5
8346 >  ac_status=$?
8347 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8348 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8349 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8350 >  (eval $ac_try) 2>&5
8351 >  ac_status=$?
8352 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8353 >  (exit $ac_status); }; }; then
8354 >  ac_cv_func_malloc_0_nonnull=yes
8355 > else
8356 >  echo "$as_me: program exited with status $ac_status" >&5
8357 > echo "$as_me: failed program was:" >&5
8358 > sed 's/^/| /' conftest.$ac_ext >&5
8359 >
8360 > ( exit $ac_status )
8361 > ac_cv_func_malloc_0_nonnull=no
8362 > fi
8363 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8364 > fi
8365 > fi
8366 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8367 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8368 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8369 >
8370 > cat >>confdefs.h <<\_ACEOF
8371 > #define HAVE_MALLOC 1
8372 > _ACEOF
8373 >
8374 > else
8375 >  cat >>confdefs.h <<\_ACEOF
8376 > #define HAVE_MALLOC 0
8377 > _ACEOF
8378 >
8379 >   case $LIBOBJS in
8380 >    "malloc.$ac_objext"   | \
8381 >  *" malloc.$ac_objext"   | \
8382 >    "malloc.$ac_objext "* | \
8383 >  *" malloc.$ac_objext "* ) ;;
8384 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8385 > esac
8386 >
8387 >
8388 > cat >>confdefs.h <<\_ACEOF
8389 > #define malloc rpl_malloc
8390 > _ACEOF
8391 >
8392 > fi
8393 >
8394 >
8395 >
8396 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8397 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8398 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8399 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8400 > else
8401 >  if test "$cross_compiling" = yes; then
8402 >  ac_cv_func_memcmp_working=no
8403 > else
8404 >  cat >conftest.$ac_ext <<_ACEOF
8405 > /* confdefs.h.  */
8406 > _ACEOF
8407 > cat confdefs.h >>conftest.$ac_ext
8408 > cat >>conftest.$ac_ext <<_ACEOF
8409 > /* end confdefs.h.  */
8410 > $ac_includes_default
8411 > #ifdef FC_DUMMY_MAIN
8412 > #ifndef FC_DUMMY_MAIN_EQ_F77
8413 > #  ifdef __cplusplus
8414 >     extern "C"
8415 > #  endif
8416 >   int FC_DUMMY_MAIN() { return 1; }
8417 > #endif
8418 > #endif
8419 > int
8420 > main ()
8421 > {
8422 >
8423 >  /* Some versions of memcmp are not 8-bit clean.  */
8424 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8425 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8426 >    exit (1);
8427 >
8428 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8429 >     or more and with at least one buffer not starting on a 4-byte boundary.
8430 >     William Lewis provided this test program.   */
8431 >  {
8432 >    char foo[21];
8433 >    char bar[21];
8434 >    int i;
8435 >    for (i = 0; i < 4; i++)
8436 >      {
8437 >        char *a = foo + i;
8438 >        char *b = bar + i;
8439 >        strcpy (a, "--------01111111");
8440 >        strcpy (b, "--------10000000");
8441 >        if (memcmp (a, b, 16) >= 0)
8442 >          exit (1);
8443 >      }
8444 >    exit (0);
8445 >  }
8446 >
8447 >  ;
8448 >  return 0;
8449 > }
8450 > _ACEOF
8451 > rm -f conftest$ac_exeext
8452 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8453 >  (eval $ac_link) 2>&5
8454 >  ac_status=$?
8455 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8456 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8457 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8458 >  (eval $ac_try) 2>&5
8459 >  ac_status=$?
8460 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8461 >  (exit $ac_status); }; }; then
8462 >  ac_cv_func_memcmp_working=yes
8463 > else
8464 >  echo "$as_me: program exited with status $ac_status" >&5
8465 > echo "$as_me: failed program was:" >&5
8466 > sed 's/^/| /' conftest.$ac_ext >&5
8467 >
8468 > ( exit $ac_status )
8469 > ac_cv_func_memcmp_working=no
8470 > fi
8471 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8472 > fi
8473 > fi
8474 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8475 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8476 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8477 >    "memcmp.$ac_objext"   | \
8478 >  *" memcmp.$ac_objext"   | \
8479 >    "memcmp.$ac_objext "* | \
8480 >  *" memcmp.$ac_objext "* ) ;;
8481 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8482 > esac
8483 >
8484 >
8485 >
8486 > for ac_header in stdlib.h
8487 > do
8488 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8489 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8490 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8491 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8492 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8493 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8494 > fi
8495 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8496 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8497 > else
8498 >  # Is the header compilable?
8499 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8500 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
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 > $ac_includes_default
8508 > #include <$ac_header>
8509 > _ACEOF
8510 > rm -f conftest.$ac_objext
8511 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8512 >  (eval $ac_compile) 2>conftest.er1
8513 >  ac_status=$?
8514 >  grep -v '^ *+' conftest.er1 >conftest.err
8515 >  rm -f conftest.er1
8516 >  cat conftest.err >&5
8517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8518 >  (exit $ac_status); } &&
8519 >         { ac_try='test -z "$ac_c_werror_flag"
8520 >                         || test ! -s conftest.err'
8521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8522 >  (eval $ac_try) 2>&5
8523 >  ac_status=$?
8524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8525 >  (exit $ac_status); }; } &&
8526 >         { ac_try='test -s conftest.$ac_objext'
8527 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8528 >  (eval $ac_try) 2>&5
8529 >  ac_status=$?
8530 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8531 >  (exit $ac_status); }; }; then
8532 >  ac_header_compiler=yes
8533 > else
8534 >  echo "$as_me: failed program was:" >&5
8535 > sed 's/^/| /' conftest.$ac_ext >&5
8536 >
8537 > ac_header_compiler=no
8538 > fi
8539 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8540 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8541 > echo "${ECHO_T}$ac_header_compiler" >&6
8542 >
8543 > # Is the header present?
8544 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8545 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8546 > cat >conftest.$ac_ext <<_ACEOF
8547 > /* confdefs.h.  */
8548 > _ACEOF
8549 > cat confdefs.h >>conftest.$ac_ext
8550 > cat >>conftest.$ac_ext <<_ACEOF
8551 > /* end confdefs.h.  */
8552 > #include <$ac_header>
8553 > _ACEOF
8554 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8555 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8556 >  ac_status=$?
8557 >  grep -v '^ *+' conftest.er1 >conftest.err
8558 >  rm -f conftest.er1
8559 >  cat conftest.err >&5
8560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8561 >  (exit $ac_status); } >/dev/null; then
8562 >  if test -s conftest.err; then
8563 >    ac_cpp_err=$ac_c_preproc_warn_flag
8564 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8565 >  else
8566 >    ac_cpp_err=
8567 >  fi
8568 > else
8569 >  ac_cpp_err=yes
8570 > fi
8571 > if test -z "$ac_cpp_err"; then
8572 >  ac_header_preproc=yes
8573 > else
8574 >  echo "$as_me: failed program was:" >&5
8575 > sed 's/^/| /' conftest.$ac_ext >&5
8576 >
8577 >  ac_header_preproc=no
8578 > fi
8579 > rm -f conftest.err conftest.$ac_ext
8580 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8581 > echo "${ECHO_T}$ac_header_preproc" >&6
8582 >
8583 > # So?  What about this header?
8584 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8585 >  yes:no: )
8586 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8587 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8588 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8589 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8590 >    ac_header_preproc=yes
8591 >    ;;
8592 >  no:yes:* )
8593 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8594 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8595 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8596 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8598 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8599 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8600 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8601 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8602 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8603 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8604 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8605 >    (
8606 >      cat <<\_ASBOX
8607 > ## ------------------------------ ##
8608 > ## Report this to gezelter@nd.edu ##
8609 > ## ------------------------------ ##
8610 > _ASBOX
8611 >    ) |
8612 >      sed "s/^/$as_me: WARNING:     /" >&2
8613 >    ;;
8614 > esac
8615 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8616 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8617 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8618 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8619 > else
8620 >  eval "$as_ac_Header=\$ac_header_preproc"
8621 > fi
8622 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8623 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8624 >
8625 > fi
8626 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8627 >  cat >>confdefs.h <<_ACEOF
8628 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8629 > _ACEOF
8630 >
8631 > fi
8632 >
8633 > done
8634 >
8635 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8636 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8637 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8639 > else
8640 >  if test "$cross_compiling" = yes; then
8641 >  ac_cv_func_realloc_0_nonnull=no
8642 > else
8643 >  cat >conftest.$ac_ext <<_ACEOF
8644 > /* confdefs.h.  */
8645 > _ACEOF
8646 > cat confdefs.h >>conftest.$ac_ext
8647 > cat >>conftest.$ac_ext <<_ACEOF
8648 > /* end confdefs.h.  */
8649 > #if STDC_HEADERS || HAVE_STDLIB_H
8650 > # include <stdlib.h>
8651 > #else
8652 > char *realloc ();
8653 > #endif
8654 >
8655 > #ifdef FC_DUMMY_MAIN
8656 > #ifndef FC_DUMMY_MAIN_EQ_F77
8657 > #  ifdef __cplusplus
8658 >     extern "C"
8659 > #  endif
8660 >   int FC_DUMMY_MAIN() { return 1; }
8661 > #endif
8662 > #endif
8663 > int
8664 > main ()
8665 > {
8666 > exit (realloc (0, 0) ? 0 : 1);
8667 >  ;
8668 >  return 0;
8669 > }
8670 > _ACEOF
8671 > rm -f conftest$ac_exeext
8672 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8673 >  (eval $ac_link) 2>&5
8674 >  ac_status=$?
8675 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8676 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8677 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8678 >  (eval $ac_try) 2>&5
8679 >  ac_status=$?
8680 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8681 >  (exit $ac_status); }; }; then
8682 >  ac_cv_func_realloc_0_nonnull=yes
8683 > else
8684 >  echo "$as_me: program exited with status $ac_status" >&5
8685 > echo "$as_me: failed program was:" >&5
8686 > sed 's/^/| /' conftest.$ac_ext >&5
8687 >
8688 > ( exit $ac_status )
8689 > ac_cv_func_realloc_0_nonnull=no
8690 > fi
8691 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8692 > fi
8693 > fi
8694 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8695 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8696 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8697 >
8698 > cat >>confdefs.h <<\_ACEOF
8699 > #define HAVE_REALLOC 1
8700 > _ACEOF
8701 >
8702 > else
8703 >  cat >>confdefs.h <<\_ACEOF
8704 > #define HAVE_REALLOC 0
8705 > _ACEOF
8706 >
8707 >   case $LIBOBJS in
8708 >    "realloc.$ac_objext"   | \
8709 >  *" realloc.$ac_objext"   | \
8710 >    "realloc.$ac_objext "* | \
8711 >  *" realloc.$ac_objext "* ) ;;
8712 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8713 > esac
8714 >
8715 >
8716 > cat >>confdefs.h <<\_ACEOF
8717 > #define realloc rpl_realloc
8718 > _ACEOF
8719 >
8720 > fi
8721 >
8722 >
8723 >
8724 >
8725 >
8726 > for ac_header in sys/select.h sys/socket.h
8727 > do
8728 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8729 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8730 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8731 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8732 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8733 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8734 > fi
8735 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8736 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8737 > else
8738 >  # Is the header compilable?
8739 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8740 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8741 > cat >conftest.$ac_ext <<_ACEOF
8742 > /* confdefs.h.  */
8743 > _ACEOF
8744 > cat confdefs.h >>conftest.$ac_ext
8745 > cat >>conftest.$ac_ext <<_ACEOF
8746 > /* end confdefs.h.  */
8747 > $ac_includes_default
8748 > #include <$ac_header>
8749 > _ACEOF
8750 > rm -f conftest.$ac_objext
8751 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8752 >  (eval $ac_compile) 2>conftest.er1
8753 >  ac_status=$?
8754 >  grep -v '^ *+' conftest.er1 >conftest.err
8755 >  rm -f conftest.er1
8756 >  cat conftest.err >&5
8757 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8758 >  (exit $ac_status); } &&
8759 >         { ac_try='test -z "$ac_c_werror_flag"
8760 >                         || test ! -s conftest.err'
8761 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8762 >  (eval $ac_try) 2>&5
8763 >  ac_status=$?
8764 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8765 >  (exit $ac_status); }; } &&
8766 >         { ac_try='test -s conftest.$ac_objext'
8767 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8768 >  (eval $ac_try) 2>&5
8769 >  ac_status=$?
8770 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8771 >  (exit $ac_status); }; }; then
8772 >  ac_header_compiler=yes
8773 > else
8774 >  echo "$as_me: failed program was:" >&5
8775 > sed 's/^/| /' conftest.$ac_ext >&5
8776 >
8777 > ac_header_compiler=no
8778 > fi
8779 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8780 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8781 > echo "${ECHO_T}$ac_header_compiler" >&6
8782 >
8783 > # Is the header present?
8784 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8785 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8786 > cat >conftest.$ac_ext <<_ACEOF
8787 > /* confdefs.h.  */
8788 > _ACEOF
8789 > cat confdefs.h >>conftest.$ac_ext
8790 > cat >>conftest.$ac_ext <<_ACEOF
8791 > /* end confdefs.h.  */
8792 > #include <$ac_header>
8793 > _ACEOF
8794 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8795 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8796 >  ac_status=$?
8797 >  grep -v '^ *+' conftest.er1 >conftest.err
8798 >  rm -f conftest.er1
8799 >  cat conftest.err >&5
8800 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8801 >  (exit $ac_status); } >/dev/null; then
8802 >  if test -s conftest.err; then
8803 >    ac_cpp_err=$ac_c_preproc_warn_flag
8804 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8805 >  else
8806 >    ac_cpp_err=
8807 >  fi
8808 > else
8809 >  ac_cpp_err=yes
8810 > fi
8811 > if test -z "$ac_cpp_err"; then
8812 >  ac_header_preproc=yes
8813 > else
8814 >  echo "$as_me: failed program was:" >&5
8815 > sed 's/^/| /' conftest.$ac_ext >&5
8816 >
8817 >  ac_header_preproc=no
8818 > fi
8819 > rm -f conftest.err conftest.$ac_ext
8820 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8821 > echo "${ECHO_T}$ac_header_preproc" >&6
8822 >
8823 > # So?  What about this header?
8824 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8825 >  yes:no: )
8826 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8827 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8828 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8829 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8830 >    ac_header_preproc=yes
8831 >    ;;
8832 >  no:yes:* )
8833 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8834 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8835 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8836 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8837 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8838 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8839 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8840 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8841 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8842 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8843 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8844 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8845 >    (
8846 >      cat <<\_ASBOX
8847 > ## ------------------------------ ##
8848 > ## Report this to gezelter@nd.edu ##
8849 > ## ------------------------------ ##
8850 > _ASBOX
8851 >    ) |
8852 >      sed "s/^/$as_me: WARNING:     /" >&2
8853 >    ;;
8854 > esac
8855 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8856 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8857 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8858 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8859 > else
8860 >  eval "$as_ac_Header=\$ac_header_preproc"
8861 > fi
8862 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8863 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8864 >
8865 > fi
8866 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8867 >  cat >>confdefs.h <<_ACEOF
8868 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8869 > _ACEOF
8870 >
8871 > fi
8872 >
8873 > done
8874 >
8875 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8876 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8877 > if test "${ac_cv_func_select_args+set}" = set; then
8878 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8879 > else
8880 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8881 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8882 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8883 >   cat >conftest.$ac_ext <<_ACEOF
8884 > /* confdefs.h.  */
8885 > _ACEOF
8886 > cat confdefs.h >>conftest.$ac_ext
8887 > cat >>conftest.$ac_ext <<_ACEOF
8888 > /* end confdefs.h.  */
8889 > $ac_includes_default
8890 > #if HAVE_SYS_SELECT_H
8891 > # include <sys/select.h>
8892 > #endif
8893 > #if HAVE_SYS_SOCKET_H
8894 > # include <sys/socket.h>
8895 > #endif
8896 >
8897 > #ifdef FC_DUMMY_MAIN
8898 > #ifndef FC_DUMMY_MAIN_EQ_F77
8899 > #  ifdef __cplusplus
8900 >     extern "C"
8901 > #  endif
8902 >   int FC_DUMMY_MAIN() { return 1; }
8903 > #endif
8904 > #endif
8905 > int
8906 > main ()
8907 > {
8908 > extern int select ($ac_arg1,
8909 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8910 >                                            $ac_arg5);
8911 >  ;
8912 >  return 0;
8913 > }
8914 > _ACEOF
8915 > rm -f conftest.$ac_objext
8916 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8917 >  (eval $ac_compile) 2>conftest.er1
8918 >  ac_status=$?
8919 >  grep -v '^ *+' conftest.er1 >conftest.err
8920 >  rm -f conftest.er1
8921 >  cat conftest.err >&5
8922 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8923 >  (exit $ac_status); } &&
8924 >         { ac_try='test -z "$ac_c_werror_flag"
8925 >                         || test ! -s conftest.err'
8926 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8927 >  (eval $ac_try) 2>&5
8928 >  ac_status=$?
8929 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8930 >  (exit $ac_status); }; } &&
8931 >         { ac_try='test -s conftest.$ac_objext'
8932 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8933 >  (eval $ac_try) 2>&5
8934 >  ac_status=$?
8935 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8936 >  (exit $ac_status); }; }; then
8937 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8938 > else
8939 >  echo "$as_me: failed program was:" >&5
8940 > sed 's/^/| /' conftest.$ac_ext >&5
8941 >
8942 > fi
8943 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8944 >  done
8945 > done
8946 > done
8947 > # Provide a safe default value.
8948 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8949 >
8950 > fi
8951 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8952 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8953 > ac_save_IFS=$IFS; IFS=','
8954 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8955 > IFS=$ac_save_IFS
8956 > shift
8957 >
8958 > cat >>confdefs.h <<_ACEOF
8959 > #define SELECT_TYPE_ARG1 $1
8960 > _ACEOF
8961 >
8962 >
8963 > cat >>confdefs.h <<_ACEOF
8964 > #define SELECT_TYPE_ARG234 ($2)
8965 > _ACEOF
8966 >
8967 >
8968 > cat >>confdefs.h <<_ACEOF
8969 > #define SELECT_TYPE_ARG5 ($3)
8970 > _ACEOF
8971 >
8972 > rm -f conftest*
8973 >
8974 >
8975 > for ac_func in strftime
8976 > do
8977 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8978 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8979 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8980 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8981 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8982 > else
8983 >  cat >conftest.$ac_ext <<_ACEOF
8984 > /* confdefs.h.  */
8985 > _ACEOF
8986 > cat confdefs.h >>conftest.$ac_ext
8987 > cat >>conftest.$ac_ext <<_ACEOF
8988 > /* end confdefs.h.  */
8989 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8990 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8991 > #define $ac_func innocuous_$ac_func
8992 >
8993 > /* System header to define __stub macros and hopefully few prototypes,
8994 >    which can conflict with char $ac_func (); below.
8995 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8996 >    <limits.h> exists even on freestanding compilers.  */
8997 >
8998 > #ifdef __STDC__
8999 > # include <limits.h>
9000 > #else
9001 > # include <assert.h>
9002 > #endif
9003 >
9004 > #undef $ac_func
9005 >
9006 > /* Override any gcc2 internal prototype to avoid an error.  */
9007 > #ifdef __cplusplus
9008 > extern "C"
9009 > {
9010 > #endif
9011 > /* We use char because int might match the return type of a gcc2
9012 >   builtin and then its argument prototype would still apply.  */
9013 > char $ac_func ();
9014 > /* The GNU C library defines this for functions which it implements
9015 >    to always fail with ENOSYS.  Some functions are actually named
9016 >    something starting with __ and the normal name is an alias.  */
9017 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9018 > choke me
9019 > #else
9020 > char (*f) () = $ac_func;
9021 > #endif
9022 > #ifdef __cplusplus
9023 > }
9024 > #endif
9025 >
9026 > #ifdef FC_DUMMY_MAIN
9027 > #ifndef FC_DUMMY_MAIN_EQ_F77
9028 > #  ifdef __cplusplus
9029 >     extern "C"
9030 > #  endif
9031 >   int FC_DUMMY_MAIN() { return 1; }
9032 > #endif
9033 > #endif
9034 > int
9035 > main ()
9036 > {
9037 > return f != $ac_func;
9038 >  ;
9039 >  return 0;
9040 > }
9041 > _ACEOF
9042 > rm -f conftest.$ac_objext conftest$ac_exeext
9043 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9044 >  (eval $ac_link) 2>conftest.er1
9045 >  ac_status=$?
9046 >  grep -v '^ *+' conftest.er1 >conftest.err
9047 >  rm -f conftest.er1
9048 >  cat conftest.err >&5
9049 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9050 >  (exit $ac_status); } &&
9051 >         { ac_try='test -z "$ac_c_werror_flag"
9052 >                         || test ! -s conftest.err'
9053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9054 >  (eval $ac_try) 2>&5
9055 >  ac_status=$?
9056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9057 >  (exit $ac_status); }; } &&
9058 >         { ac_try='test -s conftest$ac_exeext'
9059 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9060 >  (eval $ac_try) 2>&5
9061 >  ac_status=$?
9062 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9063 >  (exit $ac_status); }; }; then
9064 >  eval "$as_ac_var=yes"
9065 > else
9066 >  echo "$as_me: failed program was:" >&5
9067 > sed 's/^/| /' conftest.$ac_ext >&5
9068 >
9069 > eval "$as_ac_var=no"
9070 > fi
9071 > rm -f conftest.err conftest.$ac_objext \
9072 >      conftest$ac_exeext conftest.$ac_ext
9073 > fi
9074 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9075 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9076 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9077 >  cat >>confdefs.h <<_ACEOF
9078 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9079 > _ACEOF
9080 >
9081 > else
9082 >  # strftime is in -lintl on SCO UNIX.
9083 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9084 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9085 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9086 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9087 > else
9088 >  ac_check_lib_save_LIBS=$LIBS
9089 > LIBS="-lintl  $LIBS"
9090 > cat >conftest.$ac_ext <<_ACEOF
9091 > /* confdefs.h.  */
9092 > _ACEOF
9093 > cat confdefs.h >>conftest.$ac_ext
9094 > cat >>conftest.$ac_ext <<_ACEOF
9095 > /* end confdefs.h.  */
9096 >
9097 > /* Override any gcc2 internal prototype to avoid an error.  */
9098 > #ifdef __cplusplus
9099 > extern "C"
9100 > #endif
9101 > /* We use char because int might match the return type of a gcc2
9102 >   builtin and then its argument prototype would still apply.  */
9103 > char strftime ();
9104 > #ifdef FC_DUMMY_MAIN
9105 > #ifndef FC_DUMMY_MAIN_EQ_F77
9106 > #  ifdef __cplusplus
9107 >     extern "C"
9108 > #  endif
9109 >   int FC_DUMMY_MAIN() { return 1; }
9110 > #endif
9111 > #endif
9112 > int
9113 > main ()
9114 > {
9115 > strftime ();
9116 >  ;
9117 >  return 0;
9118 > }
9119 > _ACEOF
9120 > rm -f conftest.$ac_objext conftest$ac_exeext
9121 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9122 >  (eval $ac_link) 2>conftest.er1
9123 >  ac_status=$?
9124 >  grep -v '^ *+' conftest.er1 >conftest.err
9125 >  rm -f conftest.er1
9126 >  cat conftest.err >&5
9127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9128 >  (exit $ac_status); } &&
9129 >         { ac_try='test -z "$ac_c_werror_flag"
9130 >                         || test ! -s conftest.err'
9131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9132 >  (eval $ac_try) 2>&5
9133 >  ac_status=$?
9134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9135 >  (exit $ac_status); }; } &&
9136 >         { ac_try='test -s conftest$ac_exeext'
9137 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9138 >  (eval $ac_try) 2>&5
9139 >  ac_status=$?
9140 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9141 >  (exit $ac_status); }; }; then
9142 >  ac_cv_lib_intl_strftime=yes
9143 > else
9144 >  echo "$as_me: failed program was:" >&5
9145 > sed 's/^/| /' conftest.$ac_ext >&5
9146 >
9147 > ac_cv_lib_intl_strftime=no
9148 > fi
9149 > rm -f conftest.err conftest.$ac_objext \
9150 >      conftest$ac_exeext conftest.$ac_ext
9151 > LIBS=$ac_check_lib_save_LIBS
9152 > fi
9153 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9154 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9155 > if test $ac_cv_lib_intl_strftime = yes; then
9156 >  cat >>confdefs.h <<\_ACEOF
9157 > #define HAVE_STRFTIME 1
9158 > _ACEOF
9159 >
9160 > LIBS="-lintl $LIBS"
9161 > fi
9162 >
9163 > fi
9164 > done
9165 >
9166 > echo "$as_me:$LINENO: checking for working strtod" >&5
9167 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9168 > if test "${ac_cv_func_strtod+set}" = set; then
9169 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9170 > else
9171 >  if test "$cross_compiling" = yes; then
9172 >  ac_cv_func_strtod=no
9173 > else
9174 >  cat >conftest.$ac_ext <<_ACEOF
9175 > /* confdefs.h.  */
9176 > _ACEOF
9177 > cat confdefs.h >>conftest.$ac_ext
9178 > cat >>conftest.$ac_ext <<_ACEOF
9179 > /* end confdefs.h.  */
9180 >
9181 > double strtod ();
9182 > int
9183 > main()
9184 > {
9185 >  {
9186 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9187 >    char *string = " +69";
9188 >    char *term;
9189 >    double value;
9190 >    value = strtod (string, &term);
9191 >    if (value != 69 || term != (string + 4))
9192 >      exit (1);
9193 >  }
9194 >
9195 >  {
9196 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9197 >       terminating character under some conditions.  */
9198 >    char *string = "NaN";
9199 >    char *term;
9200 >    strtod (string, &term);
9201 >    if (term != string && *(term - 1) == 0)
9202 >      exit (1);
9203 >  }
9204 >  exit (0);
9205 > }
9206 >
9207 > _ACEOF
9208 > rm -f conftest$ac_exeext
9209 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9210 >  (eval $ac_link) 2>&5
9211 >  ac_status=$?
9212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9213 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9214 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9215 >  (eval $ac_try) 2>&5
9216 >  ac_status=$?
9217 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9218 >  (exit $ac_status); }; }; then
9219 >  ac_cv_func_strtod=yes
9220 > else
9221 >  echo "$as_me: program exited with status $ac_status" >&5
9222 > echo "$as_me: failed program was:" >&5
9223 > sed 's/^/| /' conftest.$ac_ext >&5
9224 >
9225 > ( exit $ac_status )
9226 > ac_cv_func_strtod=no
9227 > fi
9228 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9229 > fi
9230 > fi
9231 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9232 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9233 > if test $ac_cv_func_strtod = no; then
9234 >  case $LIBOBJS in
9235 >    "strtod.$ac_objext"   | \
9236 >  *" strtod.$ac_objext"   | \
9237 >    "strtod.$ac_objext "* | \
9238 >  *" strtod.$ac_objext "* ) ;;
9239 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9240 > esac
9241 >
9242 > echo "$as_me:$LINENO: checking for pow" >&5
9243 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9244 > if test "${ac_cv_func_pow+set}" = set; then
9245 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9246 > else
9247 >  cat >conftest.$ac_ext <<_ACEOF
9248 > /* confdefs.h.  */
9249 > _ACEOF
9250 > cat confdefs.h >>conftest.$ac_ext
9251 > cat >>conftest.$ac_ext <<_ACEOF
9252 > /* end confdefs.h.  */
9253 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9254 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9255 > #define pow innocuous_pow
9256 >
9257 > /* System header to define __stub macros and hopefully few prototypes,
9258 >    which can conflict with char pow (); below.
9259 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9260 >    <limits.h> exists even on freestanding compilers.  */
9261 >
9262 > #ifdef __STDC__
9263 > # include <limits.h>
9264 > #else
9265 > # include <assert.h>
9266 > #endif
9267 >
9268 > #undef pow
9269 >
9270 > /* Override any gcc2 internal prototype to avoid an error.  */
9271 > #ifdef __cplusplus
9272 > extern "C"
9273 > {
9274 > #endif
9275 > /* We use char because int might match the return type of a gcc2
9276 >   builtin and then its argument prototype would still apply.  */
9277 > char pow ();
9278 > /* The GNU C library defines this for functions which it implements
9279 >    to always fail with ENOSYS.  Some functions are actually named
9280 >    something starting with __ and the normal name is an alias.  */
9281 > #if defined (__stub_pow) || defined (__stub___pow)
9282 > choke me
9283 > #else
9284 > char (*f) () = pow;
9285 > #endif
9286 > #ifdef __cplusplus
9287 > }
9288 > #endif
9289 >
9290 > #ifdef FC_DUMMY_MAIN
9291 > #ifndef FC_DUMMY_MAIN_EQ_F77
9292 > #  ifdef __cplusplus
9293 >     extern "C"
9294 > #  endif
9295 >   int FC_DUMMY_MAIN() { return 1; }
9296 > #endif
9297 > #endif
9298 > int
9299 > main ()
9300 > {
9301 > return f != pow;
9302 >  ;
9303 >  return 0;
9304 > }
9305 > _ACEOF
9306 > rm -f conftest.$ac_objext conftest$ac_exeext
9307 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9308 >  (eval $ac_link) 2>conftest.er1
9309 >  ac_status=$?
9310 >  grep -v '^ *+' conftest.er1 >conftest.err
9311 >  rm -f conftest.er1
9312 >  cat conftest.err >&5
9313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314 >  (exit $ac_status); } &&
9315 >         { ac_try='test -z "$ac_c_werror_flag"
9316 >                         || test ! -s conftest.err'
9317 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9318 >  (eval $ac_try) 2>&5
9319 >  ac_status=$?
9320 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9321 >  (exit $ac_status); }; } &&
9322 >         { ac_try='test -s conftest$ac_exeext'
9323 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9324 >  (eval $ac_try) 2>&5
9325 >  ac_status=$?
9326 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9327 >  (exit $ac_status); }; }; then
9328 >  ac_cv_func_pow=yes
9329 > else
9330 >  echo "$as_me: failed program was:" >&5
9331 > sed 's/^/| /' conftest.$ac_ext >&5
9332 >
9333 > ac_cv_func_pow=no
9334 > fi
9335 > rm -f conftest.err conftest.$ac_objext \
9336 >      conftest$ac_exeext conftest.$ac_ext
9337 > fi
9338 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9339 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9340 >
9341 > if test $ac_cv_func_pow = no; then
9342 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9343 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9344 > if test "${ac_cv_lib_m_pow+set}" = set; then
9345 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9346 > else
9347 >  ac_check_lib_save_LIBS=$LIBS
9348 > LIBS="-lm  $LIBS"
9349 > cat >conftest.$ac_ext <<_ACEOF
9350 > /* confdefs.h.  */
9351 > _ACEOF
9352 > cat confdefs.h >>conftest.$ac_ext
9353 > cat >>conftest.$ac_ext <<_ACEOF
9354 > /* end confdefs.h.  */
9355 >
9356 > /* Override any gcc2 internal prototype to avoid an error.  */
9357 > #ifdef __cplusplus
9358 > extern "C"
9359 > #endif
9360 > /* We use char because int might match the return type of a gcc2
9361 >   builtin and then its argument prototype would still apply.  */
9362 > char pow ();
9363 > #ifdef FC_DUMMY_MAIN
9364 > #ifndef FC_DUMMY_MAIN_EQ_F77
9365 > #  ifdef __cplusplus
9366 >     extern "C"
9367 > #  endif
9368 >   int FC_DUMMY_MAIN() { return 1; }
9369 > #endif
9370 > #endif
9371 > int
9372 > main ()
9373 > {
9374 > pow ();
9375 >  ;
9376 >  return 0;
9377 > }
9378 > _ACEOF
9379 > rm -f conftest.$ac_objext conftest$ac_exeext
9380 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9381 >  (eval $ac_link) 2>conftest.er1
9382 >  ac_status=$?
9383 >  grep -v '^ *+' conftest.er1 >conftest.err
9384 >  rm -f conftest.er1
9385 >  cat conftest.err >&5
9386 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9387 >  (exit $ac_status); } &&
9388 >         { ac_try='test -z "$ac_c_werror_flag"
9389 >                         || test ! -s conftest.err'
9390 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9391 >  (eval $ac_try) 2>&5
9392 >  ac_status=$?
9393 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9394 >  (exit $ac_status); }; } &&
9395 >         { ac_try='test -s conftest$ac_exeext'
9396 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9397 >  (eval $ac_try) 2>&5
9398 >  ac_status=$?
9399 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9400 >  (exit $ac_status); }; }; then
9401 >  ac_cv_lib_m_pow=yes
9402 > else
9403 >  echo "$as_me: failed program was:" >&5
9404 > sed 's/^/| /' conftest.$ac_ext >&5
9405 >
9406 > ac_cv_lib_m_pow=no
9407 > fi
9408 > rm -f conftest.err conftest.$ac_objext \
9409 >      conftest$ac_exeext conftest.$ac_ext
9410 > LIBS=$ac_check_lib_save_LIBS
9411 > fi
9412 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9413 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9414 > if test $ac_cv_lib_m_pow = yes; then
9415 >  POW_LIB=-lm
9416 > else
9417 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9418 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9419 > fi
9420 >
9421 > fi
9422 >
9423 > fi
9424 >
9425 >
9426 >
9427 >
9428 >
9429 >
9430 >
9431 >
9432 >
9433 >
9434 >
9435 >
9436 >
9437 >
9438 >
9439 >
9440 >
9441 >
9442 >
9443 >
9444 >
9445 >
9446 >
9447 >
9448 >
9449 >
9450 >
9451 >
9452 > 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
9453 > do
9454 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9455 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9456 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9457 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9458 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9459 > else
9460 >  cat >conftest.$ac_ext <<_ACEOF
9461 > /* confdefs.h.  */
9462 > _ACEOF
9463 > cat confdefs.h >>conftest.$ac_ext
9464 > cat >>conftest.$ac_ext <<_ACEOF
9465 > /* end confdefs.h.  */
9466 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9467 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9468 > #define $ac_func innocuous_$ac_func
9469 >
9470 > /* System header to define __stub macros and hopefully few prototypes,
9471 >    which can conflict with char $ac_func (); below.
9472 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9473 >    <limits.h> exists even on freestanding compilers.  */
9474 >
9475 > #ifdef __STDC__
9476 > # include <limits.h>
9477 > #else
9478 > # include <assert.h>
9479 > #endif
9480 >
9481 > #undef $ac_func
9482 >
9483 > /* Override any gcc2 internal prototype to avoid an error.  */
9484 > #ifdef __cplusplus
9485 > extern "C"
9486 > {
9487 > #endif
9488 > /* We use char because int might match the return type of a gcc2
9489 >   builtin and then its argument prototype would still apply.  */
9490 > char $ac_func ();
9491 > /* The GNU C library defines this for functions which it implements
9492 >    to always fail with ENOSYS.  Some functions are actually named
9493 >    something starting with __ and the normal name is an alias.  */
9494 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9495 > choke me
9496 > #else
9497 > char (*f) () = $ac_func;
9498 > #endif
9499 > #ifdef __cplusplus
9500 > }
9501 > #endif
9502 >
9503 > #ifdef FC_DUMMY_MAIN
9504 > #ifndef FC_DUMMY_MAIN_EQ_F77
9505 > #  ifdef __cplusplus
9506 >     extern "C"
9507 > #  endif
9508 >   int FC_DUMMY_MAIN() { return 1; }
9509 > #endif
9510 > #endif
9511 > int
9512 > main ()
9513 > {
9514 > return f != $ac_func;
9515 >  ;
9516 >  return 0;
9517 > }
9518 > _ACEOF
9519 > rm -f conftest.$ac_objext conftest$ac_exeext
9520 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9521 >  (eval $ac_link) 2>conftest.er1
9522 >  ac_status=$?
9523 >  grep -v '^ *+' conftest.er1 >conftest.err
9524 >  rm -f conftest.er1
9525 >  cat conftest.err >&5
9526 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9527 >  (exit $ac_status); } &&
9528 >         { ac_try='test -z "$ac_c_werror_flag"
9529 >                         || test ! -s conftest.err'
9530 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9531 >  (eval $ac_try) 2>&5
9532 >  ac_status=$?
9533 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9534 >  (exit $ac_status); }; } &&
9535 >         { ac_try='test -s conftest$ac_exeext'
9536 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9537 >  (eval $ac_try) 2>&5
9538 >  ac_status=$?
9539 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9540 >  (exit $ac_status); }; }; then
9541 >  eval "$as_ac_var=yes"
9542 > else
9543 >  echo "$as_me: failed program was:" >&5
9544 > sed 's/^/| /' conftest.$ac_ext >&5
9545 >
9546 > eval "$as_ac_var=no"
9547 > fi
9548 > rm -f conftest.err conftest.$ac_objext \
9549 >      conftest$ac_exeext conftest.$ac_ext
9550 > fi
9551 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9552 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9553 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9554 >  cat >>confdefs.h <<_ACEOF
9555 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9556 > _ACEOF
9557 >
9558 > fi
9559 > done
9560 >
9561 >
9562 > # special check for _system_configuration because AIX <4.3.2 do not
9563 > # contain the `physmem' member.
9564 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9565 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9566 > cat >conftest.$ac_ext <<_ACEOF
9567 > /* confdefs.h.  */
9568 > _ACEOF
9569 > cat confdefs.h >>conftest.$ac_ext
9570 > cat >>conftest.$ac_ext <<_ACEOF
9571 > /* end confdefs.h.  */
9572 > #include <sys/systemcfg.h>
9573 > #ifdef FC_DUMMY_MAIN
9574 > #ifndef FC_DUMMY_MAIN_EQ_F77
9575 > #  ifdef __cplusplus
9576 >     extern "C"
9577 > #  endif
9578 >   int FC_DUMMY_MAIN() { return 1; }
9579 > #endif
9580 > #endif
9581 > int
9582 > main ()
9583 > {
9584 > double x = _system_configuration.physmem;
9585 >  ;
9586 >  return 0;
9587 > }
9588 > _ACEOF
9589 > rm -f conftest.$ac_objext
9590 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9591 >  (eval $ac_compile) 2>conftest.er1
9592 >  ac_status=$?
9593 >  grep -v '^ *+' conftest.er1 >conftest.err
9594 >  rm -f conftest.er1
9595 >  cat conftest.err >&5
9596 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9597 >  (exit $ac_status); } &&
9598 >         { ac_try='test -z "$ac_c_werror_flag"
9599 >                         || test ! -s conftest.err'
9600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9601 >  (eval $ac_try) 2>&5
9602 >  ac_status=$?
9603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9604 >  (exit $ac_status); }; } &&
9605 >         { ac_try='test -s conftest.$ac_objext'
9606 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9607 >  (eval $ac_try) 2>&5
9608 >  ac_status=$?
9609 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9610 >  (exit $ac_status); }; }; then
9611 >  echo "$as_me:$LINENO: result: yes" >&5
9612 > echo "${ECHO_T}yes" >&6
9613 >
9614 > cat >>confdefs.h <<\_ACEOF
9615 > #define HAVE__SYSTEM_CONFIGURATION 1
9616 > _ACEOF
9617 >
9618 > else
9619 >  echo "$as_me: failed program was:" >&5
9620 > sed 's/^/| /' conftest.$ac_ext >&5
9621 >
9622 > echo "$as_me:$LINENO: result: no" >&5
9623 > echo "${ECHO_T}no" >&6
9624 > fi
9625 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9626 >
9627 >  # clean out junk possibly left behind by a previous configuration
9628 >  rm -f src/getopt.h
9629 >  # Check for getopt_long support
9630 >
9631 > for ac_header in getopt.h
9632 > do
9633 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9634 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9635 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9636 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9637 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9639 > fi
9640 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9641 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9642 > else
9643 >  # Is the header compilable?
9644 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9645 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9646 > cat >conftest.$ac_ext <<_ACEOF
9647 > /* confdefs.h.  */
9648 > _ACEOF
9649 > cat confdefs.h >>conftest.$ac_ext
9650 > cat >>conftest.$ac_ext <<_ACEOF
9651 > /* end confdefs.h.  */
9652 > $ac_includes_default
9653 > #include <$ac_header>
9654 > _ACEOF
9655 > rm -f conftest.$ac_objext
9656 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9657 >  (eval $ac_compile) 2>conftest.er1
9658 >  ac_status=$?
9659 >  grep -v '^ *+' conftest.er1 >conftest.err
9660 >  rm -f conftest.er1
9661 >  cat conftest.err >&5
9662 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9663 >  (exit $ac_status); } &&
9664 >         { ac_try='test -z "$ac_c_werror_flag"
9665 >                         || test ! -s conftest.err'
9666 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9667 >  (eval $ac_try) 2>&5
9668 >  ac_status=$?
9669 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9670 >  (exit $ac_status); }; } &&
9671 >         { ac_try='test -s conftest.$ac_objext'
9672 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9673 >  (eval $ac_try) 2>&5
9674 >  ac_status=$?
9675 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9676 >  (exit $ac_status); }; }; then
9677 >  ac_header_compiler=yes
9678 > else
9679 >  echo "$as_me: failed program was:" >&5
9680 > sed 's/^/| /' conftest.$ac_ext >&5
9681 >
9682 > ac_header_compiler=no
9683 > fi
9684 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9685 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9686 > echo "${ECHO_T}$ac_header_compiler" >&6
9687 >
9688 > # Is the header present?
9689 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9690 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9691 > cat >conftest.$ac_ext <<_ACEOF
9692 > /* confdefs.h.  */
9693 > _ACEOF
9694 > cat confdefs.h >>conftest.$ac_ext
9695 > cat >>conftest.$ac_ext <<_ACEOF
9696 > /* end confdefs.h.  */
9697 > #include <$ac_header>
9698 > _ACEOF
9699 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9700 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9701 >  ac_status=$?
9702 >  grep -v '^ *+' conftest.er1 >conftest.err
9703 >  rm -f conftest.er1
9704 >  cat conftest.err >&5
9705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9706 >  (exit $ac_status); } >/dev/null; then
9707 >  if test -s conftest.err; then
9708 >    ac_cpp_err=$ac_c_preproc_warn_flag
9709 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9710 >  else
9711 >    ac_cpp_err=
9712 >  fi
9713 > else
9714 >  ac_cpp_err=yes
9715 > fi
9716 > if test -z "$ac_cpp_err"; then
9717 >  ac_header_preproc=yes
9718 > else
9719 >  echo "$as_me: failed program was:" >&5
9720 > sed 's/^/| /' conftest.$ac_ext >&5
9721 >
9722 >  ac_header_preproc=no
9723 > fi
9724 > rm -f conftest.err conftest.$ac_ext
9725 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9726 > echo "${ECHO_T}$ac_header_preproc" >&6
9727 >
9728 > # So?  What about this header?
9729 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9730 >  yes:no: )
9731 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9732 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9733 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9734 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9735 >    ac_header_preproc=yes
9736 >    ;;
9737 >  no:yes:* )
9738 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9739 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9740 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9741 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9742 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9743 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9744 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9745 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9746 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9747 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9748 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9749 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9750 >    (
9751 >      cat <<\_ASBOX
9752 > ## ------------------------------ ##
9753 > ## Report this to gezelter@nd.edu ##
9754 > ## ------------------------------ ##
9755 > _ASBOX
9756 >    ) |
9757 >      sed "s/^/$as_me: WARNING:     /" >&2
9758 >    ;;
9759 > esac
9760 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9761 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9762 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9763 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9764 > else
9765 >  eval "$as_ac_Header=\$ac_header_preproc"
9766 > fi
9767 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9768 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9769 >
9770 > fi
9771 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9772 >  cat >>confdefs.h <<_ACEOF
9773 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9774 > _ACEOF
9775 >
9776 > fi
9777 >
9778 > done
9779 >
9780 >
9781 > for ac_func in getopt_long
9782 > do
9783 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9784 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9785 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9786 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9787 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9788 > else
9789 >  cat >conftest.$ac_ext <<_ACEOF
9790 > /* confdefs.h.  */
9791 > _ACEOF
9792 > cat confdefs.h >>conftest.$ac_ext
9793 > cat >>conftest.$ac_ext <<_ACEOF
9794 > /* end confdefs.h.  */
9795 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9796 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9797 > #define $ac_func innocuous_$ac_func
9798 >
9799 > /* System header to define __stub macros and hopefully few prototypes,
9800 >    which can conflict with char $ac_func (); below.
9801 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9802 >    <limits.h> exists even on freestanding compilers.  */
9803 >
9804 > #ifdef __STDC__
9805 > # include <limits.h>
9806 > #else
9807 > # include <assert.h>
9808 > #endif
9809 >
9810 > #undef $ac_func
9811 >
9812 > /* Override any gcc2 internal prototype to avoid an error.  */
9813 > #ifdef __cplusplus
9814 > extern "C"
9815 > {
9816 > #endif
9817 > /* We use char because int might match the return type of a gcc2
9818 >   builtin and then its argument prototype would still apply.  */
9819 > char $ac_func ();
9820 > /* The GNU C library defines this for functions which it implements
9821 >    to always fail with ENOSYS.  Some functions are actually named
9822 >    something starting with __ and the normal name is an alias.  */
9823 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9824 > choke me
9825 > #else
9826 > char (*f) () = $ac_func;
9827 > #endif
9828 > #ifdef __cplusplus
9829 > }
9830 > #endif
9831 >
9832 > #ifdef FC_DUMMY_MAIN
9833 > #ifndef FC_DUMMY_MAIN_EQ_F77
9834 > #  ifdef __cplusplus
9835 >     extern "C"
9836 > #  endif
9837 >   int FC_DUMMY_MAIN() { return 1; }
9838 > #endif
9839 > #endif
9840 > int
9841 > main ()
9842 > {
9843 > return f != $ac_func;
9844 >  ;
9845 >  return 0;
9846 > }
9847 > _ACEOF
9848 > rm -f conftest.$ac_objext conftest$ac_exeext
9849 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9850 >  (eval $ac_link) 2>conftest.er1
9851 >  ac_status=$?
9852 >  grep -v '^ *+' conftest.er1 >conftest.err
9853 >  rm -f conftest.er1
9854 >  cat conftest.err >&5
9855 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9856 >  (exit $ac_status); } &&
9857 >         { ac_try='test -z "$ac_c_werror_flag"
9858 >                         || test ! -s conftest.err'
9859 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9860 >  (eval $ac_try) 2>&5
9861 >  ac_status=$?
9862 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9863 >  (exit $ac_status); }; } &&
9864 >         { ac_try='test -s conftest$ac_exeext'
9865 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9866 >  (eval $ac_try) 2>&5
9867 >  ac_status=$?
9868 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9869 >  (exit $ac_status); }; }; then
9870 >  eval "$as_ac_var=yes"
9871 > else
9872 >  echo "$as_me: failed program was:" >&5
9873 > sed 's/^/| /' conftest.$ac_ext >&5
9874 >
9875 > eval "$as_ac_var=no"
9876 > fi
9877 > rm -f conftest.err conftest.$ac_objext \
9878 >      conftest$ac_exeext conftest.$ac_ext
9879 > fi
9880 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9881 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9882 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9883 >  cat >>confdefs.h <<_ACEOF
9884 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9885 > _ACEOF
9886 >
9887 > else
9888 >  # FreeBSD has a gnugetopt library for this
9889 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9890 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9891 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9892 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9893 > else
9894 >  ac_check_lib_save_LIBS=$LIBS
9895 > LIBS="-lgnugetopt  $LIBS"
9896 > cat >conftest.$ac_ext <<_ACEOF
9897 > /* confdefs.h.  */
9898 > _ACEOF
9899 > cat confdefs.h >>conftest.$ac_ext
9900 > cat >>conftest.$ac_ext <<_ACEOF
9901 > /* end confdefs.h.  */
9902 >
9903 > /* Override any gcc2 internal prototype to avoid an error.  */
9904 > #ifdef __cplusplus
9905 > extern "C"
9906 > #endif
9907 > /* We use char because int might match the return type of a gcc2
9908 >   builtin and then its argument prototype would still apply.  */
9909 > char getopt_long ();
9910 > #ifdef FC_DUMMY_MAIN
9911 > #ifndef FC_DUMMY_MAIN_EQ_F77
9912 > #  ifdef __cplusplus
9913 >     extern "C"
9914 > #  endif
9915 >   int FC_DUMMY_MAIN() { return 1; }
9916 > #endif
9917 > #endif
9918 > int
9919 > main ()
9920 > {
9921 > getopt_long ();
9922 >  ;
9923 >  return 0;
9924 > }
9925 > _ACEOF
9926 > rm -f conftest.$ac_objext conftest$ac_exeext
9927 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9928 >  (eval $ac_link) 2>conftest.er1
9929 >  ac_status=$?
9930 >  grep -v '^ *+' conftest.er1 >conftest.err
9931 >  rm -f conftest.er1
9932 >  cat conftest.err >&5
9933 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9934 >  (exit $ac_status); } &&
9935 >         { ac_try='test -z "$ac_c_werror_flag"
9936 >                         || test ! -s conftest.err'
9937 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9938 >  (eval $ac_try) 2>&5
9939 >  ac_status=$?
9940 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9941 >  (exit $ac_status); }; } &&
9942 >         { ac_try='test -s conftest$ac_exeext'
9943 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9944 >  (eval $ac_try) 2>&5
9945 >  ac_status=$?
9946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9947 >  (exit $ac_status); }; }; then
9948 >  ac_cv_lib_gnugetopt_getopt_long=yes
9949 > else
9950 >  echo "$as_me: failed program was:" >&5
9951 > sed 's/^/| /' conftest.$ac_ext >&5
9952 >
9953 > ac_cv_lib_gnugetopt_getopt_long=no
9954 > fi
9955 > rm -f conftest.err conftest.$ac_objext \
9956 >      conftest$ac_exeext conftest.$ac_ext
9957 > LIBS=$ac_check_lib_save_LIBS
9958 > fi
9959 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9960 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9961 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9962 >  cat >>confdefs.h <<\_ACEOF
9963 > #define HAVE_GETOPT_LONG 1
9964 > _ACEOF
9965 >
9966 > else
9967 >  # use the GNU replacement
9968 >      case $LIBOBJS in
9969 >    "getopt.$ac_objext"   | \
9970 >  *" getopt.$ac_objext"   | \
9971 >    "getopt.$ac_objext "* | \
9972 >  *" getopt.$ac_objext "* ) ;;
9973 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9974 > esac
9975 >
9976 >      case $LIBOBJS in
9977 >    "getopt1.$ac_objext"   | \
9978 >  *" getopt1.$ac_objext"   | \
9979 >    "getopt1.$ac_objext "* | \
9980 >  *" getopt1.$ac_objext "* ) ;;
9981 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9982 > esac
9983 >
9984 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9985 >
9986 > fi
9987 >
9988 > fi
9989 > done
9990 >
9991 >
9992 > ac_ext=cc
9993 > ac_cpp='$CXXCPP $CPPFLAGS'
9994 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9995 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9996 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9997 >
9998 >
9999 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10000 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10001 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10002 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10003 > else
10004 >
10005 >
10006 > ac_ext=cc
10007 > ac_cpp='$CXXCPP $CPPFLAGS'
10008 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10009 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10010 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10011 >
10012 > cat >conftest.$ac_ext <<_ACEOF
10013 > /* confdefs.h.  */
10014 > _ACEOF
10015 > cat confdefs.h >>conftest.$ac_ext
10016 > cat >>conftest.$ac_ext <<_ACEOF
10017 > /* end confdefs.h.  */
10018 > namespace Outer { namespace Inner { int i = 0; }}
10019 > #ifdef FC_DUMMY_MAIN
10020 > #ifndef FC_DUMMY_MAIN_EQ_F77
10021 > #  ifdef __cplusplus
10022 >     extern "C"
10023 > #  endif
10024 >   int FC_DUMMY_MAIN() { return 1; }
10025 > #endif
10026 > #endif
10027 > int
10028 > main ()
10029 > {
10030 > using namespace Outer::Inner; return i;
10031 >  ;
10032 >  return 0;
10033 > }
10034 > _ACEOF
10035 > rm -f conftest.$ac_objext
10036 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10037 >  (eval $ac_compile) 2>conftest.er1
10038 >  ac_status=$?
10039 >  grep -v '^ *+' conftest.er1 >conftest.err
10040 >  rm -f conftest.er1
10041 >  cat conftest.err >&5
10042 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10043 >  (exit $ac_status); } &&
10044 >         { ac_try='test -z "$ac_cxx_werror_flag"
10045 >                         || test ! -s conftest.err'
10046 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10047 >  (eval $ac_try) 2>&5
10048 >  ac_status=$?
10049 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10050 >  (exit $ac_status); }; } &&
10051 >         { ac_try='test -s conftest.$ac_objext'
10052 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10053 >  (eval $ac_try) 2>&5
10054 >  ac_status=$?
10055 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10056 >  (exit $ac_status); }; }; then
10057 >  ac_cv_cxx_namespaces=yes
10058 > else
10059 >  echo "$as_me: failed program was:" >&5
10060 > sed 's/^/| /' conftest.$ac_ext >&5
10061 >
10062 > ac_cv_cxx_namespaces=no
10063 > fi
10064 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10065 > ac_ext=cc
10066 > ac_cpp='$CXXCPP $CPPFLAGS'
10067 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10068 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10069 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10070 >
10071 >
10072 > fi
10073 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10074 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10075 > if test "$ac_cv_cxx_namespaces" = yes; then
10076 >
10077 > cat >>confdefs.h <<\_ACEOF
10078 > #define HAVE_NAMESPACES
10079 > _ACEOF
10080 >
10081 > fi
10082 >
10083 > ac_ext=cc
10084 > ac_cpp='$CXXCPP $CPPFLAGS'
10085 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10086 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10087 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10088 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10089 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10090 > if test -z "$CXXCPP"; then
10091 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10092 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10093 > else
10094 >      # Double quotes because CXXCPP needs to be expanded
10095 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10096 >    do
10097 >      ac_preproc_ok=false
10098 > for ac_cxx_preproc_warn_flag in '' yes
10099 > do
10100 >  # Use a header file that comes with gcc, so configuring glibc
10101 >  # with a fresh cross-compiler works.
10102 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10103 >  # <limits.h> exists even on freestanding compilers.
10104 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10105 >  # not just through cpp. "Syntax error" is here to catch this case.
10106 >  cat >conftest.$ac_ext <<_ACEOF
10107 > /* confdefs.h.  */
10108 > _ACEOF
10109 > cat confdefs.h >>conftest.$ac_ext
10110 > cat >>conftest.$ac_ext <<_ACEOF
10111 > /* end confdefs.h.  */
10112 > #ifdef __STDC__
10113 > # include <limits.h>
10114 > #else
10115 > # include <assert.h>
10116 > #endif
10117 >                     Syntax error
10118 > _ACEOF
10119 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10120 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10121 >  ac_status=$?
10122 >  grep -v '^ *+' conftest.er1 >conftest.err
10123 >  rm -f conftest.er1
10124 >  cat conftest.err >&5
10125 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10126 >  (exit $ac_status); } >/dev/null; then
10127 >  if test -s conftest.err; then
10128 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10129 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10130 >  else
10131 >    ac_cpp_err=
10132 >  fi
10133 > else
10134 >  ac_cpp_err=yes
10135 > fi
10136 > if test -z "$ac_cpp_err"; then
10137 >  :
10138 > else
10139 >  echo "$as_me: failed program was:" >&5
10140 > sed 's/^/| /' conftest.$ac_ext >&5
10141 >
10142 >  # Broken: fails on valid input.
10143 > continue
10144 > fi
10145 > rm -f conftest.err conftest.$ac_ext
10146 >
10147 >  # OK, works on sane cases.  Now check whether non-existent headers
10148 >  # can be detected and how.
10149 >  cat >conftest.$ac_ext <<_ACEOF
10150 > /* confdefs.h.  */
10151 > _ACEOF
10152 > cat confdefs.h >>conftest.$ac_ext
10153 > cat >>conftest.$ac_ext <<_ACEOF
10154 > /* end confdefs.h.  */
10155 > #include <ac_nonexistent.h>
10156 > _ACEOF
10157 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10158 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10159 >  ac_status=$?
10160 >  grep -v '^ *+' conftest.er1 >conftest.err
10161 >  rm -f conftest.er1
10162 >  cat conftest.err >&5
10163 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10164 >  (exit $ac_status); } >/dev/null; then
10165 >  if test -s conftest.err; then
10166 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10167 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10168 >  else
10169 >    ac_cpp_err=
10170 >  fi
10171 > else
10172 >  ac_cpp_err=yes
10173 > fi
10174 > if test -z "$ac_cpp_err"; then
10175 >  # Broken: success on invalid input.
10176 > continue
10177 > else
10178 >  echo "$as_me: failed program was:" >&5
10179 > sed 's/^/| /' conftest.$ac_ext >&5
10180 >
10181 >  # Passes both tests.
10182 > ac_preproc_ok=:
10183 > break
10184 > fi
10185 > rm -f conftest.err conftest.$ac_ext
10186 >
10187 > done
10188 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10189 > rm -f conftest.err conftest.$ac_ext
10190 > if $ac_preproc_ok; then
10191 >  break
10192 > fi
10193 >
10194 >    done
10195 >    ac_cv_prog_CXXCPP=$CXXCPP
10196 >
10197 > fi
10198 >  CXXCPP=$ac_cv_prog_CXXCPP
10199 > else
10200 >  ac_cv_prog_CXXCPP=$CXXCPP
10201 > fi
10202 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10203 > echo "${ECHO_T}$CXXCPP" >&6
10204 > ac_preproc_ok=false
10205 > for ac_cxx_preproc_warn_flag in '' yes
10206 > do
10207 >  # Use a header file that comes with gcc, so configuring glibc
10208 >  # with a fresh cross-compiler works.
10209 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10210 >  # <limits.h> exists even on freestanding compilers.
10211 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10212 >  # not just through cpp. "Syntax error" is here to catch this case.
10213 >  cat >conftest.$ac_ext <<_ACEOF
10214 > /* confdefs.h.  */
10215 > _ACEOF
10216 > cat confdefs.h >>conftest.$ac_ext
10217 > cat >>conftest.$ac_ext <<_ACEOF
10218 > /* end confdefs.h.  */
10219 > #ifdef __STDC__
10220 > # include <limits.h>
10221 > #else
10222 > # include <assert.h>
10223 > #endif
10224 >                     Syntax error
10225 > _ACEOF
10226 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10227 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10228 >  ac_status=$?
10229 >  grep -v '^ *+' conftest.er1 >conftest.err
10230 >  rm -f conftest.er1
10231 >  cat conftest.err >&5
10232 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10233 >  (exit $ac_status); } >/dev/null; then
10234 >  if test -s conftest.err; then
10235 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10236 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10237 >  else
10238 >    ac_cpp_err=
10239 >  fi
10240 > else
10241 >  ac_cpp_err=yes
10242 > fi
10243 > if test -z "$ac_cpp_err"; then
10244 >  :
10245 > else
10246 >  echo "$as_me: failed program was:" >&5
10247 > sed 's/^/| /' conftest.$ac_ext >&5
10248 >
10249 >  # Broken: fails on valid input.
10250 > continue
10251 > fi
10252 > rm -f conftest.err conftest.$ac_ext
10253 >
10254 >  # OK, works on sane cases.  Now check whether non-existent headers
10255 >  # can be detected and how.
10256 >  cat >conftest.$ac_ext <<_ACEOF
10257 > /* confdefs.h.  */
10258 > _ACEOF
10259 > cat confdefs.h >>conftest.$ac_ext
10260 > cat >>conftest.$ac_ext <<_ACEOF
10261 > /* end confdefs.h.  */
10262 > #include <ac_nonexistent.h>
10263 > _ACEOF
10264 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10265 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10266 >  ac_status=$?
10267 >  grep -v '^ *+' conftest.er1 >conftest.err
10268 >  rm -f conftest.er1
10269 >  cat conftest.err >&5
10270 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10271 >  (exit $ac_status); } >/dev/null; then
10272 >  if test -s conftest.err; then
10273 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10274 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10275 >  else
10276 >    ac_cpp_err=
10277 >  fi
10278 > else
10279 >  ac_cpp_err=yes
10280 > fi
10281 > if test -z "$ac_cpp_err"; then
10282 >  # Broken: success on invalid input.
10283 > continue
10284 > else
10285 >  echo "$as_me: failed program was:" >&5
10286 > sed 's/^/| /' conftest.$ac_ext >&5
10287 >
10288 >  # Passes both tests.
10289 > ac_preproc_ok=:
10290 > break
10291 > fi
10292 > rm -f conftest.err conftest.$ac_ext
10293 >
10294 > done
10295 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10296 > rm -f conftest.err conftest.$ac_ext
10297 > if $ac_preproc_ok; then
10298 >  :
10299 > else
10300 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10301 > See \`config.log' for more details." >&5
10302 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10303 > See \`config.log' for more details." >&2;}
10304 >   { (exit 1); exit 1; }; }
10305 > fi
10306 >
10307 > ac_ext=cc
10308 > ac_cpp='$CXXCPP $CPPFLAGS'
10309 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10310 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10311 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10312 >
10313 >
10314 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10315 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10316 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10317 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10318 > else
10319 >
10320 >
10321 >
10322 > ac_ext=cc
10323 > ac_cpp='$CXXCPP $CPPFLAGS'
10324 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10325 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10326 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10327 >
10328 > cat >conftest.$ac_ext <<_ACEOF
10329 > /* confdefs.h.  */
10330 > _ACEOF
10331 > cat confdefs.h >>conftest.$ac_ext
10332 > cat >>conftest.$ac_ext <<_ACEOF
10333 > /* end confdefs.h.  */
10334 > #include <list>
10335 > #include <deque>
10336 > #ifdef HAVE_NAMESPACES
10337 > using namespace std;
10338 > #endif
10339 > #ifdef FC_DUMMY_MAIN
10340 > #ifndef FC_DUMMY_MAIN_EQ_F77
10341 > #  ifdef __cplusplus
10342 >     extern "C"
10343 > #  endif
10344 >   int FC_DUMMY_MAIN() { return 1; }
10345 > #endif
10346 > #endif
10347 > int
10348 > main ()
10349 > {
10350 > list<int> x; x.push_back(5);
10351 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10352 >  ;
10353 >  return 0;
10354 > }
10355 > _ACEOF
10356 > rm -f conftest.$ac_objext
10357 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10358 >  (eval $ac_compile) 2>conftest.er1
10359 >  ac_status=$?
10360 >  grep -v '^ *+' conftest.er1 >conftest.err
10361 >  rm -f conftest.er1
10362 >  cat conftest.err >&5
10363 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10364 >  (exit $ac_status); } &&
10365 >         { ac_try='test -z "$ac_cxx_werror_flag"
10366 >                         || test ! -s conftest.err'
10367 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10368 >  (eval $ac_try) 2>&5
10369 >  ac_status=$?
10370 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10371 >  (exit $ac_status); }; } &&
10372 >         { ac_try='test -s conftest.$ac_objext'
10373 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10374 >  (eval $ac_try) 2>&5
10375 >  ac_status=$?
10376 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377 >  (exit $ac_status); }; }; then
10378 >  ac_cv_cxx_have_stl=yes
10379 > else
10380 >  echo "$as_me: failed program was:" >&5
10381 > sed 's/^/| /' conftest.$ac_ext >&5
10382 >
10383 > ac_cv_cxx_have_stl=no
10384 > fi
10385 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10386 > ac_ext=cc
10387 > ac_cpp='$CXXCPP $CPPFLAGS'
10388 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10389 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10390 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10391 >
10392 >
10393 > fi
10394 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10395 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10396 > if test "$ac_cv_cxx_have_stl" = yes; then
10397 >
10398 > cat >>confdefs.h <<\_ACEOF
10399 > #define HAVE_STL
10400 > _ACEOF
10401 >
10402 > fi
10403 >
10404 >
10405 >
10406 >  if test "${ac_cv_header_iostream+set}" = set; then
10407 >  echo "$as_me:$LINENO: checking for iostream" >&5
10408 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10409 > if test "${ac_cv_header_iostream+set}" = set; then
10410 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10411 > fi
10412 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10413 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10414 > else
10415 >  # Is the header compilable?
10416 > echo "$as_me:$LINENO: checking iostream usability" >&5
10417 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10418 > cat >conftest.$ac_ext <<_ACEOF
10419 > /* confdefs.h.  */
10420 > _ACEOF
10421 > cat confdefs.h >>conftest.$ac_ext
10422 > cat >>conftest.$ac_ext <<_ACEOF
10423 > /* end confdefs.h.  */
10424 > $ac_includes_default
10425 > #include <iostream>
10426 > _ACEOF
10427 > rm -f conftest.$ac_objext
10428 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10429 >  (eval $ac_compile) 2>conftest.er1
10430 >  ac_status=$?
10431 >  grep -v '^ *+' conftest.er1 >conftest.err
10432 >  rm -f conftest.er1
10433 >  cat conftest.err >&5
10434 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10435 >  (exit $ac_status); } &&
10436 >         { ac_try='test -z "$ac_cxx_werror_flag"
10437 >                         || test ! -s conftest.err'
10438 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10439 >  (eval $ac_try) 2>&5
10440 >  ac_status=$?
10441 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10442 >  (exit $ac_status); }; } &&
10443 >         { ac_try='test -s conftest.$ac_objext'
10444 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10445 >  (eval $ac_try) 2>&5
10446 >  ac_status=$?
10447 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10448 >  (exit $ac_status); }; }; then
10449 >  ac_header_compiler=yes
10450 > else
10451 >  echo "$as_me: failed program was:" >&5
10452 > sed 's/^/| /' conftest.$ac_ext >&5
10453 >
10454 > ac_header_compiler=no
10455 > fi
10456 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10457 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10458 > echo "${ECHO_T}$ac_header_compiler" >&6
10459 >
10460 > # Is the header present?
10461 > echo "$as_me:$LINENO: checking iostream presence" >&5
10462 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10463 > cat >conftest.$ac_ext <<_ACEOF
10464 > /* confdefs.h.  */
10465 > _ACEOF
10466 > cat confdefs.h >>conftest.$ac_ext
10467 > cat >>conftest.$ac_ext <<_ACEOF
10468 > /* end confdefs.h.  */
10469 > #include <iostream>
10470 > _ACEOF
10471 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10472 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10473 >  ac_status=$?
10474 >  grep -v '^ *+' conftest.er1 >conftest.err
10475 >  rm -f conftest.er1
10476 >  cat conftest.err >&5
10477 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10478 >  (exit $ac_status); } >/dev/null; then
10479 >  if test -s conftest.err; then
10480 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10481 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10482 >  else
10483 >    ac_cpp_err=
10484 >  fi
10485 > else
10486 >  ac_cpp_err=yes
10487 > fi
10488 > if test -z "$ac_cpp_err"; then
10489 >  ac_header_preproc=yes
10490 > else
10491 >  echo "$as_me: failed program was:" >&5
10492 > sed 's/^/| /' conftest.$ac_ext >&5
10493 >
10494 >  ac_header_preproc=no
10495 > fi
10496 > rm -f conftest.err conftest.$ac_ext
10497 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10498 > echo "${ECHO_T}$ac_header_preproc" >&6
10499 >
10500 > # So?  What about this header?
10501 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10502 >  yes:no: )
10503 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10504 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10505 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10506 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10507 >    ac_header_preproc=yes
10508 >    ;;
10509 >  no:yes:* )
10510 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10511 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10512 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10513 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10514 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10515 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10516 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10517 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10518 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10519 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10520 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10521 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10522 >    (
10523 >      cat <<\_ASBOX
10524 > ## ------------------------------ ##
10525 > ## Report this to gezelter@nd.edu ##
10526 > ## ------------------------------ ##
10527 > _ASBOX
10528 >    ) |
10529 >      sed "s/^/$as_me: WARNING:     /" >&2
10530 >    ;;
10531 > esac
10532 > echo "$as_me:$LINENO: checking for iostream" >&5
10533 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10534 > if test "${ac_cv_header_iostream+set}" = set; then
10535 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10536 > else
10537 >  ac_cv_header_iostream=$ac_header_preproc
10538 > fi
10539 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10540 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10541 >
10542 > fi
10543 > if test $ac_cv_header_iostream = yes; then
10544 >
10545 >
10546 > cat >>confdefs.h <<\_ACEOF
10547 > #define HAVE_IOSTREAM 1
10548 > _ACEOF
10549 >
10550 >
10551 > else
10552 >
10553 >
10554 > for ac_header in iostream.h
10555 > do
10556 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10557 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10558 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10559 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10560 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10561 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10562 > fi
10563 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10564 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10565 > else
10566 >  # Is the header compilable?
10567 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10568 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10569 > cat >conftest.$ac_ext <<_ACEOF
10570 > /* confdefs.h.  */
10571 > _ACEOF
10572 > cat confdefs.h >>conftest.$ac_ext
10573 > cat >>conftest.$ac_ext <<_ACEOF
10574 > /* end confdefs.h.  */
10575 > $ac_includes_default
10576 > #include <$ac_header>
10577 > _ACEOF
10578 > rm -f conftest.$ac_objext
10579 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10580 >  (eval $ac_compile) 2>conftest.er1
10581 >  ac_status=$?
10582 >  grep -v '^ *+' conftest.er1 >conftest.err
10583 >  rm -f conftest.er1
10584 >  cat conftest.err >&5
10585 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10586 >  (exit $ac_status); } &&
10587 >         { ac_try='test -z "$ac_cxx_werror_flag"
10588 >                         || test ! -s conftest.err'
10589 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10590 >  (eval $ac_try) 2>&5
10591 >  ac_status=$?
10592 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10593 >  (exit $ac_status); }; } &&
10594 >         { ac_try='test -s conftest.$ac_objext'
10595 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10596 >  (eval $ac_try) 2>&5
10597 >  ac_status=$?
10598 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10599 >  (exit $ac_status); }; }; then
10600 >  ac_header_compiler=yes
10601 > else
10602 >  echo "$as_me: failed program was:" >&5
10603 > sed 's/^/| /' conftest.$ac_ext >&5
10604 >
10605 > ac_header_compiler=no
10606 > fi
10607 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10608 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10609 > echo "${ECHO_T}$ac_header_compiler" >&6
10610 >
10611 > # Is the header present?
10612 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10613 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10614 > cat >conftest.$ac_ext <<_ACEOF
10615 > /* confdefs.h.  */
10616 > _ACEOF
10617 > cat confdefs.h >>conftest.$ac_ext
10618 > cat >>conftest.$ac_ext <<_ACEOF
10619 > /* end confdefs.h.  */
10620 > #include <$ac_header>
10621 > _ACEOF
10622 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10623 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10624 >  ac_status=$?
10625 >  grep -v '^ *+' conftest.er1 >conftest.err
10626 >  rm -f conftest.er1
10627 >  cat conftest.err >&5
10628 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10629 >  (exit $ac_status); } >/dev/null; then
10630 >  if test -s conftest.err; then
10631 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10632 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10633 >  else
10634 >    ac_cpp_err=
10635 >  fi
10636 > else
10637 >  ac_cpp_err=yes
10638 > fi
10639 > if test -z "$ac_cpp_err"; then
10640 >  ac_header_preproc=yes
10641 > else
10642 >  echo "$as_me: failed program was:" >&5
10643 > sed 's/^/| /' conftest.$ac_ext >&5
10644 >
10645 >  ac_header_preproc=no
10646 > fi
10647 > rm -f conftest.err conftest.$ac_ext
10648 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10649 > echo "${ECHO_T}$ac_header_preproc" >&6
10650 >
10651 > # So?  What about this header?
10652 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10653 >  yes:no: )
10654 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10655 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10656 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10657 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10658 >    ac_header_preproc=yes
10659 >    ;;
10660 >  no:yes:* )
10661 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10662 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10663 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10664 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10665 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10666 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10667 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10668 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10669 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10670 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10671 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10672 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10673 >    (
10674 >      cat <<\_ASBOX
10675 > ## ------------------------------ ##
10676 > ## Report this to gezelter@nd.edu ##
10677 > ## ------------------------------ ##
10678 > _ASBOX
10679 >    ) |
10680 >      sed "s/^/$as_me: WARNING:     /" >&2
10681 >    ;;
10682 > esac
10683 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10684 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10685 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10686 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10687 > else
10688 >  eval "$as_ac_Header=\$ac_header_preproc"
10689 > fi
10690 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10691 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10692 >
10693 > fi
10694 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10695 >  cat >>confdefs.h <<_ACEOF
10696 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10697 > _ACEOF
10698 >
10699 > fi
10700 >
10701 > done
10702 >
10703 >
10704 > fi
10705 >
10706 >
10707 >
10708 >
10709 >  if test "${ac_cv_header_iomanip+set}" = set; then
10710 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10711 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10712 > if test "${ac_cv_header_iomanip+set}" = set; then
10713 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10714 > fi
10715 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10716 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10717 > else
10718 >  # Is the header compilable?
10719 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10720 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10721 > cat >conftest.$ac_ext <<_ACEOF
10722 > /* confdefs.h.  */
10723 > _ACEOF
10724 > cat confdefs.h >>conftest.$ac_ext
10725 > cat >>conftest.$ac_ext <<_ACEOF
10726 > /* end confdefs.h.  */
10727 > $ac_includes_default
10728 > #include <iomanip>
10729 > _ACEOF
10730 > rm -f conftest.$ac_objext
10731 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10732 >  (eval $ac_compile) 2>conftest.er1
10733 >  ac_status=$?
10734 >  grep -v '^ *+' conftest.er1 >conftest.err
10735 >  rm -f conftest.er1
10736 >  cat conftest.err >&5
10737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10738 >  (exit $ac_status); } &&
10739 >         { ac_try='test -z "$ac_cxx_werror_flag"
10740 >                         || test ! -s conftest.err'
10741 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10742 >  (eval $ac_try) 2>&5
10743 >  ac_status=$?
10744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10745 >  (exit $ac_status); }; } &&
10746 >         { ac_try='test -s conftest.$ac_objext'
10747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10748 >  (eval $ac_try) 2>&5
10749 >  ac_status=$?
10750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10751 >  (exit $ac_status); }; }; then
10752 >  ac_header_compiler=yes
10753 > else
10754 >  echo "$as_me: failed program was:" >&5
10755 > sed 's/^/| /' conftest.$ac_ext >&5
10756 >
10757 > ac_header_compiler=no
10758 > fi
10759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10760 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10761 > echo "${ECHO_T}$ac_header_compiler" >&6
10762 >
10763 > # Is the header present?
10764 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10765 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10766 > cat >conftest.$ac_ext <<_ACEOF
10767 > /* confdefs.h.  */
10768 > _ACEOF
10769 > cat confdefs.h >>conftest.$ac_ext
10770 > cat >>conftest.$ac_ext <<_ACEOF
10771 > /* end confdefs.h.  */
10772 > #include <iomanip>
10773 > _ACEOF
10774 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10775 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10776 >  ac_status=$?
10777 >  grep -v '^ *+' conftest.er1 >conftest.err
10778 >  rm -f conftest.er1
10779 >  cat conftest.err >&5
10780 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10781 >  (exit $ac_status); } >/dev/null; then
10782 >  if test -s conftest.err; then
10783 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10784 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10785 >  else
10786 >    ac_cpp_err=
10787 >  fi
10788 > else
10789 >  ac_cpp_err=yes
10790 > fi
10791 > if test -z "$ac_cpp_err"; then
10792 >  ac_header_preproc=yes
10793 > else
10794 >  echo "$as_me: failed program was:" >&5
10795 > sed 's/^/| /' conftest.$ac_ext >&5
10796 >
10797 >  ac_header_preproc=no
10798 > fi
10799 > rm -f conftest.err conftest.$ac_ext
10800 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10801 > echo "${ECHO_T}$ac_header_preproc" >&6
10802 >
10803 > # So?  What about this header?
10804 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10805 >  yes:no: )
10806 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10807 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10808 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10809 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10810 >    ac_header_preproc=yes
10811 >    ;;
10812 >  no:yes:* )
10813 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10814 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10815 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10816 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10817 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10818 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10819 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10820 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10821 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10822 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10823 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10824 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10825 >    (
10826 >      cat <<\_ASBOX
10827 > ## ------------------------------ ##
10828 > ## Report this to gezelter@nd.edu ##
10829 > ## ------------------------------ ##
10830 > _ASBOX
10831 >    ) |
10832 >      sed "s/^/$as_me: WARNING:     /" >&2
10833 >    ;;
10834 > esac
10835 > echo "$as_me:$LINENO: checking for iomanip" >&5
10836 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10837 > if test "${ac_cv_header_iomanip+set}" = set; then
10838 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10839 > else
10840 >  ac_cv_header_iomanip=$ac_header_preproc
10841 > fi
10842 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10843 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10844 >
10845 > fi
10846 > if test $ac_cv_header_iomanip = yes; then
10847 >
10848 >
10849 > cat >>confdefs.h <<\_ACEOF
10850 > #define HAVE_IOMANIP 1
10851 > _ACEOF
10852 >
10853 >
10854 > else
10855 >
10856 >
10857 > for ac_header in iomanip.h
10858 > do
10859 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10860 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10861 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10862 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10863 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10864 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10865 > fi
10866 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10867 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10868 > else
10869 >  # Is the header compilable?
10870 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10871 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10872 > cat >conftest.$ac_ext <<_ACEOF
10873 > /* confdefs.h.  */
10874 > _ACEOF
10875 > cat confdefs.h >>conftest.$ac_ext
10876 > cat >>conftest.$ac_ext <<_ACEOF
10877 > /* end confdefs.h.  */
10878 > $ac_includes_default
10879 > #include <$ac_header>
10880 > _ACEOF
10881 > rm -f conftest.$ac_objext
10882 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10883 >  (eval $ac_compile) 2>conftest.er1
10884 >  ac_status=$?
10885 >  grep -v '^ *+' conftest.er1 >conftest.err
10886 >  rm -f conftest.er1
10887 >  cat conftest.err >&5
10888 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10889 >  (exit $ac_status); } &&
10890 >         { ac_try='test -z "$ac_cxx_werror_flag"
10891 >                         || test ! -s conftest.err'
10892 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10893 >  (eval $ac_try) 2>&5
10894 >  ac_status=$?
10895 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10896 >  (exit $ac_status); }; } &&
10897 >         { ac_try='test -s conftest.$ac_objext'
10898 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10899 >  (eval $ac_try) 2>&5
10900 >  ac_status=$?
10901 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10902 >  (exit $ac_status); }; }; then
10903 >  ac_header_compiler=yes
10904 > else
10905 >  echo "$as_me: failed program was:" >&5
10906 > sed 's/^/| /' conftest.$ac_ext >&5
10907 >
10908 > ac_header_compiler=no
10909 > fi
10910 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10911 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10912 > echo "${ECHO_T}$ac_header_compiler" >&6
10913 >
10914 > # Is the header present?
10915 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10916 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10917 > cat >conftest.$ac_ext <<_ACEOF
10918 > /* confdefs.h.  */
10919 > _ACEOF
10920 > cat confdefs.h >>conftest.$ac_ext
10921 > cat >>conftest.$ac_ext <<_ACEOF
10922 > /* end confdefs.h.  */
10923 > #include <$ac_header>
10924 > _ACEOF
10925 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10926 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10927 >  ac_status=$?
10928 >  grep -v '^ *+' conftest.er1 >conftest.err
10929 >  rm -f conftest.er1
10930 >  cat conftest.err >&5
10931 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10932 >  (exit $ac_status); } >/dev/null; then
10933 >  if test -s conftest.err; then
10934 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10935 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10936 >  else
10937 >    ac_cpp_err=
10938 >  fi
10939 > else
10940 >  ac_cpp_err=yes
10941 > fi
10942 > if test -z "$ac_cpp_err"; then
10943 >  ac_header_preproc=yes
10944 > else
10945 >  echo "$as_me: failed program was:" >&5
10946 > sed 's/^/| /' conftest.$ac_ext >&5
10947 >
10948 >  ac_header_preproc=no
10949 > fi
10950 > rm -f conftest.err conftest.$ac_ext
10951 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10952 > echo "${ECHO_T}$ac_header_preproc" >&6
10953 >
10954 > # So?  What about this header?
10955 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10956 >  yes:no: )
10957 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10958 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10959 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10960 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10961 >    ac_header_preproc=yes
10962 >    ;;
10963 >  no:yes:* )
10964 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10965 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10966 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10967 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10968 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10969 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10970 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10971 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10972 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10973 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10974 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10975 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10976 >    (
10977 >      cat <<\_ASBOX
10978 > ## ------------------------------ ##
10979 > ## Report this to gezelter@nd.edu ##
10980 > ## ------------------------------ ##
10981 > _ASBOX
10982 >    ) |
10983 >      sed "s/^/$as_me: WARNING:     /" >&2
10984 >    ;;
10985 > esac
10986 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10987 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10988 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10989 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10990 > else
10991 >  eval "$as_ac_Header=\$ac_header_preproc"
10992 > fi
10993 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10994 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10995 >
10996 > fi
10997 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10998 >  cat >>confdefs.h <<_ACEOF
10999 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11000 > _ACEOF
11001 >
11002 > fi
11003 >
11004 > done
11005 >
11006 >
11007 > fi
11008 >
11009 >
11010 >
11011 >
11012 > for ac_header in cmath
11013 > do
11014 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11015 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11016 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11017 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11018 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11019 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11020 > fi
11021 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11022 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11023 > else
11024 >  # Is the header compilable?
11025 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11026 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11027 > cat >conftest.$ac_ext <<_ACEOF
11028 > /* confdefs.h.  */
11029 > _ACEOF
11030 > cat confdefs.h >>conftest.$ac_ext
11031 > cat >>conftest.$ac_ext <<_ACEOF
11032 > /* end confdefs.h.  */
11033 > $ac_includes_default
11034 > #include <$ac_header>
11035 > _ACEOF
11036 > rm -f conftest.$ac_objext
11037 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11038 >  (eval $ac_compile) 2>conftest.er1
11039 >  ac_status=$?
11040 >  grep -v '^ *+' conftest.er1 >conftest.err
11041 >  rm -f conftest.er1
11042 >  cat conftest.err >&5
11043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11044 >  (exit $ac_status); } &&
11045 >         { ac_try='test -z "$ac_cxx_werror_flag"
11046 >                         || test ! -s conftest.err'
11047 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11048 >  (eval $ac_try) 2>&5
11049 >  ac_status=$?
11050 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11051 >  (exit $ac_status); }; } &&
11052 >         { ac_try='test -s conftest.$ac_objext'
11053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11054 >  (eval $ac_try) 2>&5
11055 >  ac_status=$?
11056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11057 >  (exit $ac_status); }; }; then
11058 >  ac_header_compiler=yes
11059 > else
11060 >  echo "$as_me: failed program was:" >&5
11061 > sed 's/^/| /' conftest.$ac_ext >&5
11062 >
11063 > ac_header_compiler=no
11064 > fi
11065 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11066 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11067 > echo "${ECHO_T}$ac_header_compiler" >&6
11068 >
11069 > # Is the header present?
11070 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11071 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11072 > cat >conftest.$ac_ext <<_ACEOF
11073 > /* confdefs.h.  */
11074 > _ACEOF
11075 > cat confdefs.h >>conftest.$ac_ext
11076 > cat >>conftest.$ac_ext <<_ACEOF
11077 > /* end confdefs.h.  */
11078 > #include <$ac_header>
11079 > _ACEOF
11080 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11081 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11082 >  ac_status=$?
11083 >  grep -v '^ *+' conftest.er1 >conftest.err
11084 >  rm -f conftest.er1
11085 >  cat conftest.err >&5
11086 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11087 >  (exit $ac_status); } >/dev/null; then
11088 >  if test -s conftest.err; then
11089 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11090 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11091 >  else
11092 >    ac_cpp_err=
11093 >  fi
11094 > else
11095 >  ac_cpp_err=yes
11096 > fi
11097 > if test -z "$ac_cpp_err"; then
11098 >  ac_header_preproc=yes
11099 > else
11100 >  echo "$as_me: failed program was:" >&5
11101 > sed 's/^/| /' conftest.$ac_ext >&5
11102 >
11103 >  ac_header_preproc=no
11104 > fi
11105 > rm -f conftest.err conftest.$ac_ext
11106 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11107 > echo "${ECHO_T}$ac_header_preproc" >&6
11108 >
11109 > # So?  What about this header?
11110 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11111 >  yes:no: )
11112 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11113 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11114 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11115 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11116 >    ac_header_preproc=yes
11117 >    ;;
11118 >  no:yes:* )
11119 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11120 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11121 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11122 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11123 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11124 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11125 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11126 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11127 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11128 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11129 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11130 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11131 >    (
11132 >      cat <<\_ASBOX
11133 > ## ------------------------------ ##
11134 > ## Report this to gezelter@nd.edu ##
11135 > ## ------------------------------ ##
11136 > _ASBOX
11137 >    ) |
11138 >      sed "s/^/$as_me: WARNING:     /" >&2
11139 >    ;;
11140 > esac
11141 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11142 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11143 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11144 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11145 > else
11146 >  eval "$as_ac_Header=\$ac_header_preproc"
11147 > fi
11148 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11149 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11150 >
11151 > fi
11152 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11153 >  cat >>confdefs.h <<_ACEOF
11154 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11155 > _ACEOF
11156 >
11157 > fi
11158 >
11159 > done
11160 >
11161 >
11162 >
11163 >
11164 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11165 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11166 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11167 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11168 > else
11169 >
11170 >      ac_cv_cxx_have_std_iostream=no
11171 >      ac_cv_cxx_need_use_std_iostream=no
11172 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11173 >
11174 >
11175 >        ac_ext=cc
11176 > ac_cpp='$CXXCPP $CPPFLAGS'
11177 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11178 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11179 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11180 >
11181 >        cat >conftest.$ac_ext <<_ACEOF
11182 > /* confdefs.h.  */
11183 > _ACEOF
11184 > cat confdefs.h >>conftest.$ac_ext
11185 > cat >>conftest.$ac_ext <<_ACEOF
11186 > /* end confdefs.h.  */
11187 >
11188 > #ifdef HAVE_IOSTREAM
11189 > #include <iostream>
11190 > #else
11191 > #include <iostream.h>
11192 > #endif
11193 >
11194 > #ifdef FC_DUMMY_MAIN
11195 > #ifndef FC_DUMMY_MAIN_EQ_F77
11196 > #  ifdef __cplusplus
11197 >     extern "C"
11198 > #  endif
11199 >   int FC_DUMMY_MAIN() { return 1; }
11200 > #endif
11201 > #endif
11202 > int
11203 > main ()
11204 > {
11205 > std::cout<<"Hello World"<<std::endl;return 0;
11206 >  ;
11207 >  return 0;
11208 > }
11209 > _ACEOF
11210 > rm -f conftest.$ac_objext
11211 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11212 >  (eval $ac_compile) 2>conftest.er1
11213 >  ac_status=$?
11214 >  grep -v '^ *+' conftest.er1 >conftest.err
11215 >  rm -f conftest.er1
11216 >  cat conftest.err >&5
11217 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11218 >  (exit $ac_status); } &&
11219 >         { ac_try='test -z "$ac_cxx_werror_flag"
11220 >                         || test ! -s conftest.err'
11221 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11222 >  (eval $ac_try) 2>&5
11223 >  ac_status=$?
11224 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11225 >  (exit $ac_status); }; } &&
11226 >         { ac_try='test -s conftest.$ac_objext'
11227 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11228 >  (eval $ac_try) 2>&5
11229 >  ac_status=$?
11230 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11231 >  (exit $ac_status); }; }; then
11232 >  ac_cv_cxx_have_std_iostream=yes
11233 > else
11234 >  echo "$as_me: failed program was:" >&5
11235 > sed 's/^/| /' conftest.$ac_ext >&5
11236 >
11237 > fi
11238 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11239 >        cat >conftest.$ac_ext <<_ACEOF
11240 > /* confdefs.h.  */
11241 > _ACEOF
11242 > cat confdefs.h >>conftest.$ac_ext
11243 > cat >>conftest.$ac_ext <<_ACEOF
11244 > /* end confdefs.h.  */
11245 >
11246 > #define __USE_STD_IOSTREAM 1
11247 > #ifdef HAVE_IOSTREAM
11248 > #include <iostream>
11249 > #else
11250 > #include <iostream.h>
11251 > #endif
11252 >
11253 > #ifdef FC_DUMMY_MAIN
11254 > #ifndef FC_DUMMY_MAIN_EQ_F77
11255 > #  ifdef __cplusplus
11256 >     extern "C"
11257 > #  endif
11258 >   int FC_DUMMY_MAIN() { return 1; }
11259 > #endif
11260 > #endif
11261 > int
11262 > main ()
11263 > {
11264 > std::cout<<"Hello World"<<std::endl;return 0;
11265 >  ;
11266 >  return 0;
11267 > }
11268 > _ACEOF
11269 > rm -f conftest.$ac_objext
11270 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11271 >  (eval $ac_compile) 2>conftest.er1
11272 >  ac_status=$?
11273 >  grep -v '^ *+' conftest.er1 >conftest.err
11274 >  rm -f conftest.er1
11275 >  cat conftest.err >&5
11276 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11277 >  (exit $ac_status); } &&
11278 >         { ac_try='test -z "$ac_cxx_werror_flag"
11279 >                         || test ! -s conftest.err'
11280 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11281 >  (eval $ac_try) 2>&5
11282 >  ac_status=$?
11283 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11284 >  (exit $ac_status); }; } &&
11285 >         { ac_try='test -s conftest.$ac_objext'
11286 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11287 >  (eval $ac_try) 2>&5
11288 >  ac_status=$?
11289 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11290 >  (exit $ac_status); }; }; then
11291 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11292 > else
11293 >  echo "$as_me: failed program was:" >&5
11294 > sed 's/^/| /' conftest.$ac_ext >&5
11295 >
11296 > fi
11297 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11298 >        ac_ext=cc
11299 > ac_cpp='$CXXCPP $CPPFLAGS'
11300 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11301 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11302 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11303 >
11304 >      fi
11305 >
11306 > fi
11307 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11308 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11309 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11310 >
11311 > cat >>confdefs.h <<\_ACEOF
11312 > #define HAVE_STD_IOSTREAM 1
11313 > _ACEOF
11314 >
11315 >  fi
11316 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11317 >
11318 > cat >>confdefs.h <<\_ACEOF
11319 > #define __USE_STD_IOSTREAM 1
11320 > _ACEOF
11321 >
11322 >  fi
11323 >
11324 >
11325 >
11326 >
11327 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11328 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11329 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11330 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11331 > else
11332 >
11333 >      ac_cv_cxx_have_std_stl=no
11334 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11335 >
11336 >
11337 >        ac_ext=cc
11338 > ac_cpp='$CXXCPP $CPPFLAGS'
11339 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11340 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11341 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11342 >
11343 >        cat >conftest.$ac_ext <<_ACEOF
11344 > /* confdefs.h.  */
11345 > _ACEOF
11346 > cat confdefs.h >>conftest.$ac_ext
11347 > cat >>conftest.$ac_ext <<_ACEOF
11348 > /* end confdefs.h.  */
11349 > #include <list>
11350 >
11351 > #ifdef FC_DUMMY_MAIN
11352 > #ifndef FC_DUMMY_MAIN_EQ_F77
11353 > #  ifdef __cplusplus
11354 >     extern "C"
11355 > #  endif
11356 >   int FC_DUMMY_MAIN() { return 1; }
11357 > #endif
11358 > #endif
11359 > int
11360 > main ()
11361 > {
11362 > std::list<int> foo;return 0;
11363 >  ;
11364 >  return 0;
11365 > }
11366 > _ACEOF
11367 > rm -f conftest.$ac_objext
11368 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11369 >  (eval $ac_compile) 2>conftest.er1
11370 >  ac_status=$?
11371 >  grep -v '^ *+' conftest.er1 >conftest.err
11372 >  rm -f conftest.er1
11373 >  cat conftest.err >&5
11374 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11375 >  (exit $ac_status); } &&
11376 >         { ac_try='test -z "$ac_cxx_werror_flag"
11377 >                         || test ! -s conftest.err'
11378 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11379 >  (eval $ac_try) 2>&5
11380 >  ac_status=$?
11381 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11382 >  (exit $ac_status); }; } &&
11383 >         { ac_try='test -s conftest.$ac_objext'
11384 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11385 >  (eval $ac_try) 2>&5
11386 >  ac_status=$?
11387 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11388 >  (exit $ac_status); }; }; then
11389 >  ac_cv_cxx_have_std_stl=yes
11390 > else
11391 >  echo "$as_me: failed program was:" >&5
11392 > sed 's/^/| /' conftest.$ac_ext >&5
11393 >
11394 > fi
11395 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11396 >        ac_ext=cc
11397 > ac_cpp='$CXXCPP $CPPFLAGS'
11398 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11399 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11400 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11401 >
11402 >      fi
11403 >
11404 > fi
11405 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11406 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11407 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11408 >
11409 > cat >>confdefs.h <<\_ACEOF
11410 > #define HAVE_STD_STL 1
11411 > _ACEOF
11412 >
11413 >  fi
11414 >
11415 >
11416 >
11417 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11418 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11419 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11420 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11421 > else
11422 >
11423 >    ac_cv_cxx_have_fstream_attach=no
11424 >
11425 >
11426 >    ac_ext=cc
11427 > ac_cpp='$CXXCPP $CPPFLAGS'
11428 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431 >
11432 >    cat >conftest.$ac_ext <<_ACEOF
11433 > /* confdefs.h.  */
11434 > _ACEOF
11435 > cat confdefs.h >>conftest.$ac_ext
11436 > cat >>conftest.$ac_ext <<_ACEOF
11437 > /* end confdefs.h.  */
11438 >
11439 > #ifdef HAVE_IOSTREAM
11440 > #include <fstream>
11441 > #else
11442 > #include <fstream.h>
11443 > #endif
11444 > #ifdef HAVE_STD_IOSTREAM
11445 > using namespace std;
11446 > #endif
11447 >
11448 > #ifdef FC_DUMMY_MAIN
11449 > #ifndef FC_DUMMY_MAIN_EQ_F77
11450 > #  ifdef __cplusplus
11451 >     extern "C"
11452 > #  endif
11453 >   int FC_DUMMY_MAIN() { return 1; }
11454 > #endif
11455 > #endif
11456 > int
11457 > main ()
11458 > {
11459 > int fd=0;ofstream s;s.attach(fd);
11460 >  ;
11461 >  return 0;
11462 > }
11463 > _ACEOF
11464 > rm -f conftest.$ac_objext
11465 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11466 >  (eval $ac_compile) 2>conftest.er1
11467 >  ac_status=$?
11468 >  grep -v '^ *+' conftest.er1 >conftest.err
11469 >  rm -f conftest.er1
11470 >  cat conftest.err >&5
11471 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11472 >  (exit $ac_status); } &&
11473 >         { ac_try='test -z "$ac_cxx_werror_flag"
11474 >                         || test ! -s conftest.err'
11475 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11476 >  (eval $ac_try) 2>&5
11477 >  ac_status=$?
11478 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11479 >  (exit $ac_status); }; } &&
11480 >         { ac_try='test -s conftest.$ac_objext'
11481 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11482 >  (eval $ac_try) 2>&5
11483 >  ac_status=$?
11484 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11485 >  (exit $ac_status); }; }; then
11486 >  ac_cv_cxx_have_fstream_attach=yes
11487 > else
11488 >  echo "$as_me: failed program was:" >&5
11489 > sed 's/^/| /' conftest.$ac_ext >&5
11490 >
11491 > fi
11492 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11493 >    ac_ext=cc
11494 > ac_cpp='$CXXCPP $CPPFLAGS'
11495 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11496 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11497 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11498 >
11499 >
11500 > fi
11501 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11502 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11503 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11504 >
11505 > cat >>confdefs.h <<\_ACEOF
11506 > #define HAVE_FSTREAM_ATTACH 1
11507 > _ACEOF
11508 >
11509 >  fi
11510 >
11511 >
11512 >
11513 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11514 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11515 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11516 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11517 > else
11518 >
11519 >    ac_cv_cxx_have_fstream_open=no
11520 >    ac_cv_cxx_fstream_open_prot=no
11521 >
11522 >
11523 >    ac_ext=cc
11524 > ac_cpp='$CXXCPP $CPPFLAGS'
11525 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11526 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11527 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11528 >
11529 >    # Try with 2 parameters
11530 >    cat >conftest.$ac_ext <<_ACEOF
11531 > /* confdefs.h.  */
11532 > _ACEOF
11533 > cat confdefs.h >>conftest.$ac_ext
11534 > cat >>conftest.$ac_ext <<_ACEOF
11535 > /* end confdefs.h.  */
11536 >
11537 > #ifdef HAVE_IOSTREAM
11538 > #include <fstream>
11539 > #else
11540 > #include <fstream.h>
11541 > #endif
11542 > #ifdef HAVE_STD_IOSTREAM
11543 > using namespace std;
11544 > #endif
11545 >
11546 > #ifdef FC_DUMMY_MAIN
11547 > #ifndef FC_DUMMY_MAIN_EQ_F77
11548 > #  ifdef __cplusplus
11549 >     extern "C"
11550 > #  endif
11551 >   int FC_DUMMY_MAIN() { return 1; }
11552 > #endif
11553 > #endif
11554 > int
11555 > main ()
11556 > {
11557 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11558 >  ;
11559 >  return 0;
11560 > }
11561 > _ACEOF
11562 > rm -f conftest.$ac_objext
11563 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11564 >  (eval $ac_compile) 2>conftest.er1
11565 >  ac_status=$?
11566 >  grep -v '^ *+' conftest.er1 >conftest.err
11567 >  rm -f conftest.er1
11568 >  cat conftest.err >&5
11569 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11570 >  (exit $ac_status); } &&
11571 >         { ac_try='test -z "$ac_cxx_werror_flag"
11572 >                         || test ! -s conftest.err'
11573 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11574 >  (eval $ac_try) 2>&5
11575 >  ac_status=$?
11576 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11577 >  (exit $ac_status); }; } &&
11578 >         { ac_try='test -s conftest.$ac_objext'
11579 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11580 >  (eval $ac_try) 2>&5
11581 >  ac_status=$?
11582 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11583 >  (exit $ac_status); }; }; then
11584 >  ac_cv_cxx_have_fstream_open=yes
11585 > else
11586 >  echo "$as_me: failed program was:" >&5
11587 > sed 's/^/| /' conftest.$ac_ext >&5
11588 >
11589 > fi
11590 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11591 >    # Try with mode parameter
11592 >    cat >conftest.$ac_ext <<_ACEOF
11593 > /* confdefs.h.  */
11594 > _ACEOF
11595 > cat confdefs.h >>conftest.$ac_ext
11596 > cat >>conftest.$ac_ext <<_ACEOF
11597 > /* end confdefs.h.  */
11598 >
11599 > #ifdef HAVE_IOSTREAM
11600 > #include <fstream>
11601 > #else
11602 > #include <fstream.h>
11603 > #endif
11604 > #ifdef HAVE_STD_IOSTREAM
11605 > using namespace std;
11606 > #endif
11607 >
11608 > #ifdef FC_DUMMY_MAIN
11609 > #ifndef FC_DUMMY_MAIN_EQ_F77
11610 > #  ifdef __cplusplus
11611 >     extern "C"
11612 > #  endif
11613 >   int FC_DUMMY_MAIN() { return 1; }
11614 > #endif
11615 > #endif
11616 > int
11617 > main ()
11618 > {
11619 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11620 >  ;
11621 >  return 0;
11622 > }
11623 > _ACEOF
11624 > rm -f conftest.$ac_objext
11625 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11626 >  (eval $ac_compile) 2>conftest.er1
11627 >  ac_status=$?
11628 >  grep -v '^ *+' conftest.er1 >conftest.err
11629 >  rm -f conftest.er1
11630 >  cat conftest.err >&5
11631 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11632 >  (exit $ac_status); } &&
11633 >         { ac_try='test -z "$ac_cxx_werror_flag"
11634 >                         || test ! -s conftest.err'
11635 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11636 >  (eval $ac_try) 2>&5
11637 >  ac_status=$?
11638 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639 >  (exit $ac_status); }; } &&
11640 >         { ac_try='test -s conftest.$ac_objext'
11641 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11642 >  (eval $ac_try) 2>&5
11643 >  ac_status=$?
11644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11645 >  (exit $ac_status); }; }; then
11646 >  ac_cv_cxx_fstream_open_prot=yes
11647 > else
11648 >  echo "$as_me: failed program was:" >&5
11649 > sed 's/^/| /' conftest.$ac_ext >&5
11650 >
11651 > fi
11652 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11653 >    ac_ext=cc
11654 > ac_cpp='$CXXCPP $CPPFLAGS'
11655 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11656 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11657 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11658 >
11659 >
11660 > fi
11661 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11662 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11663 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11664 >
11665 > cat >>confdefs.h <<\_ACEOF
11666 > #define HAVE_FSTREAM_OPEN 1
11667 > _ACEOF
11668 >
11669 >  fi
11670 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11671 >
11672 > cat >>confdefs.h <<\_ACEOF
11673 > #define FSTREAM_OPEN_PROT 1
11674 > _ACEOF
11675 >
11676 >  fi
11677 >
11678 >
11679 >
11680 >
11681 >
11682 >
11683 >
11684 > for ac_header in ctype.h iostream fstream sstream strstream
11685 > do
11686 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11687 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11688 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11689 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11690 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11691 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11692 > fi
11693 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11694 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11695 > else
11696 >  # Is the header compilable?
11697 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11698 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11699 > cat >conftest.$ac_ext <<_ACEOF
11700 > /* confdefs.h.  */
11701 > _ACEOF
11702 > cat confdefs.h >>conftest.$ac_ext
11703 > cat >>conftest.$ac_ext <<_ACEOF
11704 > /* end confdefs.h.  */
11705 > $ac_includes_default
11706 > #include <$ac_header>
11707 > _ACEOF
11708 > rm -f conftest.$ac_objext
11709 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11710 >  (eval $ac_compile) 2>conftest.er1
11711 >  ac_status=$?
11712 >  grep -v '^ *+' conftest.er1 >conftest.err
11713 >  rm -f conftest.er1
11714 >  cat conftest.err >&5
11715 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11716 >  (exit $ac_status); } &&
11717 >         { ac_try='test -z "$ac_cxx_werror_flag"
11718 >                         || test ! -s conftest.err'
11719 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11720 >  (eval $ac_try) 2>&5
11721 >  ac_status=$?
11722 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723 >  (exit $ac_status); }; } &&
11724 >         { ac_try='test -s conftest.$ac_objext'
11725 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11726 >  (eval $ac_try) 2>&5
11727 >  ac_status=$?
11728 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11729 >  (exit $ac_status); }; }; then
11730 >  ac_header_compiler=yes
11731 > else
11732 >  echo "$as_me: failed program was:" >&5
11733 > sed 's/^/| /' conftest.$ac_ext >&5
11734 >
11735 > ac_header_compiler=no
11736 > fi
11737 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11738 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11739 > echo "${ECHO_T}$ac_header_compiler" >&6
11740 >
11741 > # Is the header present?
11742 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11743 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11744 > cat >conftest.$ac_ext <<_ACEOF
11745 > /* confdefs.h.  */
11746 > _ACEOF
11747 > cat confdefs.h >>conftest.$ac_ext
11748 > cat >>conftest.$ac_ext <<_ACEOF
11749 > /* end confdefs.h.  */
11750 > #include <$ac_header>
11751 > _ACEOF
11752 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11753 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11754 >  ac_status=$?
11755 >  grep -v '^ *+' conftest.er1 >conftest.err
11756 >  rm -f conftest.er1
11757 >  cat conftest.err >&5
11758 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11759 >  (exit $ac_status); } >/dev/null; then
11760 >  if test -s conftest.err; then
11761 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11762 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11763 >  else
11764 >    ac_cpp_err=
11765 >  fi
11766 > else
11767 >  ac_cpp_err=yes
11768 > fi
11769 > if test -z "$ac_cpp_err"; then
11770 >  ac_header_preproc=yes
11771 > else
11772 >  echo "$as_me: failed program was:" >&5
11773 > sed 's/^/| /' conftest.$ac_ext >&5
11774 >
11775 >  ac_header_preproc=no
11776 > fi
11777 > rm -f conftest.err conftest.$ac_ext
11778 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11779 > echo "${ECHO_T}$ac_header_preproc" >&6
11780 >
11781 > # So?  What about this header?
11782 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11783 >  yes:no: )
11784 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11785 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11786 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11787 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11788 >    ac_header_preproc=yes
11789 >    ;;
11790 >  no:yes:* )
11791 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11792 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11793 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11794 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11795 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11796 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11797 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11798 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11799 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11800 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11801 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11802 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11803 >    (
11804 >      cat <<\_ASBOX
11805 > ## ------------------------------ ##
11806 > ## Report this to gezelter@nd.edu ##
11807 > ## ------------------------------ ##
11808 > _ASBOX
11809 >    ) |
11810 >      sed "s/^/$as_me: WARNING:     /" >&2
11811 >    ;;
11812 > esac
11813 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11814 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11815 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11816 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11817 > else
11818 >  eval "$as_ac_Header=\$ac_header_preproc"
11819 > fi
11820 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11821 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11822 >
11823 > fi
11824 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11825 >  cat >>confdefs.h <<_ACEOF
11826 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11827 > _ACEOF
11828 >
11829 > fi
11830 >
11831 > done
11832 >
11833 > # AC_CPP_FUNC
11834 > # ------------------ #
11835 > # Checks to see if ANSI C99 CPP variable __func__ works.
11836 > # If not, perhaps __FUNCTION__ works instead.
11837 > # If not, we'll just define __func__ to "".
11838 > # AC_CPP_FUNC
11839 >
11840 >
11841 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11842 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11843 > if test "${ac_cv_cpp_func+set}" = set; then
11844 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11845 > else
11846 >  cat >conftest.$ac_ext <<_ACEOF
11847 > /* confdefs.h.  */
11848 > _ACEOF
11849 > cat confdefs.h >>conftest.$ac_ext
11850 > cat >>conftest.$ac_ext <<_ACEOF
11851 > /* end confdefs.h.  */
11852 >
11853 > #ifdef FC_DUMMY_MAIN
11854 > #ifndef FC_DUMMY_MAIN_EQ_F77
11855 > #  ifdef __cplusplus
11856 >     extern "C"
11857 > #  endif
11858 >   int FC_DUMMY_MAIN() { return 1; }
11859   #endif
4907 #ifdef __cplusplus
4908 }
11860   #endif
4910
11861   int
11862   main ()
11863   {
11864 < return f != $ac_func;
11864 > const char *foo = __func__;
11865    ;
11866    return 0;
11867   }
11868   _ACEOF
11869 < rm -f conftest.$ac_objext conftest$ac_exeext
11870 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11871 <  (eval $ac_link) 2>conftest.er1
11869 > rm -f conftest.$ac_objext
11870 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11871 >  (eval $ac_compile) 2>conftest.er1
11872    ac_status=$?
11873    grep -v '^ *+' conftest.er1 >conftest.err
11874    rm -f conftest.er1
11875    cat conftest.err >&5
11876    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11877    (exit $ac_status); } &&
11878 <         { ac_try='test -z "$ac_c_werror_flag"
11878 >         { ac_try='test -z "$ac_cxx_werror_flag"
11879                           || test ! -s conftest.err'
11880    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11881    (eval $ac_try) 2>&5
11882    ac_status=$?
11883    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11884    (exit $ac_status); }; } &&
11885 <         { ac_try='test -s conftest$ac_exeext'
11885 >         { ac_try='test -s conftest.$ac_objext'
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); }; }; then
11891 <  eval "$as_ac_var=yes"
11891 >  ac_cv_cpp_func=yes
11892   else
11893    echo "$as_me: failed program was:" >&5
11894   sed 's/^/| /' conftest.$ac_ext >&5
11895  
4946 eval "$as_ac_var=no"
4947 fi
4948 rm -f conftest.err conftest.$ac_objext \
4949      conftest$ac_exeext conftest.$ac_ext
4950 fi
4951 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
4952 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
4953 if test `eval echo '${'$as_ac_var'}'` = yes; then
4954  cat >>confdefs.h <<_ACEOF
4955 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
4956 _ACEOF
4957
4958 else
4959  # FreeBSD has a gnugetopt library for this
4960    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
4961 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
4962 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
4963  echo $ECHO_N "(cached) $ECHO_C" >&6
4964 else
4965  ac_check_lib_save_LIBS=$LIBS
4966 LIBS="-lgnugetopt  $LIBS"
11896   cat >conftest.$ac_ext <<_ACEOF
11897   /* confdefs.h.  */
11898   _ACEOF
# Line 4971 | Line 11900 | cat >>conftest.$ac_ext <<_ACEOF
11900   cat >>conftest.$ac_ext <<_ACEOF
11901   /* end confdefs.h.  */
11902  
11903 < /* Override any gcc2 internal prototype to avoid an error.  */
11904 < #ifdef __cplusplus
11905 < extern "C"
11903 > #ifdef FC_DUMMY_MAIN
11904 > #ifndef FC_DUMMY_MAIN_EQ_F77
11905 > #  ifdef __cplusplus
11906 >     extern "C"
11907 > #  endif
11908 >   int FC_DUMMY_MAIN() { return 1; }
11909   #endif
11910 < /* We use char because int might match the return type of a gcc2
4979 <   builtin and then its argument prototype would still apply.  */
4980 < char getopt_long ();
11910 > #endif
11911   int
11912   main ()
11913   {
11914 < getopt_long ();
11914 > const char *foo = __FUNCTION__;
11915    ;
11916    return 0;
11917   }
11918   _ACEOF
11919 < rm -f conftest.$ac_objext conftest$ac_exeext
11920 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11921 <  (eval $ac_link) 2>conftest.er1
11919 > rm -f conftest.$ac_objext
11920 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11921 >  (eval $ac_compile) 2>conftest.er1
11922    ac_status=$?
11923    grep -v '^ *+' conftest.er1 >conftest.err
11924    rm -f conftest.er1
11925    cat conftest.err >&5
11926    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11927    (exit $ac_status); } &&
11928 <         { ac_try='test -z "$ac_c_werror_flag"
11928 >         { ac_try='test -z "$ac_cxx_werror_flag"
11929                           || test ! -s conftest.err'
11930    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11931    (eval $ac_try) 2>&5
11932    ac_status=$?
11933    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11934    (exit $ac_status); }; } &&
11935 <         { ac_try='test -s conftest$ac_exeext'
11935 >         { ac_try='test -s conftest.$ac_objext'
11936    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11937    (eval $ac_try) 2>&5
11938    ac_status=$?
11939    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11940    (exit $ac_status); }; }; then
11941 <  ac_cv_lib_gnugetopt_getopt_long=yes
11941 >  ac_cv_cpp_func=__FUNCTION__
11942   else
11943    echo "$as_me: failed program was:" >&5
11944   sed 's/^/| /' conftest.$ac_ext >&5
11945  
11946 < ac_cv_lib_gnugetopt_getopt_long=no
11946 > ac_cv_cpp_func=no
11947   fi
11948 < rm -f conftest.err conftest.$ac_objext \
5019 <      conftest$ac_exeext conftest.$ac_ext
5020 < LIBS=$ac_check_lib_save_LIBS
11948 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11949   fi
11950 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11951 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11952 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11953 <  cat >>confdefs.h <<\_ACEOF
11954 < #define HAVE_GETOPT_LONG 1
11950 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11951 > fi
11952 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11953 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11954 > if test $ac_cv_cpp_func = __FUNCTION__; then
11955 >
11956 > cat >>confdefs.h <<\_ACEOF
11957 > #define __func__ __FUNCTION__
11958   _ACEOF
11959  
11960 < else
5030 <  # use the GNU replacement
5031 <      case $LIBOBJS in
5032 <    "getopt.$ac_objext"   | \
5033 <  *" getopt.$ac_objext"   | \
5034 <    "getopt.$ac_objext "* | \
5035 <  *" getopt.$ac_objext "* ) ;;
5036 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5037 < esac
11960 > elif test $ac_cv_cpp_func = no; then
11961  
11962 <      case $LIBOBJS in
11963 <    "getopt1.$ac_objext"   | \
11964 <  *" getopt1.$ac_objext"   | \
5042 <    "getopt1.$ac_objext "* | \
5043 <  *" getopt1.$ac_objext "* ) ;;
5044 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5045 < esac
11962 > cat >>confdefs.h <<\_ACEOF
11963 > #define __func__ ""
11964 > _ACEOF
11965  
5047                ac_config_links="$ac_config_links utils/getopt.h:utils/gnugetopt.h"
5048
11966   fi
11967  
5051 fi
5052 done
11968  
11969  
11970  
11971 +
11972   case $debug in
11973    1)
11974       ;;
# Line 5061 | Line 11977 | case $debug in
11977  
11978  
11979  
11980 + # Try to determine "good" native compiler flags if none specified on command
11981 + # line
11982  
11983 + if test "$ac_test_FFLAGS" != "set"; then
11984 +  FCFLAGS=""
11985 +  case "${host_cpu}-${host_os}" in
11986  
11987 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11988 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11989 +                fi;;
11990 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11991 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11992 +                fi;;
11993 +   powerpc*-aix*)
11994 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11995 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11996 +                echo "*******************************************************"
11997 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11998 +                echo "*  recommended that you use                           *"
11999 +                echo "*                                                     *"
12000 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12001 +                echo "*                                 ^^^                 *"
12002 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12003 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12004 +                echo "*******************************************************"
12005 +        fi;;
12006 +   *darwin*)
12007 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12008 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12009 +        fi
12010 +        if test "$FC" = ifort; then
12011 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12012 +        fi;;
12013 +  esac
12014 +
12015 +  if test -n "$CPU_FLAGS"; then
12016 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12017 +  fi
12018 +
12019 +  if test -z "$FCFLAGS"; then
12020 +        echo ""
12021 +        echo "*********************************************************"
12022 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12023 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12024 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12025 +        echo "*********************************************************"
12026 +        echo ""
12027 +        FCFLAGS="-O3"
12028 +  fi
12029 +
12030 +
12031 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12032 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12033 + if test "${ac_guessed_f90flags+set}" = set; then
12034 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12035 + else
12036 +
12037 +
12038 +
12039 + ac_ext=${FC_SRCEXT-f}
12040 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12041 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12042 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12043 +
12044 + echo 'program main' > conftest.$ac_ext
12045 + echo 'end program main' >> conftest.$ac_ext
12046 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12047 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12048 +  (eval $ac_compile) 2>&5
12049 +  ac_status=$?
12050 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12051 +  (exit $ac_status); }; then
12052 +        ac_guessed_f90flags=yes
12053 + else
12054 +        ac_guessed_f90flags=no
12055 + fi
12056 + rm -f conftest*
12057 + ac_ext=cc
12058 + ac_cpp='$CXXCPP $CPPFLAGS'
12059 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12060 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12061 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12062 +
12063 +
12064 + fi
12065 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12066 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12067 + if test "$ac_guessed_f90flags" = yes; then
12068 +        :
12069 +
12070 + else
12071 +        :
12072 +
12073 +        echo ""
12074 +        echo "**********************************************************"
12075 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12076 +        echo "* your compiler.                                        *"
12077 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12078 +        echo "*********************************************************"
12079 +        echo ""
12080 +        FCFLAGS=""
12081 +
12082 + fi
12083 +
12084 +
12085 + fi
12086 +
12087 +
12088 +
12089 +
12090 +
12091 +
12092 +
12093   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12094   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12095   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5071 | Line 12098 | cat > conftest.c <<EOF
12098  
12099   cat > conftest.c <<EOF
12100   #ifdef __GNUC__
12101 <  #ifndef __INTEL_COMPILER
12101 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12102 >     no;
12103 >  #else
12104       yes;
12105    #endif
12106   #endif
# Line 5109 | Line 12138 | if test "$ac_test_CFLAGS" != "set"; then
12138                      CFLAGS="-O"
12139                  fi;;
12140    sparc-solaris2*) if test "$CC" = cc; then
12141 <                    CFLAGS="-native -fast -xO5 -dalign"
12141 >                    CFLAGS="-O -dalign"
12142                   fi;;
12143  
12144    alpha*-osf*)  if test "$CC" = cc; then
# Line 5138 | Line 12167 | if test "$ac_test_CFLAGS" != "set"; then
12167          fi;;
12168     *darwin*)
12169          if test "$CC" = xlc -o "$CC" = cc; then
12170 <                CFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12170 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12171 >        fi
12172 >        if test "$CC" = icc; then
12173 >                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12174          fi;;
12175    esac
12176  
# Line 5152 | Line 12184 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12184      # -malign-double for x86 systems
12185  
12186  
12187 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12188 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12187 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12188 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12189   if test "${ac_align_double+set}" = set; then
12190    echo $ECHO_N "(cached) $ECHO_C" >&6
12191   else
12192    echo 'void f(){}' > conftest.c
12193 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12193 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12194          ac_align_double=yes
12195   else
12196          ac_align_double=no
# Line 5179 | Line 12211 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12211      # -fstrict-aliasing for gcc-2.95+
12212  
12213  
12214 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12215 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12214 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12215 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12216   if test "${ac_fstrict_aliasing+set}" = set; then
12217    echo $ECHO_N "(cached) $ECHO_C" >&6
12218   else
12219    echo 'void f(){}' > conftest.c
12220 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12220 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12221          ac_fstrict_aliasing=yes
12222   else
12223          ac_fstrict_aliasing=no
# Line 5210 | Line 12242 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12242                    case "${host_cpu}" in
12243            i586*)
12244  
12245 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12246 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12245 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12246 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12247   if test "${ac_cpu_pentium+set}" = set; then
12248    echo $ECHO_N "(cached) $ECHO_C" >&6
12249   else
12250    echo 'void f(){}' > conftest.c
12251 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12251 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12252          ac_cpu_pentium=yes
12253   else
12254          ac_cpu_pentium=no
# Line 5233 | Line 12265 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12265          :
12266  
12267  
12268 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12269 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12268 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12269 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12270   if test "${ac_pentium+set}" = set; then
12271    echo $ECHO_N "(cached) $ECHO_C" >&6
12272   else
12273    echo 'void f(){}' > conftest.c
12274 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12274 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12275          ac_pentium=yes
12276   else
12277          ac_pentium=no
# Line 5262 | Line 12294 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12294                    ;;
12295            i686*)
12296  
12297 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12298 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12297 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12298 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12299   if test "${ac_cpu_pentiumpro+set}" = set; then
12300    echo $ECHO_N "(cached) $ECHO_C" >&6
12301   else
12302    echo 'void f(){}' > conftest.c
12303 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12303 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12304          ac_cpu_pentiumpro=yes
12305   else
12306          ac_cpu_pentiumpro=no
# Line 5285 | Line 12317 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12317          :
12318  
12319  
12320 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12321 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12320 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12321 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12322   if test "${ac_pentiumpro+set}" = set; then
12323    echo $ECHO_N "(cached) $ECHO_C" >&6
12324   else
12325    echo 'void f(){}' > conftest.c
12326 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12326 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12327          ac_pentiumpro=yes
12328   else
12329          ac_pentiumpro=no
# Line 5318 | Line 12350 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12350                  if test -n "$is60x"; then
12351  
12352  
12353 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12354 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12353 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12354 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12355   if test "${ac_m_cpu_60x+set}" = set; then
12356    echo $ECHO_N "(cached) $ECHO_C" >&6
12357   else
12358    echo 'void f(){}' > conftest.c
12359 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12359 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12360          ac_m_cpu_60x=yes
12361   else
12362          ac_m_cpu_60x=no
# Line 5376 | Line 12408 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12408          :
12409  
12410  
12411 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12412 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12411 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12412 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12413   if test "${ac_m_cpu_750+set}" = set; then
12414    echo $ECHO_N "(cached) $ECHO_C" >&6
12415   else
12416    echo 'void f(){}' > conftest.c
12417 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12417 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12418          ac_m_cpu_750=yes
12419   else
12420          ac_m_cpu_750=no
# Line 5409 | Line 12441 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12441                  if test -z "$CPU_FLAGS"; then
12442  
12443  
12444 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12445 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12444 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12445 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12446   if test "${ac_m_cpu_powerpc+set}" = set; then
12447    echo $ECHO_N "(cached) $ECHO_C" >&6
12448   else
12449    echo 'void f(){}' > conftest.c
12450 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12450 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12451          ac_m_cpu_powerpc=yes
12452   else
12453          ac_m_cpu_powerpc=no
# Line 5437 | Line 12469 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12469                  if test -z "$CPU_FLAGS"; then
12470  
12471  
12472 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12473 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12472 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12473 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12474   if test "${ac_m_powerpc+set}" = set; then
12475    echo $ECHO_N "(cached) $ECHO_C" >&6
12476   else
12477    echo 'void f(){}' > conftest.c
12478 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12478 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12479          ac_m_powerpc=yes
12480   else
12481          ac_m_powerpc=no
# Line 5482 | Line 12514 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12514  
12515  
12516  
12517 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12518 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12517 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12518 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12519   if test "${ac_guessed_cflags+set}" = set; then
12520    echo $ECHO_N "(cached) $ECHO_C" >&6
12521   else
12522    echo 'void f(){}' > conftest.c
12523 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12523 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12524          ac_guessed_cflags=yes
12525   else
12526          ac_guessed_cflags=no
# Line 5532 | Line 12564 | cat > conftest.cpp <<EOF
12564  
12565   cat > conftest.cpp <<EOF
12566   #ifdef __GNUC__
12567 <  #ifndef __INTEL_COMPILER
12567 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12568 >     no;
12569 >  #else
12570       yes;
12571    #endif
12572   #endif
# Line 5570 | Line 12604 | if test "$ac_test_CXXFLAGS" != "set"; then
12604                      CXXFLAGS="-O"
12605                  fi;;
12606    sparc-solaris2*) if test "$CXX" = CC; then
12607 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12607 >                    CXXFLAGS="-features=extensions -O -dalign"
12608                   fi;;
12609     rs6000*-aix*)  if test "$CXX" = xlC; then
12610                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 5589 | Line 12623 | if test "$ac_test_CXXFLAGS" != "set"; then
12623                  echo "*******************************************************"
12624          fi;;
12625     *darwin*)
12626 <        if test "$CXX" = xlc++; then
12627 <                CXXFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12626 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12627 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12628 >        fi
12629 >        if test "$CXX" = icpc; then
12630 >                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12631          fi;;
12632    esac
12633  
# Line 5604 | Line 12641 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12641      # -malign-double for x86 systems
12642  
12643  
12644 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12645 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12644 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12645 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12646   if test "${ac_align_double+set}" = set; then
12647    echo $ECHO_N "(cached) $ECHO_C" >&6
12648   else
12649    echo 'void f(){}' > conftest.cpp
12650 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12650 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12651          ac_align_double=yes
12652   else
12653          ac_align_double=no
# Line 5631 | Line 12668 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12668      # -fstrict-aliasing for gcc-2.95+
12669  
12670  
12671 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12672 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12671 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12672 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12673   if test "${ac_fstrict_aliasing+set}" = set; then
12674    echo $ECHO_N "(cached) $ECHO_C" >&6
12675   else
12676    echo 'void f(){}' > conftest.cpp
12677 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12677 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12678          ac_fstrict_aliasing=yes
12679   else
12680          ac_fstrict_aliasing=no
# Line 5662 | Line 12699 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12699                    case "${host_cpu}" in
12700            i586*)
12701  
12702 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12703 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12702 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12703 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12704   if test "${ac_cpu_pentium+set}" = set; then
12705    echo $ECHO_N "(cached) $ECHO_C" >&6
12706   else
12707    echo 'void f(){}' > conftest.cpp
12708 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12708 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12709          ac_cpu_pentium=yes
12710   else
12711          ac_cpu_pentium=no
# Line 5685 | Line 12722 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12722          :
12723  
12724  
12725 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12726 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12725 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12726 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12727   if test "${ac_pentium+set}" = set; then
12728    echo $ECHO_N "(cached) $ECHO_C" >&6
12729   else
12730    echo 'void f(){}' > conftest.cpp
12731 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12731 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12732          ac_pentium=yes
12733   else
12734          ac_pentium=no
# Line 5714 | Line 12751 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12751                    ;;
12752            i686*)
12753  
12754 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12755 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12754 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12755 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12756   if test "${ac_cpu_pentiumpro+set}" = set; then
12757    echo $ECHO_N "(cached) $ECHO_C" >&6
12758   else
12759    echo 'void f(){}' > conftest.cpp
12760 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12760 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12761          ac_cpu_pentiumpro=yes
12762   else
12763          ac_cpu_pentiumpro=no
# Line 5737 | Line 12774 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12774          :
12775  
12776  
12777 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12778 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12777 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12778 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12779   if test "${ac_pentiumpro+set}" = set; then
12780    echo $ECHO_N "(cached) $ECHO_C" >&6
12781   else
12782    echo 'void f(){}' > conftest.cpp
12783 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12783 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12784          ac_pentiumpro=yes
12785   else
12786          ac_pentiumpro=no
# Line 5770 | Line 12807 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12807                  if test -n "$is60x"; then
12808  
12809  
12810 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12811 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12810 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12811 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12812   if test "${ac_m_cpu_60x+set}" = set; then
12813    echo $ECHO_N "(cached) $ECHO_C" >&6
12814   else
12815    echo 'void f(){}' > conftest.cpp
12816 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12816 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12817          ac_m_cpu_60x=yes
12818   else
12819          ac_m_cpu_60x=no
# Line 5828 | Line 12865 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12865          :
12866  
12867  
12868 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12869 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12868 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12869 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12870   if test "${ac_m_cpu_750+set}" = set; then
12871    echo $ECHO_N "(cached) $ECHO_C" >&6
12872   else
12873    echo 'void f(){}' > conftest.cpp
12874 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12874 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12875          ac_m_cpu_750=yes
12876   else
12877          ac_m_cpu_750=no
# Line 5861 | Line 12898 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12898                  if test -z "$CPU_FLAGS"; then
12899  
12900  
12901 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12902 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12901 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12902 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12903   if test "${ac_m_cpu_powerpc+set}" = set; then
12904    echo $ECHO_N "(cached) $ECHO_C" >&6
12905   else
12906    echo 'void f(){}' > conftest.cpp
12907 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12907 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12908          ac_m_cpu_powerpc=yes
12909   else
12910          ac_m_cpu_powerpc=no
# Line 5889 | Line 12926 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12926                  if test -z "$CPU_FLAGS"; then
12927  
12928  
12929 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12930 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12929 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12930 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12931   if test "${ac_m_powerpc+set}" = set; then
12932    echo $ECHO_N "(cached) $ECHO_C" >&6
12933   else
12934    echo 'void f(){}' > conftest.cpp
12935 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12935 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12936          ac_m_powerpc=yes
12937   else
12938          ac_m_powerpc=no
# Line 5934 | Line 12971 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12971  
12972  
12973  
12974 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12975 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
12974 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12975 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12976   if test "${ac_guessed_cxxflags+set}" = set; then
12977    echo $ECHO_N "(cached) $ECHO_C" >&6
12978   else
12979    echo 'void f(){}' > conftest.cpp
12980 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12980 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12981          ac_guessed_cxxflags=yes
12982   else
12983          ac_guessed_cxxflags=no
# Line 5951 | Line 12988 | if test "$ac_guessed_cxxflags" = yes; then
12988   echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12989   echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12990   if test "$ac_guessed_cxxflags" = yes; then
12991 <        :
5955 <
5956 < else
5957 <        :
5958 <
5959 <        echo ""
5960 <        echo "**********************************************************"
5961 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
5962 <        echo "* your compiler.                                         *"
5963 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
5964 <        echo "**********************************************************"
5965 <        echo ""
5966 <        CXXFLAGS=""
5967 <
5968 < fi
5969 <
5970 <
5971 < fi
5972 <
5973 <
5974 <
5975 <
5976 <
5977 < # Try to determine "good" native compiler flags if none specified on command
5978 < # line
5979 <
5980 < if test x"$F90FLAGS" = x ; then
5981 <  F90FLAGS=""
5982 <  case "${host_cpu}-${host_os}" in
5983 <
5984 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
5985 <                    F90FLAGS="-O"
5986 <                fi;;
5987 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
5988 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
5989 <                fi;;
5990 <   powerpc*-aix*)
5991 <        if test "$F90" = f90 -o "$F90" = xlf90; then
5992 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
5993 <                echo "*******************************************************"
5994 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
5995 <                echo "*  recommended that you use                           *"
5996 <                echo "*                                                     *"
5997 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
5998 <                echo "*                                 ^^^                 *"
5999 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6000 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6001 <                echo "*******************************************************"
6002 <        fi;;
6003 <   *darwin*)
6004 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6005 <                F90FLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto"
6006 <        fi;;
6007 <  esac
6008 <
6009 <  if test -n "$CPU_FLAGS"; then
6010 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6011 <  fi
6012 <
6013 <  if test -z "$F90FLAGS"; then
6014 <        echo ""
6015 <        echo "**********************************************************"
6016 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6017 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6018 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6019 <        echo "**********************************************************"
6020 <        echo ""
6021 <        F90FLAGS="-O3"
6022 <  fi
6023 <
6024 <
6025 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6026 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6027 < if test "${ac_guessed_f90flags+set}" = set; then
6028 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6029 < else
6030 <
6031 <
6032 <
6033 < ac_ext=f90
6034 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6035 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6036 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6037 <
6038 < echo 'program main' > conftest.$ac_ext
6039 < echo 'end program main' >> conftest.$ac_ext
6040 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6041 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6042 <  (eval $ac_compile) 2>&5
6043 <  ac_status=$?
6044 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6045 <  (exit $ac_status); }; then
6046 <        ac_guessed_f90flags=yes
6047 < else
6048 <        ac_guessed_f90flags=no
6049 < fi
6050 < rm -f conftest*
6051 < ac_ext=c
6052 < ac_cpp='$CPP $CPPFLAGS'
6053 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6054 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6055 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6056 <
6057 <
6058 < fi
6059 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6060 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
6061 < if test "$ac_guessed_f90flags" = yes; then
6062 <        :
6063 <
6064 < else
6065 <        :
6066 <
6067 <        echo ""
6068 <        echo "**********************************************************"
6069 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6070 <        echo "* your compiler.                                         *"
6071 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6072 <        echo "**********************************************************"
6073 <        echo ""
6074 <        F90FLAGS=""
6075 <
6076 < fi
6077 <
6078 <
6079 < fi
6080 <
6081 <     ;;
6082 < esac
6083 <
6084 < # Find a good install program.  We prefer a C program (faster),
6085 < # so one script is as good as another.  But avoid the broken or
6086 < # incompatible versions:
6087 < # SysV /etc/install, /usr/sbin/install
6088 < # SunOS /usr/etc/install
6089 < # IRIX /sbin/install
6090 < # AIX /bin/install
6091 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6092 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6093 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6094 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6095 < # OS/2's system install, which has a completely different semantic
6096 < # ./install, which can be erroneously created by make from ./install.sh.
6097 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6098 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6099 < if test -z "$INSTALL"; then
6100 < if test "${ac_cv_path_install+set}" = set; then
6101 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6102 < else
6103 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6104 < for as_dir in $PATH
6105 < do
6106 <  IFS=$as_save_IFS
6107 <  test -z "$as_dir" && as_dir=.
6108 <  # Account for people who put trailing slashes in PATH elements.
6109 < case $as_dir/ in
6110 <  ./ | .// | /cC/* | \
6111 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6112 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6113 <  /usr/ucb/* ) ;;
6114 <  *)
6115 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6116 <    # Don't use installbsd from OSF since it installs stuff as root
6117 <    # by default.
6118 <    for ac_prog in ginstall scoinst install; do
6119 <      for ac_exec_ext in '' $ac_executable_extensions; do
6120 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6121 <          if test $ac_prog = install &&
6122 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6123 <            # AIX install.  It has an incompatible calling convention.
6124 <            :
6125 <          elif test $ac_prog = install &&
6126 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6127 <            # program-specific install script used by HP pwplus--don't use.
6128 <            :
6129 <          else
6130 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6131 <            break 3
6132 <          fi
6133 <        fi
6134 <      done
6135 <    done
6136 <    ;;
6137 < esac
6138 < done
6139 <
6140 <
6141 < fi
6142 <  if test "${ac_cv_path_install+set}" = set; then
6143 <    INSTALL=$ac_cv_path_install
6144 <  else
6145 <    # As a last resort, use the slow shell script.  We don't cache a
6146 <    # path for INSTALL within a source directory, because that will
6147 <    # break other packages using the cache if that directory is
6148 <    # removed, or if the path is relative.
6149 <    INSTALL=$ac_install_sh
6150 <  fi
6151 < fi
6152 < echo "$as_me:$LINENO: result: $INSTALL" >&5
6153 < echo "${ECHO_T}$INSTALL" >&6
6154 <
6155 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6156 < # It thinks the first close brace ends the variable substitution.
6157 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6158 <
6159 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6160 <
6161 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6162 <
6163 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
6164 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6165 < LN_S=$as_ln_s
6166 < if test "$LN_S" = "ln -s"; then
6167 <  echo "$as_me:$LINENO: result: yes" >&5
6168 < echo "${ECHO_T}yes" >&6
6169 < else
6170 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6171 < echo "${ECHO_T}no, using $LN_S" >&6
6172 < fi
6173 <
6174 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6175 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6176 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6177 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6178 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6179 < else
6180 <  cat >conftest.make <<\_ACEOF
6181 < all:
6182 <        @echo 'ac_maketemp="$(MAKE)"'
6183 < _ACEOF
6184 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6185 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6186 < if test -n "$ac_maketemp"; then
6187 <  eval ac_cv_prog_make_${ac_make}_set=yes
6188 < else
6189 <  eval ac_cv_prog_make_${ac_make}_set=no
6190 < fi
6191 < rm -f conftest.make
6192 < fi
6193 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6194 <  echo "$as_me:$LINENO: result: yes" >&5
6195 < echo "${ECHO_T}yes" >&6
6196 <  SET_MAKE=
6197 < else
6198 <  echo "$as_me:$LINENO: result: no" >&5
6199 < echo "${ECHO_T}no" >&6
6200 <  SET_MAKE="MAKE=${MAKE-make}"
6201 < fi
6202 <
6203 < if test -n "$ac_tool_prefix"; then
6204 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6205 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6206 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6207 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6208 < if test "${ac_cv_prog_RANLIB+set}" = set; then
6209 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6210 < else
6211 <  if test -n "$RANLIB"; then
6212 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6213 < else
6214 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6215 < for as_dir in $PATH
6216 < do
6217 <  IFS=$as_save_IFS
6218 <  test -z "$as_dir" && as_dir=.
6219 <  for ac_exec_ext in '' $ac_executable_extensions; do
6220 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6221 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6222 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6223 <    break 2
6224 <  fi
6225 < done
6226 < done
6227 <
6228 < fi
6229 < fi
6230 < RANLIB=$ac_cv_prog_RANLIB
6231 < if test -n "$RANLIB"; then
6232 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6233 < echo "${ECHO_T}$RANLIB" >&6
6234 < else
6235 <  echo "$as_me:$LINENO: result: no" >&5
6236 < echo "${ECHO_T}no" >&6
6237 < fi
6238 <
6239 < fi
6240 < if test -z "$ac_cv_prog_RANLIB"; then
6241 <  ac_ct_RANLIB=$RANLIB
6242 <  # Extract the first word of "ranlib", so it can be a program name with args.
6243 < set dummy ranlib; ac_word=$2
6244 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6245 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6246 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6247 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6248 < else
6249 <  if test -n "$ac_ct_RANLIB"; then
6250 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6251 < else
6252 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6253 < for as_dir in $PATH
6254 < do
6255 <  IFS=$as_save_IFS
6256 <  test -z "$as_dir" && as_dir=.
6257 <  for ac_exec_ext in '' $ac_executable_extensions; do
6258 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6259 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6260 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6261 <    break 2
6262 <  fi
6263 < done
6264 < done
6265 <
6266 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6267 < fi
6268 < fi
6269 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6270 < if test -n "$ac_ct_RANLIB"; then
6271 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6272 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6273 < else
6274 <  echo "$as_me:$LINENO: result: no" >&5
6275 < echo "${ECHO_T}no" >&6
6276 < fi
6277 <
6278 <  RANLIB=$ac_ct_RANLIB
6279 < else
6280 <  RANLIB="$ac_cv_prog_RANLIB"
6281 < fi
6282 <
6283 < for ac_prog in 'bison -y' byacc
6284 < do
6285 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6286 < set dummy $ac_prog; ac_word=$2
6287 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6288 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6289 < if test "${ac_cv_prog_YACC+set}" = set; then
6290 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6291 < else
6292 <  if test -n "$YACC"; then
6293 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6294 < else
6295 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6296 < for as_dir in $PATH
6297 < do
6298 <  IFS=$as_save_IFS
6299 <  test -z "$as_dir" && as_dir=.
6300 <  for ac_exec_ext in '' $ac_executable_extensions; do
6301 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6302 <    ac_cv_prog_YACC="$ac_prog"
6303 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6304 <    break 2
6305 <  fi
6306 < done
6307 < done
6308 <
6309 < fi
6310 < fi
6311 < YACC=$ac_cv_prog_YACC
6312 < if test -n "$YACC"; then
6313 <  echo "$as_me:$LINENO: result: $YACC" >&5
6314 < echo "${ECHO_T}$YACC" >&6
6315 < else
6316 <  echo "$as_me:$LINENO: result: no" >&5
6317 < echo "${ECHO_T}no" >&6
6318 < fi
6319 <
6320 <  test -n "$YACC" && break
6321 < done
6322 < test -n "$YACC" || YACC="yacc"
6323 <
6324 < for ac_prog in flex lex
6325 < do
6326 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6327 < set dummy $ac_prog; ac_word=$2
6328 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6329 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6330 < if test "${ac_cv_prog_LEX+set}" = set; then
6331 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6332 < else
6333 <  if test -n "$LEX"; then
6334 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6335 < else
6336 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6337 < for as_dir in $PATH
6338 < do
6339 <  IFS=$as_save_IFS
6340 <  test -z "$as_dir" && as_dir=.
6341 <  for ac_exec_ext in '' $ac_executable_extensions; do
6342 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6343 <    ac_cv_prog_LEX="$ac_prog"
6344 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6345 <    break 2
6346 <  fi
6347 < done
6348 < done
6349 <
6350 < fi
6351 < fi
6352 < LEX=$ac_cv_prog_LEX
6353 < if test -n "$LEX"; then
6354 <  echo "$as_me:$LINENO: result: $LEX" >&5
6355 < echo "${ECHO_T}$LEX" >&6
6356 < else
6357 <  echo "$as_me:$LINENO: result: no" >&5
6358 < echo "${ECHO_T}no" >&6
6359 < fi
6360 <
6361 <  test -n "$LEX" && break
6362 < done
6363 < test -n "$LEX" || LEX=":"
6364 <
6365 < if test -z "$LEXLIB"
6366 < then
6367 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6368 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6369 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6370 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6371 < else
6372 <  ac_check_lib_save_LIBS=$LIBS
6373 < LIBS="-lfl  $LIBS"
6374 < cat >conftest.$ac_ext <<_ACEOF
6375 < /* confdefs.h.  */
6376 < _ACEOF
6377 < cat confdefs.h >>conftest.$ac_ext
6378 < cat >>conftest.$ac_ext <<_ACEOF
6379 < /* end confdefs.h.  */
6380 <
6381 < /* Override any gcc2 internal prototype to avoid an error.  */
6382 < #ifdef __cplusplus
6383 < extern "C"
6384 < #endif
6385 < /* We use char because int might match the return type of a gcc2
6386 <   builtin and then its argument prototype would still apply.  */
6387 < char yywrap ();
6388 < int
6389 < main ()
6390 < {
6391 < yywrap ();
6392 <  ;
6393 <  return 0;
6394 < }
6395 < _ACEOF
6396 < rm -f conftest.$ac_objext conftest$ac_exeext
6397 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6398 <  (eval $ac_link) 2>conftest.er1
6399 <  ac_status=$?
6400 <  grep -v '^ *+' conftest.er1 >conftest.err
6401 <  rm -f conftest.er1
6402 <  cat conftest.err >&5
6403 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6404 <  (exit $ac_status); } &&
6405 <         { ac_try='test -z "$ac_c_werror_flag"
6406 <                         || test ! -s conftest.err'
6407 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6408 <  (eval $ac_try) 2>&5
6409 <  ac_status=$?
6410 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6411 <  (exit $ac_status); }; } &&
6412 <         { ac_try='test -s conftest$ac_exeext'
6413 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6414 <  (eval $ac_try) 2>&5
6415 <  ac_status=$?
6416 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6417 <  (exit $ac_status); }; }; then
6418 <  ac_cv_lib_fl_yywrap=yes
6419 < else
6420 <  echo "$as_me: failed program was:" >&5
6421 < sed 's/^/| /' conftest.$ac_ext >&5
6422 <
6423 < ac_cv_lib_fl_yywrap=no
6424 < fi
6425 < rm -f conftest.err conftest.$ac_objext \
6426 <      conftest$ac_exeext conftest.$ac_ext
6427 < LIBS=$ac_check_lib_save_LIBS
6428 < fi
6429 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6430 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6431 < if test $ac_cv_lib_fl_yywrap = yes; then
6432 <  LEXLIB="-lfl"
6433 < else
6434 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6435 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6436 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
6437 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6438 < else
6439 <  ac_check_lib_save_LIBS=$LIBS
6440 < LIBS="-ll  $LIBS"
6441 < cat >conftest.$ac_ext <<_ACEOF
6442 < /* confdefs.h.  */
6443 < _ACEOF
6444 < cat confdefs.h >>conftest.$ac_ext
6445 < cat >>conftest.$ac_ext <<_ACEOF
6446 < /* end confdefs.h.  */
6447 <
6448 < /* Override any gcc2 internal prototype to avoid an error.  */
6449 < #ifdef __cplusplus
6450 < extern "C"
6451 < #endif
6452 < /* We use char because int might match the return type of a gcc2
6453 <   builtin and then its argument prototype would still apply.  */
6454 < char yywrap ();
6455 < int
6456 < main ()
6457 < {
6458 < yywrap ();
6459 <  ;
6460 <  return 0;
6461 < }
6462 < _ACEOF
6463 < rm -f conftest.$ac_objext conftest$ac_exeext
6464 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6465 <  (eval $ac_link) 2>conftest.er1
6466 <  ac_status=$?
6467 <  grep -v '^ *+' conftest.er1 >conftest.err
6468 <  rm -f conftest.er1
6469 <  cat conftest.err >&5
6470 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6471 <  (exit $ac_status); } &&
6472 <         { ac_try='test -z "$ac_c_werror_flag"
6473 <                         || test ! -s conftest.err'
6474 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6475 <  (eval $ac_try) 2>&5
6476 <  ac_status=$?
6477 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6478 <  (exit $ac_status); }; } &&
6479 <         { ac_try='test -s conftest$ac_exeext'
6480 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6481 <  (eval $ac_try) 2>&5
6482 <  ac_status=$?
6483 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6484 <  (exit $ac_status); }; }; then
6485 <  ac_cv_lib_l_yywrap=yes
6486 < else
6487 <  echo "$as_me: failed program was:" >&5
6488 < sed 's/^/| /' conftest.$ac_ext >&5
6489 <
6490 < ac_cv_lib_l_yywrap=no
6491 < fi
6492 < rm -f conftest.err conftest.$ac_objext \
6493 <      conftest$ac_exeext conftest.$ac_ext
6494 < LIBS=$ac_check_lib_save_LIBS
6495 < fi
6496 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
6497 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
6498 < if test $ac_cv_lib_l_yywrap = yes; then
6499 <  LEXLIB="-ll"
6500 < fi
6501 <
6502 < fi
6503 <
6504 < fi
6505 <
6506 < if test "x$LEX" != "x:"; then
6507 <  echo "$as_me:$LINENO: checking lex output file root" >&5
6508 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
6509 < if test "${ac_cv_prog_lex_root+set}" = set; then
6510 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6511 < else
6512 <  # The minimal lex program is just a single line: %%.  But some broken lexes
6513 < # (Solaris, I think it was) want two %% lines, so accommodate them.
6514 < cat >conftest.l <<_ACEOF
6515 < %%
6516 < %%
6517 < _ACEOF
6518 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
6519 <  (eval $LEX conftest.l) 2>&5
6520 <  ac_status=$?
6521 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6522 <  (exit $ac_status); }
6523 < if test -f lex.yy.c; then
6524 <  ac_cv_prog_lex_root=lex.yy
6525 < elif test -f lexyy.c; then
6526 <  ac_cv_prog_lex_root=lexyy
6527 < else
6528 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
6529 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
6530 <   { (exit 1); exit 1; }; }
6531 < fi
6532 < fi
6533 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
6534 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
6535 < rm -f conftest.l
6536 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
6537 <
6538 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
6539 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
6540 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
6541 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6542 < else
6543 <  # POSIX says lex can declare yytext either as a pointer or an array; the
6544 < # default is implementation-dependent. Figure out which it is, since
6545 < # not all implementations provide the %pointer and %array declarations.
6546 < ac_cv_prog_lex_yytext_pointer=no
6547 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
6548 < ac_save_LIBS=$LIBS
6549 < LIBS="$LIBS $LEXLIB"
6550 < cat >conftest.$ac_ext <<_ACEOF
6551 < `cat $LEX_OUTPUT_ROOT.c`
6552 < _ACEOF
6553 < rm -f conftest.$ac_objext conftest$ac_exeext
6554 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6555 <  (eval $ac_link) 2>conftest.er1
6556 <  ac_status=$?
6557 <  grep -v '^ *+' conftest.er1 >conftest.err
6558 <  rm -f conftest.er1
6559 <  cat conftest.err >&5
6560 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6561 <  (exit $ac_status); } &&
6562 <         { ac_try='test -z "$ac_c_werror_flag"
6563 <                         || test ! -s conftest.err'
6564 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6565 <  (eval $ac_try) 2>&5
6566 <  ac_status=$?
6567 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6568 <  (exit $ac_status); }; } &&
6569 <         { ac_try='test -s conftest$ac_exeext'
6570 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6571 <  (eval $ac_try) 2>&5
6572 <  ac_status=$?
6573 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6574 <  (exit $ac_status); }; }; then
6575 <  ac_cv_prog_lex_yytext_pointer=yes
6576 < else
6577 <  echo "$as_me: failed program was:" >&5
6578 < sed 's/^/| /' conftest.$ac_ext >&5
6579 <
6580 < fi
6581 < rm -f conftest.err conftest.$ac_objext \
6582 <      conftest$ac_exeext conftest.$ac_ext
6583 < LIBS=$ac_save_LIBS
6584 < rm -f "${LEX_OUTPUT_ROOT}.c"
6585 <
6586 < fi
6587 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
6588 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
6589 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12991 >        :
12992  
12993 < cat >>confdefs.h <<\_ACEOF
12994 < #define YYTEXT_POINTER 1
6593 < _ACEOF
12993 > else
12994 >        :
12995  
12996 < fi
12996 >        echo ""
12997 >        echo "**********************************************************"
12998 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12999 >        echo "* your compiler.                                         *"
13000 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13001 >        echo "**********************************************************"
13002 >        echo ""
13003 >        CXXFLAGS=""
13004  
13005   fi
6598 # Extract the first word of "ar", so it can be a program name with args.
6599 set dummy ar; ac_word=$2
6600 echo "$as_me:$LINENO: checking for $ac_word" >&5
6601 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6602 if test "${ac_cv_prog_AR+set}" = set; then
6603  echo $ECHO_N "(cached) $ECHO_C" >&6
6604 else
6605  if test -n "$AR"; then
6606  ac_cv_prog_AR="$AR" # Let the user override the test.
6607 else
6608 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6609 for as_dir in $PATH
6610 do
6611  IFS=$as_save_IFS
6612  test -z "$as_dir" && as_dir=.
6613  for ac_exec_ext in '' $ac_executable_extensions; do
6614  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6615    ac_cv_prog_AR="ar"
6616    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6617    break 2
6618  fi
6619 done
6620 done
13006  
13007 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13007 >
13008   fi
6624 fi
6625 AR=$ac_cv_prog_AR
6626 if test -n "$AR"; then
6627  echo "$as_me:$LINENO: result: $AR" >&5
6628 echo "${ECHO_T}$AR" >&6
6629 else
6630  echo "$as_me:$LINENO: result: no" >&5
6631 echo "${ECHO_T}no" >&6
6632 fi
13009  
13010 < if test "$AR" = "NONE"; then
13011 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
6636 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
6637 <   { (exit 1); exit 1; }; }
6638 <  cat >confcache <<\_ACEOF
6639 < # This file is a shell script that caches the results of configure
6640 < # tests run on this system so they can be shared between configure
6641 < # scripts and configure runs, see configure's option --config-cache.
6642 < # It is not useful on other systems.  If it contains results you don't
6643 < # want to keep, you may remove or edit it.
6644 < #
6645 < # config.status only pays attention to the cache file if you give it
6646 < # the --recheck option to rerun configure.
6647 < #
6648 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
6649 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
6650 < # following values.
13010 >     ;;
13011 > esac
13012  
13013 +
13014 + cat >>confdefs.h <<\_ACEOF
13015 + #define OBAPI
13016   _ACEOF
13017  
6654 # The following way of writing the cache mishandles newlines in values,
6655 # but we know of no workaround that is simple, portable, and efficient.
6656 # So, don't put newlines in cache variables' values.
6657 # Ultrix sh set writes to stderr and can't be redirected directly,
6658 # and sets the high bit in the cache file unless we assign to the vars.
6659 {
6660  (set) 2>&1 |
6661    case `(ac_space=' '; set | grep ac_space) 2>&1` in
6662    *ac_space=\ *)
6663      # `set' does not quote correctly, so add quotes (double-quote
6664      # substitution turns \\\\ into \\, and sed turns \\ into \).
6665      sed -n \
6666        "s/'/'\\\\''/g;
6667          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6668      ;;
6669    *)
6670      # `set' quotes correctly as required by POSIX, so do not add quotes.
6671      sed -n \
6672        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
6673      ;;
6674    esac;
6675 } |
6676  sed '
6677     t clear
6678     : clear
6679     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6680     t end
6681     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6682     : end' >>confcache
6683 if diff $cache_file confcache >/dev/null 2>&1; then :; else
6684  if test -w $cache_file; then
6685    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
6686    cat confcache >$cache_file
6687  else
6688    echo "not updating unwritable cache $cache_file"
6689  fi
6690 fi
6691 rm -f confcache
6692  exit 1
6693 fi
13018  
13019  
13020  
# Line 6722 | Line 13046 | echo '#include <mpi.h>' > conftest.cc
13046   echo "$as_me:$LINENO: checking for mpi.h" >&5
13047   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13048   have_mpi_h=0
13049 + rm -f conftest*
13050   echo '#include <mpi.h>' > conftest.cc
13051 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13051 > if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13052          echo "$as_me:$LINENO: result: yes" >&5
13053   echo "${ECHO_T}yes" >&6
13054          have_mpi_h=1
13055   else
13056 +        if test -s conftest.out ; then
13057 +                cat conftest.out >> config.log
13058 +        fi
13059          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13060   echo "${ECHO_T}no! Check MPI include paths" >&6
13061          USE_MPI="no"
# Line 6745 | Line 13073 | cat >conftest.f90 <<EOF
13073   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13074   have_mpif_h=0
13075   rm -f conftest*
13076 < cat >conftest.f90 <<EOF
13076 > cat >conftest.$ac_ext <<EOF
13077   program main
13078     include 'mpif.h'
13079   end
13080   EOF
13081 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13081 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13082          echo "$as_me:$LINENO: result: yes" >&5
13083   echo "${ECHO_T}yes" >&6
13084          MPI_F90_INC="$MPI_INC_DIR"
# Line 6804 | Line 13132 | int
13132   /* We use char because int might match the return type of a gcc2
13133     builtin and then its argument prototype would still apply.  */
13134   char MPI_Init ();
13135 + #ifdef FC_DUMMY_MAIN
13136 + #ifndef FC_DUMMY_MAIN_EQ_F77
13137 + #  ifdef __cplusplus
13138 +     extern "C"
13139 + #  endif
13140 +   int FC_DUMMY_MAIN() { return 1; }
13141 + #endif
13142 + #endif
13143   int
13144   main ()
13145   {
# Line 6874 | Line 13210 | int
13210   /* We use char because int might match the return type of a gcc2
13211     builtin and then its argument prototype would still apply.  */
13212   char MPI_Init ();
13213 + #ifdef FC_DUMMY_MAIN
13214 + #ifndef FC_DUMMY_MAIN_EQ_F77
13215 + #  ifdef __cplusplus
13216 +     extern "C"
13217 + #  endif
13218 +   int FC_DUMMY_MAIN() { return 1; }
13219 + #endif
13220 + #endif
13221   int
13222   main ()
13223   {
# Line 6945 | Line 13289 | int
13289   /* We use char because int might match the return type of a gcc2
13290     builtin and then its argument prototype would still apply.  */
13291   char MPI_Init ();
13292 + #ifdef FC_DUMMY_MAIN
13293 + #ifndef FC_DUMMY_MAIN_EQ_F77
13294 + #  ifdef __cplusplus
13295 +     extern "C"
13296 + #  endif
13297 +   int FC_DUMMY_MAIN() { return 1; }
13298 + #endif
13299 + #endif
13300   int
13301   main ()
13302   {
# Line 6993 | Line 13345 | fi
13345   fi
13346  
13347   fi
13348 <
6997 < $as_unset ac_cv_lib_mpi_MPI_Init
13348 > $as_unset ac_cv_lib_mpich_MPI_Init
13349   if test x = x"$MPI_LIB"; then
13350 < echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13351 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13352 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13350 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13351 > echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13352 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13353    echo $ECHO_N "(cached) $ECHO_C" >&6
13354   else
13355    ac_check_lib_save_LIBS=$LIBS
13356 < LIBS="-lmpi -llam -lpthread $LIBS"
13356 > LIBS="-lmpich "-lpmpich" $LIBS"
13357   cat >conftest.$ac_ext <<_ACEOF
13358   /* confdefs.h.  */
13359   _ACEOF
# Line 7017 | Line 13368 | int
13368   /* We use char because int might match the return type of a gcc2
13369     builtin and then its argument prototype would still apply.  */
13370   char MPI_Init ();
13371 + #ifdef FC_DUMMY_MAIN
13372 + #ifndef FC_DUMMY_MAIN_EQ_F77
13373 + #  ifdef __cplusplus
13374 +     extern "C"
13375 + #  endif
13376 +   int FC_DUMMY_MAIN() { return 1; }
13377 + #endif
13378 + #endif
13379   int
13380   main ()
13381   {
# Line 7047 | Line 13406 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13406    ac_status=$?
13407    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13408    (exit $ac_status); }; }; then
13409 <  ac_cv_lib_mpi_MPI_Init=yes
13409 >  ac_cv_lib_mpich_MPI_Init=yes
13410   else
13411    echo "$as_me: failed program was:" >&5
13412   sed 's/^/| /' conftest.$ac_ext >&5
13413  
13414 < ac_cv_lib_mpi_MPI_Init=no
13414 > ac_cv_lib_mpich_MPI_Init=no
13415   fi
13416   rm -f conftest.err conftest.$ac_objext \
13417        conftest$ac_exeext conftest.$ac_ext
13418   LIBS=$ac_check_lib_save_LIBS
13419   fi
13420 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13421 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13422 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13423 <  MPI_LIB="-lmpi -llam -lpthread"
7065 < else
7066 <
7067 <             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7068 < echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7069 <   { (exit 1); exit 1; }; }
7070 <             USE_MPI="no"
7071 <
13420 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13421 > echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13422 > if test $ac_cv_lib_mpich_MPI_Init = yes; then
13423 >  MPI_LIB="-lpmpich -lmpich"
13424   fi
13425  
13426   fi
7075
7076
7077
7078 echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
7079 echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
7080 MPI_F90_LIB=""
7081 if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7082        MPI_F90_LIB="-lfmpich"
7083 elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7084        MPI_F90_LIB="-llamf77mpi"
7085 else
7086                        MPI_F90_LIB="  "
7087 fi
7088 echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
7089 echo "${ECHO_T}found $MPI_F90_LIB" >&6
7090
7091
7092 fi
7093
7094
7095
7096 # Check whether --with-sprng or --without-sprng was given.
7097 if test "${with_sprng+set}" = set; then
7098  withval="$with_sprng"
7099  with_sprng=$withval
7100 else
7101  with_sprng="/usr/local"
7102 fi;
7103
7104 case "x$with_sprng" in
7105        xyes | "x")  USE_SPRNG=yes;;
7106        xno) USE_SPRNG=no ;;
7107        *) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7108 esac
7109 if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7110        SPRNG="/usr/local"
7111 fi
7112 if test "$USE_SPRNG" = "yes"; then
7113
7114
7115 # Set variables...
7116 SPRNG_LIB_DIR="$SPRNG/lib"
7117 SPRNG_INC_DIR="$SPRNG/include"
7118
7119
7120
7121 echo "$as_me:$LINENO: checking for sprng.h" >&5
7122 echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
7123 have_sprng_h=0
7124 echo '#include <sprng.h>' > conftest.cc
7125 if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
7126        echo "$as_me:$LINENO: result: yes" >&5
7127 echo "${ECHO_T}yes" >&6
7128        have_sprng_h=1
7129 else
7130        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7131 echo "${ECHO_T}no! Check SPRNG include path!" >&6
7132        USE_SPRNG="no"
7133 fi
7134 rm -f conftest*
7135 if test "$have_sprng_h" = 1; then
7136
7137 cat >>confdefs.h <<\_ACEOF
7138 #define HAVE_SPRNG_H 1
7139 _ACEOF
7140
7141 fi
7142
7143 ac_ext=c
7144 ac_cpp='$CPP $CPPFLAGS'
7145 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7146 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7147 ac_compiler_gnu=$ac_cv_c_compiler_gnu
7148
7149 ac_save_LDFLAGS=$LDFLAGS
7150 LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
13427  
13428 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
13429 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
13430 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
13428 > $as_unset ac_cv_lib_mpi_MPI_Init
13429 > if test x = x"$MPI_LIB"; then
13430 > echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13431 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13432 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13433    echo $ECHO_N "(cached) $ECHO_C" >&6
13434   else
13435    ac_check_lib_save_LIBS=$LIBS
13436 < LIBS="-lsprng  $LIBS"
13436 > LIBS="-lmpi -llam -lpthread $LIBS"
13437   cat >conftest.$ac_ext <<_ACEOF
13438   /* confdefs.h.  */
13439   _ACEOF
# Line 7169 | Line 13447 | char init_rng ();
13447   #endif
13448   /* We use char because int might match the return type of a gcc2
13449     builtin and then its argument prototype would still apply.  */
13450 < char init_rng ();
13450 > char MPI_Init ();
13451 > #ifdef FC_DUMMY_MAIN
13452 > #ifndef FC_DUMMY_MAIN_EQ_F77
13453 > #  ifdef __cplusplus
13454 >     extern "C"
13455 > #  endif
13456 >   int FC_DUMMY_MAIN() { return 1; }
13457 > #endif
13458 > #endif
13459   int
13460   main ()
13461   {
13462 < init_rng ();
13462 > MPI_Init ();
13463    ;
13464    return 0;
13465   }
# Line 7200 | Line 13486 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13486    ac_status=$?
13487    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13488    (exit $ac_status); }; }; then
13489 <  ac_cv_lib_sprng_init_rng=yes
13489 >  ac_cv_lib_mpi_MPI_Init=yes
13490   else
13491    echo "$as_me: failed program was:" >&5
13492   sed 's/^/| /' conftest.$ac_ext >&5
13493  
13494 < ac_cv_lib_sprng_init_rng=no
13494 > ac_cv_lib_mpi_MPI_Init=no
13495   fi
13496   rm -f conftest.err conftest.$ac_objext \
13497        conftest$ac_exeext conftest.$ac_ext
13498   LIBS=$ac_check_lib_save_LIBS
13499   fi
13500 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
13501 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
13502 < if test $ac_cv_lib_sprng_init_rng = yes; then
13503 <  SPRNG_LIB="-lsprng"
13500 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13501 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13502 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13503 >  MPI_LIB="-lmpi -llam -lpthread"
13504   else
13505  
13506 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13507 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13506 >             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
13507 > echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
13508     { (exit 1); exit 1; }; }
13509 <             USE_SPRNG="no"
13509 >             USE_MPI="no"
13510  
13511   fi
13512  
13513 + fi
13514  
13515 < if test "$USE_SPRNG" = "no"; then
13516 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
13517 < echo "$as_me: error: No working SPRNG library found" >&2;}
13518 <   { (exit 1); exit 1; }; }
13515 >
13516 >
13517 > echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13518 > echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13519 > MPI_F90_LIB=""
13520 > if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
13521 >        MPI_F90_LIB="-lfmpich"
13522 > elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
13523 >        MPI_F90_LIB="-llamf77mpi"
13524 > else
13525 >                        MPI_F90_LIB="  "
13526   fi
13527 + echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
13528 + echo "${ECHO_T}found $MPI_F90_LIB" >&6
13529  
13530  
13531   fi
13532  
13533  
13534  
13535 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
13536 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
13535 > USE_CGAL=no
13536 > cgal_makefile=auto
13537  
13538 < # Check whether --with-mkl or --without-mkl was given.
13539 < if test "${with_mkl+set}" = set; then
13540 <  withval="$with_mkl"
13541 <     echo "$as_me:$LINENO: result: yes" >&5
13542 < echo "${ECHO_T}yes" >&6
7247 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7248 <        mkldir="$dir"
7249 <        if test -f "$dir/include/mkl.h"; then
7250 <            found_mkl="yes";
7251 <            break;
7252 <        fi
7253 <    done
7254 <    if test x_$found_mkl != x_yes; then
7255 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7256 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7257 <   { (exit 1); exit 1; }; }
7258 <    else
7259 <        printf "MKL includes found in $mkldir/include\n";
7260 <    fi
13538 > # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13539 > if test "${with_cgal_makefile+set}" = set; then
13540 >  withval="$with_cgal_makefile"
13541 >  cgal_makefile="$withval"
13542 > fi;
13543  
13544 + if test "x$cgal_makefile" != xno; then
13545  
13546 +  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13547 +    cgal_makefile="$CGAL_MAKEFILE"
13548 +  fi
13549  
13550 <  ac_ext=c
13551 < ac_cpp='$CPP $CPPFLAGS'
7266 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7267 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7268 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13550 >  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13551 > echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13552  
13553 <  ac_save_CPPFLAGS=$CPPFLAGS
13554 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
13555 <  ac_save_LDFLAGS=$LDFLAGS
13556 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
13557 <  if test "${ac_cv_header_mkl_h+set}" = set; then
13558 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
13559 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13560 < if test "${ac_cv_header_mkl_h+set}" = set; then
13553 >  if test -f "$cgal_makefile"; then
13554 >
13555 >    cat >config.tmp.Makefile <<EOF
13556 > include $cgal_makefile
13557 > default:
13558 >        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13559 >        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13560 >        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13561 >        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13562 >        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13563 >        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13564 >        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13565 >        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13566 >        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13567 >        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13568 >        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13569 >        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13570 > EOF
13571 >
13572 >    make -s -f config.tmp.Makefile
13573 >    . config.tmp.cgalvariables
13574 >
13575 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
13576 >
13577 >    if test "x$CGAL_INCLDIR" = "x"; then
13578 >      CGAL_INCLDIR=""
13579 >    fi
13580 >
13581 >    if test "x$CGAL_LIBDIR" = "x"; then
13582 >      CGAL_LIBDIR=""
13583 >    fi
13584 >
13585 >    if test "x$CGAL_RLIBDIR" = "x"; then
13586 >      CGAL_RLIBDIR=""
13587 >    fi
13588 >
13589 >    if test "x$LEDA_INCLDIR" = "x"; then
13590 >      LEDA_INCLDIR=""
13591 >    fi
13592 >
13593 >    if test "x$LEDA_LIBDIR" = "x"; then
13594 >      LEDA_LIBDIR=""
13595 >    fi
13596 >
13597 >    if test "x$LEDA_RLIBDIR" = "x"; then
13598 >      LEDA_RLIBDIR=""
13599 >    fi
13600 >
13601 >    if test "x$GMP_INCLDIR" = "x"; then
13602 >      GMP_INCLDIR=""
13603 >    fi
13604 >
13605 >    if test "x$GMP_LIBDIR" = "x"; then
13606 >      GMP_LIBDIR=""
13607 >    fi
13608 >
13609 >    if test "x$GMP_RLIBDIR" = "x"; then
13610 >      GMP_RLIBDIR=""
13611 >    fi
13612 >
13613 >    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13614 > echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13615 >    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13616 > echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13617 >    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13618 > echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13619 >    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13620 > echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13621 >    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13622 > echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13623 >    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13624 > echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13625 >    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13626 > echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13627 >    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13628 > echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13629 >    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13630 > echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13631 >
13632 >    ac_ext=cc
13633 > ac_cpp='$CXXCPP $CPPFLAGS'
13634 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13635 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13636 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13637 >
13638 >    save_CXXFLAGS="$CXXFLAGS"
13639 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13640 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13641 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13642 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13643 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13644    echo $ECHO_N "(cached) $ECHO_C" >&6
13645   fi
13646 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13647 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13646 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13647 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13648   else
13649    # Is the header compilable?
13650 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
13651 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13650 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13651 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13652   cat >conftest.$ac_ext <<_ACEOF
13653   /* confdefs.h.  */
13654   _ACEOF
# Line 7290 | Line 13656 | $ac_includes_default
13656   cat >>conftest.$ac_ext <<_ACEOF
13657   /* end confdefs.h.  */
13658   $ac_includes_default
13659 < #include <mkl.h>
13659 > #include <CGAL/Cartesian.h>
13660   _ACEOF
13661   rm -f conftest.$ac_objext
13662   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7301 | Line 13667 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13667    cat conftest.err >&5
13668    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13669    (exit $ac_status); } &&
13670 <         { ac_try='test -z "$ac_c_werror_flag"
13670 >         { ac_try='test -z "$ac_cxx_werror_flag"
13671                           || test ! -s conftest.err'
13672    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13673    (eval $ac_try) 2>&5
# Line 7326 | Line 13692 | echo "$as_me:$LINENO: checking mkl.h presence" >&5
13692   echo "${ECHO_T}$ac_header_compiler" >&6
13693  
13694   # Is the header present?
13695 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
13696 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13695 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13696 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13697   cat >conftest.$ac_ext <<_ACEOF
13698   /* confdefs.h.  */
13699   _ACEOF
13700   cat confdefs.h >>conftest.$ac_ext
13701   cat >>conftest.$ac_ext <<_ACEOF
13702   /* end confdefs.h.  */
13703 < #include <mkl.h>
13703 > #include <CGAL/Cartesian.h>
13704   _ACEOF
13705   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13706    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 7345 | Line 13711 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13711    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13712    (exit $ac_status); } >/dev/null; then
13713    if test -s conftest.err; then
13714 <    ac_cpp_err=$ac_c_preproc_warn_flag
13715 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13714 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13715 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13716    else
13717      ac_cpp_err=
13718    fi
# Line 7366 | Line 13732 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
13732   echo "${ECHO_T}$ac_header_preproc" >&6
13733  
13734   # So?  What about this header?
13735 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13735 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13736    yes:no: )
13737 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13738 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13739 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
13740 < echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
13737 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13738 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13739 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13740 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13741      ac_header_preproc=yes
13742      ;;
13743    no:yes:* )
13744 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13745 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13746 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
13747 < echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
13748 <    { echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
13749 < echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
13750 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
13751 < echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13752 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13753 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13754 <    { echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
13755 < echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
13744 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13745 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13746 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13747 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13748 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13749 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13750 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13751 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13752 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13753 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13754 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13755 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13756      (
13757        cat <<\_ASBOX
13758   ## ------------------------------ ##
# Line 7397 | Line 13763 | echo "$as_me:$LINENO: checking for mkl.h" >&5
13763        sed "s/^/$as_me: WARNING:     /" >&2
13764      ;;
13765   esac
13766 < echo "$as_me:$LINENO: checking for mkl.h" >&5
13767 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13768 < if test "${ac_cv_header_mkl_h+set}" = set; then
13766 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13767 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13768 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13769    echo $ECHO_N "(cached) $ECHO_C" >&6
13770   else
13771 <  ac_cv_header_mkl_h=$ac_header_preproc
13771 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13772   fi
13773 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13774 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13773 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13774 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13775  
13776   fi
13777 < if test $ac_cv_header_mkl_h = yes; then
13778 <
7413 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
7414 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
7415 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
7416 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13777 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13778 >  cgal=yes
13779   else
13780 <  ac_check_lib_save_LIBS=$LIBS
13781 < LIBS="-lmkl  $LIBS"
13780 >  cgal=no
13781 > fi
13782 >
13783 >
13784 >    CXXFLAGS="$save_CXXFLAGS"
13785 >
13786 >    if test "x$cgal" = xyes; then
13787 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
13788 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
13789 >      LOCATION=${CGAL_INCLDIR}
13790 >      LOCATION=${LOCATION:-/usr/include}
13791 >      if test -f $LOCATION/CGAL/version.h; then
13792 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
13793 >      else
13794 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
13795 >      fi
13796 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
13797 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
13798 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
13799 >      else
13800 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
13801 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
13802 >        cgal=no
13803 >      fi
13804 >    fi
13805 >
13806 >    if test "x$cgal" = xyes; then
13807 >      CGAL_LIBS="-lCGAL"
13808 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13809 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13810 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13811 >        CGAL_USES_LEDA=yes
13812 >        echo "$as_me:$LINENO: result: yes" >&5
13813 > echo "${ECHO_T}yes" >&6
13814 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13815 >      else
13816 >        echo "$as_me:$LINENO: result: no" >&5
13817 > echo "${ECHO_T}no" >&6
13818 >        CGAL_USES_LEDA=no
13819 >      fi
13820 >
13821 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13822 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13823 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13824 >        CGAL_USES_GMP=yes
13825 >        echo "$as_me:$LINENO: result: yes" >&5
13826 > echo "${ECHO_T}yes" >&6
13827 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13828 >      else
13829 >        echo "$as_me:$LINENO: result: no" >&5
13830 > echo "${ECHO_T}no" >&6
13831 >        CGAL_USES_GMP=no
13832 >      fi
13833 >
13834 >      CGAL_LIBS="$CGAL_LIBS -lm"
13835 >
13836 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
13837 >
13838 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13839 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13840 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13841 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13842 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13843 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13844 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13845 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13846 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13847 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13848 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13849 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13850 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13851 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13852 >    fi
13853 >
13854 >    if test "x$cgal" = xyes; then
13855 >      save_LIBS="$LIBS"
13856 >      LIBS="$LIBS -L$CGAL_LIBDIR"
13857 >      if test "x$CGAL_USES_LEDA" = xyes; then
13858 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13859 >      fi
13860 >      # if test "x$CGAL_USES_GMP" = xyes; then
13861 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13862 >      # fi
13863 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13864 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13865 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13866 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13867 > save_LIBS_CHECK_CXX_LIB="$LIBS"
13868 > LIBS="-lCGAL  $LIBS"
13869   cat >conftest.$ac_ext <<_ACEOF
13870   /* confdefs.h.  */
13871   _ACEOF
13872   cat confdefs.h >>conftest.$ac_ext
13873   cat >>conftest.$ac_ext <<_ACEOF
13874   /* end confdefs.h.  */
13875 <
13876 < /* Override any gcc2 internal prototype to avoid an error.  */
13877 < #ifdef __cplusplus
13878 < extern "C"
13875 > #include <CGAL/Cartesian.h>
13876 > #ifdef FC_DUMMY_MAIN
13877 > #ifndef FC_DUMMY_MAIN_EQ_F77
13878 > #  ifdef __cplusplus
13879 >     extern "C"
13880 > #  endif
13881 >   int FC_DUMMY_MAIN() { return 1; }
13882   #endif
13883 < /* We use char because int might match the return type of a gcc2
7432 <   builtin and then its argument prototype would still apply.  */
7433 < char vslNewStream ();
13883 > #endif
13884   int
13885   main ()
13886   {
13887 < vslNewStream ();
13887 > ::CGAL::Cartesian<int>::Point_2 P
13888    ;
13889    return 0;
13890   }
# Line 7448 | Line 13898 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13898    cat conftest.err >&5
13899    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13900    (exit $ac_status); } &&
13901 <         { ac_try='test -z "$ac_c_werror_flag"
13901 >         { ac_try='test -z "$ac_cxx_werror_flag"
13902                           || test ! -s conftest.err'
13903    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13904    (eval $ac_try) 2>&5
# Line 7461 | Line 13911 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13911    ac_status=$?
13912    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13913    (exit $ac_status); }; }; then
13914 <  ac_cv_lib_mkl_vslNewStream=yes
13914 >  echo "$as_me:$LINENO: result: yes" >&5
13915 > echo "${ECHO_T}yes" >&6
13916 > cgal=yes
13917   else
13918    echo "$as_me: failed program was:" >&5
13919   sed 's/^/| /' conftest.$ac_ext >&5
13920  
13921 < ac_cv_lib_mkl_vslNewStream=no
13921 > echo "$as_me:$LINENO: result: no" >&5
13922 > echo "${ECHO_T}no" >&6
13923 > cgal=no
13924   fi
13925   rm -f conftest.err conftest.$ac_objext \
13926        conftest$ac_exeext conftest.$ac_ext
13927 < LIBS=$ac_check_lib_save_LIBS
13928 < fi
13929 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
13930 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
7477 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
7478 <  MKL_LIBDIR="${mkldir}/lib/32",
7479 <                     MKL_LIB="-lmkl -lvml -lguide",
7480 <                     HAVE_MKL="yes"
7481 < fi
13927 > CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13928 > LIBS="$save_LIBS_CHECK_CXX_LIB"
13929 >      LIBS="$save_LIBS"
13930 >    fi
13931  
13932 <
7484 < else
7485 <  MKL_INC="-I${mkldir}/include"
7486 < fi
7487 <
7488 <
7489 <  CPPFLAGS=$ac_save_CPPFLAGS
7490 <  LDFLAGS=$ac_save_LDFLAGS
13932 >  fi
13933    ac_ext=c
13934   ac_cpp='$CPP $CPPFLAGS'
13935   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7495 | Line 13937 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
13937   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13938  
13939  
13940 <  if test x_$HAVE_MKL != x_yes; then
7499 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
7500 < echo "$as_me: error: Can't build with MKL" >&2;}
7501 <   { (exit 1); exit 1; }; }
7502 <  fi
13940 > fi
13941  
13942 + if test "x$cgal" = xyes; then
13943 +  USE_CGAL=yes
13944  
13945 + cat >>confdefs.h <<\_ACEOF
13946 + #define HAVE_CGAL 1
13947 + _ACEOF
13948  
13949  
13950 + cat >>confdefs.h <<_ACEOF
13951 + #define CGAL_VERSION $CGAL_VERSION
13952 + _ACEOF
13953  
13954 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
13955 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13956 + echo "$as_me: WARNING: *****************************************************" >&2;}
13957 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
13958 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
13959 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
13960 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
13961 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13962 + echo "$as_me: WARNING: *****************************************************" >&2;}
13963 +  fi
13964   else
13965 +   if test "x$cgal_makefile" != xno; then
13966 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
13967 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
13968 +  fi
13969 +  CGAL_INCLDIR=
13970 +  CGAL_LIBDIR=
13971 +  CGAL_RLIBDIR=
13972 +  CGAL_DEFINES=
13973 +  CGAL_CXXFLAGS=
13974 +  CGAL_LIBS=
13975 + fi
13976  
7510    echo "$as_me:$LINENO: result: no" >&5
7511 echo "${ECHO_T}no" >&6
13977  
13978 < fi;
13978 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
13979  
13980 + CGAL_LIB_DIR=${CGAL_LIBDIR}
13981  
13982 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13983  
13984  
13985  
7519 OBJEXT=".$OBJEXT"
13986  
7521 OOPSE=oopse
13987  
13988 < if test "x${prefix}" = "xNONE"
13989 < then
13990 <  OOPSE_HOME=${ac_default_prefix}/oopse
13988 >
13989 > # Check whether --enable-doxygen or --disable-doxygen was given.
13990 > if test "${enable_doxygen+set}" = set; then
13991 >  enableval="$enable_doxygen"
13992 >
13993 > fi;
13994 > # Check whether --enable-dot or --disable-dot was given.
13995 > if test "${enable_dot+set}" = set; then
13996 >  enableval="$enable_dot"
13997 >
13998 > fi;
13999 > # Check whether --enable-html-docs or --disable-html-docs was given.
14000 > if test "${enable_html_docs+set}" = set; then
14001 >  enableval="$enable_html_docs"
14002 >
14003   else
14004 <  OOPSE_HOME=${prefix}/oopse
7528 < fi
7529 < # Check whether --enable-oopse-home or --disable-oopse-home was given.
7530 < if test "${enable_oopse_home+set}" = set; then
7531 <  enableval="$enable_oopse_home"
7532 <  OOPSE_HOME="${enableval}"
14004 >   enable_html_docs=yes
14005   fi;
14006 + # Check whether --enable-latex-docs or --disable-latex-docs was given.
14007 + if test "${enable_latex_docs+set}" = set; then
14008 +  enableval="$enable_latex_docs"
14009  
14010 < case "x$INSTALL" in
14011 <   x/*) ;;
14012 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
14010 > else
14011 >   enable_latex_docs=no
14012 > fi;
14013 > if test "x$enable_doxygen" = xno; then
14014 >        enable_doc=no
14015 > else
14016 >        # Extract the first word of "doxygen", so it can be a program name with args.
14017 > set dummy doxygen; ac_word=$2
14018 > echo "$as_me:$LINENO: checking for $ac_word" >&5
14019 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
14020 > if test "${ac_cv_path_DOXYGEN+set}" = set; then
14021 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14022 > else
14023 >  case $DOXYGEN in
14024 >  [\\/]* | ?:[\\/]*)
14025 >  ac_cv_path_DOXYGEN="$DOXYGEN" # Let the user override the test with a path.
14026 >  ;;
14027 >  *)
14028 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14029 > for as_dir in $PATH
14030 > do
14031 >  IFS=$as_save_IFS
14032 >  test -z "$as_dir" && as_dir=.
14033 >  for ac_exec_ext in '' $ac_executable_extensions; do
14034 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14035 >    ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
14036 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
14037 >    break 2
14038 >  fi
14039 > done
14040 > done
14041 >
14042 >  ;;
14043   esac
14044 + fi
14045 + DOXYGEN=$ac_cv_path_DOXYGEN
14046  
14047 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14047 > if test -n "$DOXYGEN"; then
14048 >  echo "$as_me:$LINENO: result: $DOXYGEN" >&5
14049 > echo "${ECHO_T}$DOXYGEN" >&6
14050 > else
14051 >  echo "$as_me:$LINENO: result: no" >&5
14052 > echo "${ECHO_T}no" >&6
14053 > fi
14054  
14055 < CFLAGS=${CFLAGS-""}
14056 < CXXFLAGS=${CXXFLAGS-""}
14057 < CPPFLAGS=${CPPFLAGS-""}
14058 < FFLAGS=${FFLAGS-""}
14059 < F90FLAGS=${F90FLAGS-""}
14060 < LDFLAGS=${LDFLAGS-""}
14061 < DEBUG=${DEBUG-"-g"}
14062 <
14063 < case $debug in
14064 <  1)
14065 <     FFLAGS="$DEBUG $FFLAGS"
14066 <     F90FLAGS="$DEBUG $F90FLAGS"
14067 <     ;;
14055 >        if test "x$DOXYGEN" = x; then
14056 >                if test "x$enable_doxygen" = xyes; then
14057 >                        { { echo "$as_me:$LINENO: error: could not find doxygen" >&5
14058 > echo "$as_me: error: could not find doxygen" >&2;}
14059 >   { (exit 1); exit 1; }; }
14060 >                fi
14061 >                enable_doc=no
14062 >        else
14063 >                enable_doc=yes
14064 >                # Extract the first word of "dot", so it can be a program name with args.
14065 > set dummy dot; ac_word=$2
14066 > echo "$as_me:$LINENO: checking for $ac_word" >&5
14067 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
14068 > if test "${ac_cv_path_DOT+set}" = set; then
14069 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14070 > else
14071 >  case $DOT in
14072 >  [\\/]* | ?:[\\/]*)
14073 >  ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
14074 >  ;;
14075    *)
14076 <     ;;
14076 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14077 > for as_dir in $PATH
14078 > do
14079 >  IFS=$as_save_IFS
14080 >  test -z "$as_dir" && as_dir=.
14081 >  for ac_exec_ext in '' $ac_executable_extensions; do
14082 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14083 >    ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
14084 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
14085 >    break 2
14086 >  fi
14087 > done
14088 > done
14089 >
14090 >  ;;
14091   esac
14092 + fi
14093 + DOT=$ac_cv_path_DOT
14094  
14095 + if test -n "$DOT"; then
14096 +  echo "$as_me:$LINENO: result: $DOT" >&5
14097 + echo "${ECHO_T}$DOT" >&6
14098 + else
14099 +  echo "$as_me:$LINENO: result: no" >&5
14100 + echo "${ECHO_T}no" >&6
14101 + fi
14102  
14103 +        fi
14104 + fi
14105  
14106 + if test "x$enable_doc" = xyes; then
14107 +  DOC=1
14108 + else
14109 +  DOC=0
14110 + fi
14111  
14112  
14113 + if test x$DOT = x; then
14114 +        if test "x$enable_dot" = xyes; then
14115 +                { { echo "$as_me:$LINENO: error: could not find dot" >&5
14116 + echo "$as_me: error: could not find dot" >&2;}
14117 +   { (exit 1); exit 1; }; }
14118 +        fi
14119 +        enable_dot=no
14120 + else
14121 +        enable_dot=yes
14122 + fi
14123  
14124  
14125  
# Line 7572 | Line 14132 | esac
14132  
14133  
14134  
7575          ac_config_headers="$ac_config_headers src/config.h"
14135  
14136 <          ac_config_files="$ac_config_files make/Makefile"
14136 >
14137 >
14138 >
14139 >
14140 >
14141 >
14142 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14143  
14144  
14145   cat >confcache <<\_ACEOF
# Line 7939 | Line 14504 | This file was extended by OOPSE $as_me 2.0, which was
14504   } >&5
14505   cat >&5 <<_CSEOF
14506  
14507 < This file was extended by OOPSE $as_me 2.0, which was
14507 > This file was extended by OOPSE $as_me 3.0, which was
14508   generated by GNU Autoconf 2.59.  Invocation command line was
14509  
14510    CONFIG_FILES    = $CONFIG_FILES
# Line 8002 | Line 14567 | OOPSE config.status 2.0
14567  
14568   cat >>$CONFIG_STATUS <<_ACEOF
14569   ac_cs_version="\\
14570 < OOPSE config.status 2.0
14570 > OOPSE config.status 3.0
14571   configured by $0, generated by GNU Autoconf 2.59,
14572    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14573  
# Line 8106 | Line 14671 | do
14671    case "$ac_config_target" in
14672    # Handling of arguments.
14673    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14674 <  "utils/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS utils/getopt.h:utils/gnugetopt.h" ;;
14674 >  "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14675 >  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14676 >  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14677 >  "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14678    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14679    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
14680   echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
# Line 8193 | Line 14761 | s,@PROGNAME@,$PROGNAME,;t t
14761   s,@ECHO_N@,$ECHO_N,;t t
14762   s,@ECHO_T@,$ECHO_T,;t t
14763   s,@LIBS@,$LIBS,;t t
8196 s,@PROGNAME@,$PROGNAME,;t t
8197 s,@debug@,$debug,;t t
14764   s,@build@,$build,;t t
14765   s,@build_cpu@,$build_cpu,;t t
14766   s,@build_vendor@,$build_vendor,;t t
# Line 8203 | Line 14769 | s,@CC@,$CC,;t t
14769   s,@host_cpu@,$host_cpu,;t t
14770   s,@host_vendor@,$host_vendor,;t t
14771   s,@host_os@,$host_os,;t t
14772 < s,@CC@,$CC,;t t
14773 < s,@CFLAGS@,$CFLAGS,;t t
14772 > s,@PROGNAME@,$PROGNAME,;t t
14773 > s,@debug@,$debug,;t t
14774 > s,@CXX@,$CXX,;t t
14775 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14776   s,@LDFLAGS@,$LDFLAGS,;t t
14777   s,@CPPFLAGS@,$CPPFLAGS,;t t
14778 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14778 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14779   s,@EXEEXT@,$EXEEXT,;t t
14780   s,@OBJEXT@,$OBJEXT,;t t
14781 < s,@CXX@,$CXX,;t t
14782 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14783 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14784 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14785 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14786 < s,@F90@,$F90,;t t
8219 < s,@F90FLAGS@,$F90FLAGS,;t t
8220 < s,@ac_ct_F90@,$ac_ct_F90,;t t
8221 < s,@PREPFLAG@,$PREPFLAG,;t t
8222 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8223 < s,@F90LIBS@,$F90LIBS,;t t
8224 < s,@F90_FUNC@,$F90_FUNC,;t t
8225 < s,@F90_FUNC_@,$F90_FUNC_,;t t
8226 < s,@MOD@,$MOD,;t t
8227 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8228 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8229 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14781 > s,@CC@,$CC,;t t
14782 > s,@CFLAGS@,$CFLAGS,;t t
14783 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14784 > s,@FC@,$FC,;t t
14785 > s,@FCFLAGS@,$FCFLAGS,;t t
14786 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14787   s,@CPP@,$CPP,;t t
14788   s,@EGREP@,$EGREP,;t t
8232 s,@LIBOBJS@,$LIBOBJS,;t t
8233 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8234 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8235 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14789   s,@LN_S@,$LN_S,;t t
14790   s,@SET_MAKE@,$SET_MAKE,;t t
14791   s,@RANLIB@,$RANLIB,;t t
14792   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
14793 < s,@YACC@,$YACC,;t t
14794 < s,@LEX@,$LEX,;t t
14795 < s,@LEXLIB@,$LEXLIB,;t t
14796 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14793 > s,@PERLINTERP@,$PERLINTERP,;t t
14794 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14795 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14796 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14797 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14798   s,@AR@,$AR,;t t
14799 + s,@PS@,$PS,;t t
14800 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14801 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14802 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14803 + s,@FCLIBS@,$FCLIBS,;t t
14804 + s,@FC_FUNC@,$FC_FUNC,;t t
14805 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14806 + s,@MOD@,$MOD,;t t
14807 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14808 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14809 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14810 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14811 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14812 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14813 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14814 + s,@LIBOBJS@,$LIBOBJS,;t t
14815 + s,@POW_LIB@,$POW_LIB,;t t
14816 + s,@CXXCPP@,$CXXCPP,;t t
14817 + s,@__func__@,$__func__,;t t
14818   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14819   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14820   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14821   s,@MPI_LIB@,$MPI_LIB,;t t
14822   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14823   s,@USE_MPI@,$USE_MPI,;t t
14824 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
14825 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
14826 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
14827 < s,@USE_SPRNG@,$USE_SPRNG,;t t
14828 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
14829 < s,@MKL_LIB@,$MKL_LIB,;t t
14830 < s,@MKL_INC@,$MKL_INC,;t t
14831 < s,@HAVE_MKL@,$HAVE_MKL,;t t
14824 > s,@USE_CGAL@,$USE_CGAL,;t t
14825 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14826 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
14827 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
14828 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
14829 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
14830 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14831 > s,@DOXYGEN@,$DOXYGEN,;t t
14832 > s,@DOT@,$DOT,;t t
14833 > s,@DOC@,$DOC,;t t
14834 > s,@enable_dot@,$enable_dot,;t t
14835 > s,@enable_html_docs@,$enable_html_docs,;t t
14836 > s,@enable_latex_docs@,$enable_latex_docs,;t t
14837   s,@BATEXT@,$BATEXT,;t t
14838   s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
14839   s,@OOPSE@,$OOPSE,;t t
14840   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14841   s,@SUBDIRS@,$SUBDIRS,;t t
8264 s,@FFLAGS@,$FFLAGS,;t t
14842   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14843   CEOF
14844  
# Line 8499 | Line 15076 | done
15076      rm -f $tmp/out
15077    fi
15078  
15079 +  # Run the commands associated with the file.
15080 +  case $ac_file in
15081 +    make/Makefile ) chmod 0755 scripts/* ;;
15082 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15083 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15084 +    scripts/filepp ) chmod 0755 scripts/* ;;
15085 +  esac
15086   done
15087   _ACEOF
15088   cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines