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 2199 by gezelter, Thu Apr 14 21:41:56 2005 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 F90_MODULE_NAMES CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI CXXCPP USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug 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}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-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)
877  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
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-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  
# Line 997 | 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 1011 | 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 1373 | Line 1378 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1378   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1379  
1380  
1381 < # This file is part of Autoconf.                       -*- Autoconf -*-
1377 < # Programming languages support.
1378 < # Copyright 2000, 2001
1379 < # Free Software Foundation, Inc.
1380 < #
1381 < # This program is free software; you can redistribute it and/or modify
1382 < # it under the terms of the GNU General Public License as published by
1383 < # the Free Software Foundation; either version 2, or (at your option)
1384 < # any later version.
1385 < #
1386 < # This program is distributed in the hope that it will be useful,
1387 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1388 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1389 < # GNU General Public License for more details.
1390 < #
1391 < # You should have received a copy of the GNU General Public License
1392 < # along with this program; if not, write to the Free Software
1393 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1394 < # 02111-1307, USA.
1395 < #
1396 < # As a special exception, the Free Software Foundation gives unlimited
1397 < # permission to copy, distribute and modify the configure scripts that
1398 < # are the output of Autoconf.  You need not follow the terms of the GNU
1399 < # General Public License when using or distributing such scripts, even
1400 < # though portions of the text of Autoconf appear in them.  The GNU
1401 < # General Public License (GPL) does govern all other use of the material
1402 < # that constitutes the Autoconf program.
1403 < #
1404 < # Certain portions of the Autoconf source text are designed to be copied
1405 < # (in certain cases, depending on the input) into the output of
1406 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1407 < # source text consists of comments plus executable code that decides which
1408 < # of the data portions to output in any given case.  We call these
1409 < # comments and executable code the "non-data" portions.  Autoconf never
1410 < # copies any of the non-data portions into its output.
1411 < #
1412 < # This special exception to the GPL applies to versions of Autoconf
1413 < # released by the Free Software Foundation.  When you make and
1414 < # distribute a modified version of Autoconf, you may extend this special
1415 < # exception to the GPL to apply to your modified version as well, *unless*
1416 < # your modified version has the potential to copy into its output some
1417 < # of the text that was the non-data portion of the version that you started
1418 < # with.  (In other words, unless your change moves or copies text from
1419 < # the non-data portions to the data portions.)  If your modification has
1420 < # such potential, you must delete any notice of this special exception
1421 < # to the GPL from your modified version.
1422 < #
1423 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1424 < # many others).
1381 >          ac_config_headers="$ac_config_headers src/config.h"
1382  
1383  
1427 # Table of Contents:
1428 #
1429 # 1. Language selection
1430 #    and routines to produce programs in a given language.
1431 #  a. Fortran 77 (to be moved from aclang.m4)
1432 #  b. Fortran 90
1433 #  c. Fortran 95
1434 #
1435 # 2. Producing programs in a given language.
1436 #  a. Fortran 77 (to be moved from aclang.m4)
1437 #  b. Fortran 90
1438 #  c. Fortran 95
1439 #
1440 # 3. Looking for a compiler
1441 #    And possibly the associated preprocessor.
1442 #  a. Fortran 77 (to be moved from aclang.m4)
1443 #  b. Fortran 90
1444 #  c. Fortran 95
1445 #
1446 # 4. Compilers' characteristics.
1447 #  a. Fortran 77 (to be moved from aclang.m4)
1448 #  b. Fortran 90
1449 #  c. Fortran 95
1384  
1451 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1452 # ---------------------------------------------------------------------------
1453 #
1454 # Processing the elements of a list is tedious in shell programming,
1455 # as lists tend to be implemented as space delimited strings.
1456 #
1457 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1458 # if ELEMENT is a member of LIST, otherwise it executes
1459 # ACTION-IF-NOT-FOUND.
1460 # _AC_LIST_MEMBER_IF
1385  
1386  
1387  
1464 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1465 # -------------------------------------------------
1466 #
1467 # Specifying options to the compiler (whether it be the C, C++ or
1468 # Fortran 77 compiler) that are meant for the linker is compiler
1469 # dependent.  This macro lets you give options to the compiler that
1470 # are meant for the linker in a portable, compiler-independent way.
1471 #
1472 # This macro take two arguments, a list of linker options that the
1473 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1474 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1475 # appended to the shell variable in a compiler-dependent way.
1476 #
1477 # For example, if the selected language is C, then this:
1478 #
1479 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1480 #
1481 # will expand into this if the selected C compiler is gcc:
1482 #
1483 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1484 #
1485 # otherwise, it will expand into this:
1486 #
1487 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1488 #
1489 # You are encouraged to add support for compilers that this macro
1490 # doesn't currently support.
1491 # FIXME: Get rid of this macro.
1492 # _AC_LINKER_OPTION
1388  
1389  
1390  
1496 ## ----------------------- ##
1497 ## 1. Language selection.  ##
1498 ## ----------------------- ##
1391  
1500 # ----------------------------- #
1501 # 1b. The Fortran 90 language.  #
1502 # ----------------------------- #
1392  
1504 # AC_LANG(Fortran 90)
1505 # -------------------
1393  
1394  
1395  
1509 # _AC_LANG_ABBREV(Fortran 90)
1510 # ---------------------------
1396  
1397  
1398  
1514 # ----------------------------- #
1515 # 1c. The Fortran 95 language.  #
1516 # ----------------------------- #
1399  
1518 # AC_LANG(Fortran 95)
1519 # -------------------
1400  
1401  
1402  
1523 # _AC_LANG_ABBREV(Fortran 95)
1524 # ---------------------------
1403  
1404  
1405  
1528 ## ---------------------- ##
1529 ## 2.Producing programs.  ##
1530 ## ---------------------- ##
1406  
1532 # ------------------------ #
1533 # 2b. Fortran 90 sources.  #
1534 # ------------------------ #
1407  
1536 # AC_LANG_SOURCE(Fortran 90)(BODY)
1537 # --------------------------------
1408  
1409  
1410  
1541 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1542 # -----------------------------------------------
1411  
1412  
1545 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1546 # --------------------------------------------
1413  
1414  
1415  
1550 # ------------------------ #
1551 # 2c. Fortran 95 sources.  #
1552 # ------------------------ #
1416  
1554 # AC_LANG_SOURCE(Fortran 95)(BODY)
1555 # --------------------------------
1417  
1418  
1558 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1559 # -----------------------------------------------
1419  
1420  
1562 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1563 # --------------------------------------------
1421  
1422  
1423  
1567 ## -------------------------------------------- ##
1568 ## 3. Looking for Compilers and Preprocessors.  ##
1569 ## -------------------------------------------- ##
1424  
1571 # ----------------------------- #
1572 # 3b. The Fortran 90 compiler.  #
1573 # ----------------------------- #
1425  
1575
1576 # AC_LANG_PREPROC(Fortran 90)
1577 # ---------------------------
1578 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1579
1580
1581
1582 # AC_LANG_COMPILER(Fortran 90)
1583 # ----------------------------
1584 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1585 # AC_REQUIRE'able.
1586
1587
1588
1589 # AC_PROG_F90([COMPILERS...])
1590 # ---------------------------
1591 # COMPILERS is a space separated list of Fortran 90 compilers to search
1592 # for.
1593 #
1594 # Compilers are ordered by
1595 #  1. F90, F95
1596 #  2. Good/tested native compilers, bad/untested native compilers
1426   #
1598 # pgf90 is the Portland Group F90 compilers.
1599 # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1600 # lf95 is the Lahey-Fujitsu compiler.
1601 # epcf90 is the "Edinburgh Portable Compiler" F90.
1602 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1603 # AC_PROG_F90
1604
1605
1606 # ----------------------------- #
1607 # 3c. The Fortran 95 compiler.  #
1608 # ----------------------------- #
1609
1610
1611 # AC_LANG_PREPROC(Fortran 95)
1612 # ---------------------------
1613 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1614
1615
1616
1617 # AC_LANG_COMPILER(Fortran 95)
1618 # ----------------------------
1619 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1620 # AC_REQUIRE'able.
1621
1622
1623
1624 # AC_PROG_F95([COMPILERS...])
1625 # ---------------------------
1626 # COMPILERS is a space separated list of Fortran 95 compilers to search
1627 # for.
1427   #
1629 # Compilers are ordered by
1630 #  1. Good/tested native compilers, bad/untested native compilers
1428   #
1632 # xlf95 is the IBM (AIX) F95 compiler.
1633 # lf95 is the Lahey-Fujitsu compiler.
1634 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1635 # AC_PROG_F95
1429  
1430  
1638 ## ------------------------------- ##
1639 ## 4. Compilers' characteristics.  ##
1640 ## ------------------------------- ##
1431  
1432  
1643 # ---------------------------------------- #
1644 # 4b. Fortan 90 compiler characteristics.  #
1645 # ---------------------------------------- #
1433  
1434 <
1435 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1649 < # -------------------------------------------------
1650 < # Link a trivial Fortran program, compiling with a verbose output FLAG
1651 < # (which default value, $ac_cv_prog_f90_v, is computed by
1652 < # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1653 < # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1654 < # so that any link flags that are echoed by the compiler appear as
1655 < # space-separated items.
1656 < # _AC_PROG_F90_V_OUTPUT
1657 <
1658 <
1659 < # _AC_PROG_F90_V
1660 < # --------------
1434 > # AC_F90_MODULE_NAMES
1435 > # -------------------
1436   #
1437 < # Determine the flag that causes the Fortran 90 compiler to print
1663 < # information of library and object files (normally -v)
1664 < # Needed for AC_F90_LIBRARY_FLAGS
1665 < # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1666 < # _AC_PROG_F90_V
1667 <
1668 <
1669 < # AC_F90_LIBRARY_LDFLAGS
1670 < # ----------------------
1437 > # Figure out how the Fortran 90 compiler constructs module file names
1438   #
1439 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1673 < # intrinsic and run-time libraries that are required to successfully
1674 < # link a Fortran 90 program or shared library.  The output variable
1675 < # F90LIBS is set to these flags.
1676 < #
1677 < # This macro is intended to be used in those situations when it is
1678 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1679 < # program or shared library.
1680 < #
1681 < # For example, if object files from a C++ and Fortran 90 compiler must
1682 < # be linked together, then the C++ compiler/linker must be used for
1683 < # linking (since special C++-ish things need to happen at link time
1684 < # like calling global constructors, instantiating templates, enabling
1685 < # exception support, etc.).
1686 < #
1687 < # However, the Fortran 90 intrinsic and run-time libraries must be
1688 < # linked in as well, but the C++ compiler/linker doesn't know how to
1689 < # add these Fortran 90 libraries.  Hence, the macro
1690 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1691 < # libraries.
1692 < #
1693 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1694 < # AC_F90_LIBRARY_LDFLAGS
1439 > # AC_F90_MODULE_NAMES
1440  
1441  
1697 # _AC_F90_NAME_MANGLING
1698 # ---------------------
1699 # Test for the name mangling scheme used by the Fortran 90 compiler.
1700 #
1701 # Sets ac_cv_f90_mangling. The value contains three fields, separated
1702 # by commas:
1703 #
1704 # lower case / upper case:
1705 #    case translation of the Fortan 90 symbols
1706 # underscore / no underscore:
1707 #    whether the compiler appends "_" to symbol names
1708 # extra underscore / no extra underscore:
1709 #    whether the compiler appends an extra "_" to symbol names already
1710 #    containing at least one underscore
1711 #
1712 # _AC_F90_NAME_MANGLING
1442  
1714 # The replacement is empty.
1443  
1444  
1445  
1718 # AC_F90_WRAPPERS
1719 # ---------------
1720 # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1721 # properly mangle the names of C identifiers, and C identifiers with
1722 # underscores, respectively, so that they match the name mangling
1723 # scheme used by the Fortran 90 compiler.
1724 # AC_F90_WRAPPERS
1446  
1726
1727 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1728 # ------------------------------------
1729 # For a Fortran subroutine of given NAME, define a shell variable
1730 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1731 # argument is not supplied, it defaults to NAME.
1732 # AC_F90_FUNC
1733
1734
1735 # ---------------------------------------- #
1736 # 4c. Fortan 95 compiler characteristics.  #
1737 # ---------------------------------------- #
1447  
1448  
1740 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1741 # -------------------------------------------------
1742 # Link a trivial Fortran program, compiling with a verbose output FLAG
1743 # (which default value, $ac_cv_prog_f95_v, is computed by
1744 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1745 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1746 # so that any link flags that are echoed by the compiler appear as
1747 # space-separated items.
1748 # _AC_PROG_F95_V_OUTPUT
1449  
1450  
1751 # _AC_PROG_F95_V
1752 # --------------
1753 #
1754 # Determine the flag that causes the Fortran 95 compiler to print
1755 # information of library and object files (normally -v)
1756 # Needed for AC_F95_LIBRARY_FLAGS
1757 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1758 # _AC_PROG_F95_V
1451  
1452  
1761 # AC_F95_LIBRARY_LDFLAGS
1762 # ----------------------
1763 #
1764 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1765 # intrinsic and run-time libraries that are required to successfully
1766 # link a Fortran 95 program or shared library.  The output variable
1767 # F95LIBS is set to these flags.
1768 #
1769 # This macro is intended to be used in those situations when it is
1770 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1771 # program or shared library.
1772 #
1773 # For example, if object files from a C++ and Fortran 95 compiler must
1774 # be linked together, then the C++ compiler/linker must be used for
1775 # linking (since special C++-ish things need to happen at link time
1776 # like calling global constructors, instantiating templates, enabling
1777 # exception support, etc.).
1778 #
1779 # However, the Fortran 95 intrinsic and run-time libraries must be
1780 # linked in as well, but the C++ compiler/linker doesn't know how to
1781 # add these Fortran 95 libraries.  Hence, the macro
1782 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1783 # libraries.
1784 #
1785 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1786 # AC_F95_LIBRARY_LDFLAGS
1453  
1454  
1789 # _AC_F95_NAME_MANGLING
1790 # ---------------------
1791 # Test for the name mangling scheme used by the Fortran 95 compiler.
1792 #
1793 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1794 # by commas:
1795 #
1796 # lower case / upper case:
1797 #    case translation of the Fortan 95 symbols
1798 # underscore / no underscore:
1799 #    whether the compiler appends "_" to symbol names
1800 # extra underscore / no extra underscore:
1801 #    whether the compiler appends an extra "_" to symbol names already
1802 #    containing at least one underscore
1803 #
1804 # _AC_F95_NAME_MANGLING
1455  
1806 # The replacement is empty.
1456  
1457  
1458  
1810 # AC_F95_WRAPPERS
1811 # ---------------
1812 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1813 # properly mangle the names of C identifiers, and C identifiers with
1814 # underscores, respectively, so that they match the name mangling
1815 # scheme used by the Fortran 95 compiler.
1816 # AC_F95_WRAPPERS
1459  
1460  
1819 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1820 # ------------------------------------
1821 # For a Fortran subroutine of given NAME, define a shell variable
1822 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1823 # argument is not supplied, it defaults to NAME.
1824 # AC_F95_FUNC
1461  
1826 # AC_F90_MODULE_NAMES
1827 # -------------------
1828 #
1829 # Figure out how the Fortran 90 compiler constructs module file names
1830 #
1831 # AC_F90_MODULE_NAMES
1462  
1463  
1464  
# Line 1882 | Line 1512 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1512  
1513  
1514  
1885 #
1886 #
1887 #
1515  
1516  
1517  
1518  
1519  
1520  
1894 # set program name
1895 PROGNAME="oopse"
1521  
1522  
1898 # there are two ways to do debugging.  One with the --enable-debug flag
1899 # and one using the DEBUG environment variable
1523  
1901 debug=0
1902 # Check whether --enable-debug or --disable-debug was given.
1903 if test "${enable_debug+set}" = set; then
1904  enableval="$enable_debug"
1905  debug=1
1906 fi;
1907 if test "${DEBUG}"; then
1524  
1909 cat >>confdefs.h <<\_ACEOF
1910 #define debug 1
1911 _ACEOF
1525  
1913  msg="$msg, debug mode"
1914 fi
1526  
1527  
1528   # who am i
# Line 1972 | 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 1997 | 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 2006 | 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 2039 | 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 2048 | 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  
2067 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2068 See \`config.log' for more details." >&5
2069 echo "$as_me: error: no acceptable C compiler found in \$PATH
2070 See \`config.log' for more details." >&2;}
2071   { (exit 1); exit 1; }; }
2072
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 2110 | 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 2154 | 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 2167 | 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 2183 | 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 2291 | 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 2685 | 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'
2692 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2693 < 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 2711 | 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 2720 | 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 2753 | 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 2762 | 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
2776 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 2798 | 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.  */
2809 < _ACEOF
2810 < cat confdefs.h >>conftest.$ac_ext
2811 < cat >>conftest.$ac_ext <<_ACEOF
2812 < /* end confdefs.h.  */
2813 <
2814 < int
2815 < main ()
2816 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2822 <  return 0;
2823 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2831 | 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 2852 | 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
2872 < cat confdefs.h >>conftest.$ac_ext
2873 < cat >>conftest.$ac_ext <<_ACEOF
2874 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2877 < main ()
2878 < {
2879 <
2880 <  ;
2881 <  return 0;
2882 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2890 | 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 2903 | 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);
2952 <  ;
2953 <  return 0;
2954 < }
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
2958 <  (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
2975 <  ac_status=$?
2976 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2977 <  (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
2993 < int
2994 < main ()
2995 < {
2996 < exit (42);
2997 <  ;
2998 <  return 0;
2999 < }
3007 > #include <ac_nonexistent.h>
3008   _ACEOF
3009 < rm -f conftest.$ac_objext
3010 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3003 <  (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 3041 | 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
3051 <    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
3072 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3073 <  echo 'void f(){}' > conftest.cc
3074 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3075 <    echo "$as_me:$LINENO: result: yes" >&5
3076 < echo "${ECHO_T}yes" >&6
3077 <    OOPSE_TEMPLATE_FLAGS="-pto"
3078 <  else
3079 <    echo "$as_me:$LINENO: result: no" >&5
3080 < echo "${ECHO_T}no" >&6
3081 <  fi
3082 <  rm -f conftest*
3083 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3084 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3085 <  echo 'void f(){}' > conftest.cc
3086 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3087 <    echo "$as_me:$LINENO: result: yes" >&5
3088 < echo "${ECHO_T}yes" >&6
3242 > done
3243 > done
3244  
3245 <
3246 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3247 <  else
3248 <    echo "$as_me:$LINENO: result: no" >&5
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
3095  fi
3254   fi
3255  
3256 <
3257 <
3258 <
3259 < ac_ext=f90
3260 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3103 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3104 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3105 < if test -n "$ac_tool_prefix"; then
3106 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3107 <  do
3108 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3109 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
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_F90+set}" = set; then
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 "$F90"; then
3267 <  ac_cv_prog_F90="$F90" # Let the user override the test.
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
# Line 3122 | Line 3273 | do
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_F90="$ac_tool_prefix$ac_prog"
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   done
3281   done
3282  
3283 +  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284   fi
3285   fi
3286 < F90=$ac_cv_prog_F90
3287 < if test -n "$F90"; then
3288 <  echo "$as_me:$LINENO: result: $F90" >&5
3289 < echo "${ECHO_T}$F90" >&6
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 <    test -n "$F90" && break
3296 <  done
3295 >  RANLIB=$ac_ct_RANLIB
3296 > else
3297 >  RANLIB="$ac_cv_prog_RANLIB"
3298   fi
3299 < if test -z "$F90"; then
3300 <  ac_ct_F90=$F90
3301 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
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 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3317 < set dummy $ac_prog; ac_word=$2
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 > 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_ac_ct_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 "$ac_ct_F90"; then
3511 <  ac_cv_prog_ac_ct_F90="$ac_ct_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 3164 | 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_ac_ct_F90="$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 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3531 < if test -n "$ac_ct_F90"; then
3532 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3533 < echo "${ECHO_T}$ac_ct_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 "$ac_ct_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 <  F90=$ac_ct_F90
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 + 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_path_PS+set}" = set; then
3601 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3602 + else
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_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 + PS=$ac_cv_path_PS
3626  
3627 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3628 < # input file.
3629 < ac_save_ext=$ac_ext
3630 < ac_ext=F90
3631 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3632 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3633 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
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 > 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
3201  cat >conftest.$ac_ext <<_ACEOF
3640  
3641 < program main
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 < #ifndef __GNUC__
3664 <       choke me
3665 < #endif
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 < end program main
3667 > cat >>confdefs.h <<_ACEOF
3668 > #define PSCOMMAND $PS
3669 > _ACEOF
3670  
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 +   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679 +
3680 + cat >>confdefs.h <<\_ACEOF
3681 + #define PSTYPE_IS_POSIX 1
3682 + _ACEOF
3683 +
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 + 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
3715    (eval $ac_compile) 2>conftest.er1
# Line 3218 | 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 3231 | 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  
3239 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 3263 | 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 3285 | 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
3305 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3309
3310 end program main
3311
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3319 | 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 3341 | 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'
3350 < 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 3374 | 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 3396 | 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
3416 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3424
3425 end program main
3426
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3434 | 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 3456 | 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'
3465 < 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  
3468
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3479 | 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 <
3489 < ac_ext=f90
3490 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3491 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3492 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3493 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3494 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3495 < 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
3500 <
3501 < program main
3502 <
3503 <
3504 < end program main
3505 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3513 | 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 3526 | 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'
3534 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3535 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3538 <
3539 < program main
3540 <
3541 <
3542 < end program main
3543 <
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:3553: \"$ac_link\") >&5
3554 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3555 < echo "$ac_f90_v_output" >&5
3556 < 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 3595 | 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
3608
3609 ac_ext=f90
3610 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3611 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3612 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4101  
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3617 <
3618 <
3619 < end program main
3620 <
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:3630: \"$ac_link\") >&5
3631 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3632 < echo "$ac_f90_v_output" >&5
3633 < 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
3650 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3651 < 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 3672 | 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 3690 | 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"
3715
4209                  shift; shift
4210                  set X $ac_arg "$@"
4211                  ;;
# Line 3721 | 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 3732 | 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 3749 | 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 3764 | 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 &&
3770
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  
3787 ac_ext=f90
3788 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3789 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3790 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 3816 | 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 3829 | 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
3839
3840  ac_save_LIBS=$LIBS
3841  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3842
4508    ac_success=no
4509    for ac_foobar in foobar FOOBAR; do
4510      for ac_underscore in "" "_"; do
# Line 3858 | 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 3898 | 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 <
3918 <        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 3929 | 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 3968 | 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
3975 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
3976 <        else
3977 <           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"
3990 <
4681 >     ac_cv_fc_mangling="unknown"
4682    fi
4683  
4684    LIBS=$ac_save_LIBS
4685 <  ac_ext=f90
3995 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3996 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3997 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3998 <  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
4005 ac_ext=f90
4006 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4007 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4008 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 +
5101   echo "$as_me:$LINENO: checking for module suffix" >&5
5102   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
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 4110 | 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 4155 | 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 4163 | 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 4173 | 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 4181 | 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 4200 | 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 4230 | Line 5232 | else
5232   if test "${ac_cv_f90_module_names+set}" = set; then
5233    echo $ECHO_N "(cached) $ECHO_C" >&6
5234   else
5235 <  ac_ext=f90
5236 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5237 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5238 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
# Line 4251 | Line 5253 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5253    cat conftest.err >&5
5254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5255    (exit $ac_status); } &&
5256 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 4367 | Line 5369 | ac_ext=f90
5369   cd ..
5370   # cleanup
5371   rm -rf conftest
5372 < ac_ext=f90
5373 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5374 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5375 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
# Line 4465 | Line 5467 | ac_ext=c
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 < ac_ext=c
5471 < ac_cpp='$CPP $CPPFLAGS'
5472 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5473 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5474 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4473 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4474 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4475 < # On Suns, sometimes $CPP names a directory.
4476 < if test -n "$CPP" && test -d "$CPP"; then
4477 <  CPP=
4478 < fi
4479 < if test -z "$CPP"; then
4480 <  if test "${ac_cv_prog_CPP+set}" = set; then
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 <      # Double quotes because CPP needs to be expanded
5478 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5479 <    do
4486 <      ac_preproc_ok=false
4487 < for ac_c_preproc_warn_flag in '' yes
4488 < do
4489 <  # Use a header file that comes with gcc, so configuring glibc
4490 <  # with a fresh cross-compiler works.
4491 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4492 <  # <limits.h> exists even on freestanding compilers.
4493 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4494 <  # not just through cpp. "Syntax error" is here to catch this case.
4495 <  cat >conftest.$ac_ext <<_ACEOF
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 < #ifdef __STDC__
5486 < # include <limits.h>
5487 < #else
5488 < # include <assert.h>
5485 >
5486 > /* Override any gcc2 internal prototype to avoid an error.  */
5487 > #ifdef __cplusplus
5488 > extern "C"
5489   #endif
5490 <                     Syntax error
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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5510 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
5518 <  if test -s conftest.err; then
5519 <    ac_cpp_err=$ac_c_preproc_warn_flag
5520 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5521 <  else
5522 <    ac_cpp_err=
5523 <  fi
5524 < else
5525 <  ac_cpp_err=yes
5526 < fi
5527 < if test -z "$ac_cpp_err"; then
5528 <  :
5529 < else
5530 <  echo "$as_me: failed program was:" >&5
5531 < sed 's/^/| /' conftest.$ac_ext >&5
5532 <
5533 <  # Broken: fails on valid input.
5534 < continue
5535 < fi
5536 < rm -f conftest.err conftest.$ac_ext
5537 <
5538 <  # OK, works on sane cases.  Now check whether non-existent headers
5539 <  # can be detected and how.
5540 <  cat >conftest.$ac_ext <<_ACEOF
5541 < /* confdefs.h.  */
5542 < _ACEOF
5543 < cat confdefs.h >>conftest.$ac_ext
5544 < cat >>conftest.$ac_ext <<_ACEOF
5545 < /* end confdefs.h.  */
5546 < #include <ac_nonexistent.h>
5547 < _ACEOF
5548 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5549 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5550 <  ac_status=$?
5551 <  grep -v '^ *+' conftest.er1 >conftest.err
5552 <  rm -f conftest.er1
5553 <  cat conftest.err >&5
5554 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5555 <  (exit $ac_status); } >/dev/null; then
5556 <  if test -s conftest.err; then
5557 <    ac_cpp_err=$ac_c_preproc_warn_flag
5558 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5559 <  else
5560 <    ac_cpp_err=
5561 <  fi
5562 < else
5563 <  ac_cpp_err=yes
5564 < fi
5565 < if test -z "$ac_cpp_err"; then
5566 <  # Broken: success on invalid input.
5567 < continue
5568 < else
5569 <  echo "$as_me: failed program was:" >&5
5570 < sed 's/^/| /' conftest.$ac_ext >&5
5571 <
5572 <  # Passes both tests.
5573 < ac_preproc_ok=:
5574 < break
5575 < fi
5576 < rm -f conftest.err conftest.$ac_ext
5577 <
5578 < done
5579 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5580 < rm -f conftest.err conftest.$ac_ext
5581 < if $ac_preproc_ok; then
5582 <  break
5583 < fi
5584 <
5585 <    done
5586 <    ac_cv_prog_CPP=$CPP
5587 <
5588 < fi
5589 <  CPP=$ac_cv_prog_CPP
5590 < else
5591 <  ac_cv_prog_CPP=$CPP
5592 < fi
5593 < echo "$as_me:$LINENO: result: $CPP" >&5
5594 < echo "${ECHO_T}$CPP" >&6
5595 < ac_preproc_ok=false
5596 < for ac_c_preproc_warn_flag in '' yes
5597 < do
5598 <  # Use a header file that comes with gcc, so configuring glibc
5599 <  # with a fresh cross-compiler works.
5600 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5601 <  # <limits.h> exists even on freestanding compilers.
5602 <  # On the NeXT, cc -E runs the code through the compiler's parser,
5603 <  # not just through cpp. "Syntax error" is here to catch this case.
5604 <  cat >conftest.$ac_ext <<_ACEOF
5605 < /* confdefs.h.  */
5606 < _ACEOF
5607 < cat confdefs.h >>conftest.$ac_ext
5608 < cat >>conftest.$ac_ext <<_ACEOF
5609 < /* end confdefs.h.  */
5610 < #ifdef __STDC__
5611 < # include <limits.h>
5612 < #else
5613 < # include <assert.h>
5614 < #endif
5615 <                     Syntax error
5616 < _ACEOF
5617 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5618 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5619 <  ac_status=$?
5620 <  grep -v '^ *+' conftest.er1 >conftest.err
5621 <  rm -f conftest.er1
5622 <  cat conftest.err >&5
5623 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5624 <  (exit $ac_status); } >/dev/null; then
5625 <  if test -s conftest.err; then
5626 <    ac_cpp_err=$ac_c_preproc_warn_flag
5627 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5628 <  else
5629 <    ac_cpp_err=
5630 <  fi
5631 < else
5632 <  ac_cpp_err=yes
5633 < fi
5634 < if test -z "$ac_cpp_err"; then
5635 <  :
5636 < else
5637 <  echo "$as_me: failed program was:" >&5
5638 < sed 's/^/| /' conftest.$ac_ext >&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 <  # Broken: fails on valid input.
10612 < continue
10613 < fi
10614 < rm -f conftest.err conftest.$ac_ext
4642 <
4643 <  # OK, works on sane cases.  Now check whether non-existent headers
4644 <  # can be detected and how.
4645 <  cat >conftest.$ac_ext <<_ACEOF
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_nonexistent.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
# Line 4659 | Line 10628 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
10632 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 4668 | Line 10637 | if test -z "$ac_cpp_err"; then
10637    ac_cpp_err=yes
10638   fi
10639   if test -z "$ac_cpp_err"; then
10640 <  # Broken: success on invalid input.
4672 < continue
10640 >  ac_header_preproc=yes
10641   else
10642    echo "$as_me: failed program was:" >&5
10643   sed 's/^/| /' conftest.$ac_ext >&5
10644  
10645 <  # Passes both tests.
4678 < ac_preproc_ok=:
4679 < break
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 < done
10652 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10653 < rm -f conftest.err conftest.$ac_ext
10654 < if $ac_preproc_ok; then
10655 <  :
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 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4690 < See \`config.log' for more details." >&5
4691 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4692 < See \`config.log' for more details." >&2;}
4693 <   { (exit 1); exit 1; }; }
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 < ac_ext=c
10694 < ac_cpp='$CPP $CPPFLAGS'
10695 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10696 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10697 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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 < echo "$as_me:$LINENO: checking for egrep" >&5
10702 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
10703 < if test "${ac_cv_prog_egrep+set}" = set; then
4706 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4707 < else
4708 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4709 <    then ac_cv_prog_egrep='grep -E'
4710 <    else ac_cv_prog_egrep='egrep'
4711 <    fi
10701 > done
10702 >
10703 >
10704   fi
4713 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4714 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4715 EGREP=$ac_cv_prog_egrep
10705  
10706  
10707 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10708 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10709 < if test "${ac_cv_header_stdc+set}" = set; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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 < #include <stdlib.h>
10728 < #include <stdarg.h>
4731 < #include <string.h>
4732 < #include <float.h>
4733 <
4734 < int
4735 < main ()
4736 < {
4737 <
4738 <  ;
4739 <  return 0;
4740 < }
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
# Line 4748 | Line 10736 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10736    cat conftest.err >&5
10737    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10738    (exit $ac_status); } &&
10739 <         { ac_try='test -z "$ac_c_werror_flag"
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
# Line 4761 | Line 10749 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10749    ac_status=$?
10750    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10751    (exit $ac_status); }; }; then
10752 <  ac_cv_header_stdc=yes
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_cv_header_stdc=no
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 < if test $ac_cv_header_stdc = yes; then
10764 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
10765 <  cat >conftest.$ac_ext <<_ACEOF
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 <string.h>
4782 <
10772 > #include <iomanip>
10773   _ACEOF
10774 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10775 <  $EGREP "memchr" >/dev/null 2>&1; then
10776 <  :
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_cv_header_stdc=no
10789 >  ac_cpp_err=yes
10790   fi
10791 < rm -f conftest*
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 < if test $ac_cv_header_stdc = yes; then
10804 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
10805 <  cat >conftest.$ac_ext <<_ACEOF
10806 < /* confdefs.h.  */
10807 < _ACEOF
10808 < cat confdefs.h >>conftest.$ac_ext
10809 < cat >>conftest.$ac_ext <<_ACEOF
10810 < /* end confdefs.h.  */
10811 < #include <stdlib.h>
10812 <
10813 < _ACEOF
10814 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10815 <  $EGREP "free" >/dev/null 2>&1; then
10816 <  :
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_stdc=no
10840 >  ac_cv_header_iomanip=$ac_header_preproc
10841   fi
10842 < rm -f conftest*
10842 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10843 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10844  
10845   fi
10846 <
4815 < if test $ac_cv_header_stdc = yes; then
4816 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4817 <  if test "$cross_compiling" = yes; then
4818 <  :
4819 < else
4820 <  cat >conftest.$ac_ext <<_ACEOF
4821 < /* confdefs.h.  */
4822 < _ACEOF
4823 < cat confdefs.h >>conftest.$ac_ext
4824 < cat >>conftest.$ac_ext <<_ACEOF
4825 < /* end confdefs.h.  */
4826 < #include <ctype.h>
4827 < #if ((' ' & 0x0FF) == 0x020)
4828 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4829 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4830 < #else
4831 < # define ISLOWER(c) \
4832 <                   (('a' <= (c) && (c) <= 'i') \
4833 <                     || ('j' <= (c) && (c) <= 'r') \
4834 <                     || ('s' <= (c) && (c) <= 'z'))
4835 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4836 < #endif
10846 > if test $ac_cv_header_iomanip = yes; then
10847  
4838 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4839 int
4840 main ()
4841 {
4842  int i;
4843  for (i = 0; i < 256; i++)
4844    if (XOR (islower (i), ISLOWER (i))
4845        || toupper (i) != TOUPPER (i))
4846      exit(2);
4847  exit (0);
4848 }
4849 _ACEOF
4850 rm -f conftest$ac_exeext
4851 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4852  (eval $ac_link) 2>&5
4853  ac_status=$?
4854  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4855  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4856  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4857  (eval $ac_try) 2>&5
4858  ac_status=$?
4859  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4860  (exit $ac_status); }; }; then
4861  :
4862 else
4863  echo "$as_me: program exited with status $ac_status" >&5
4864 echo "$as_me: failed program was:" >&5
4865 sed 's/^/| /' conftest.$ac_ext >&5
10848  
4867 ( exit $ac_status )
4868 ac_cv_header_stdc=no
4869 fi
4870 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4871 fi
4872 fi
4873 fi
4874 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4875 echo "${ECHO_T}$ac_cv_header_stdc" >&6
4876 if test $ac_cv_header_stdc = yes; then
4877
10849   cat >>confdefs.h <<\_ACEOF
10850 < #define STDC_HEADERS 1
10850 > #define HAVE_IOMANIP 1
10851   _ACEOF
10852  
4882 fi
10853  
10854 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
10854 > else
10855  
10856  
10857 <
4888 <
4889 <
4890 <
4891 <
4892 <
4893 <
4894 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4895 <                  inttypes.h stdint.h unistd.h
10857 > for ac_header in iomanip.h
10858   do
10859   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10860 < echo "$as_me:$LINENO: checking for $ac_header" >&5
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 <  cat >conftest.$ac_ext <<_ACEOF
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
4910
10879   #include <$ac_header>
10880   _ACEOF
10881   rm -f conftest.$ac_objext
# Line 4919 | Line 10887 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10887    cat conftest.err >&5
10888    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10889    (exit $ac_status); } &&
10890 <         { ac_try='test -z "$ac_c_werror_flag"
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
# Line 4932 | Line 10900 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10900    ac_status=$?
10901    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10902    (exit $ac_status); }; }; then
10903 <  eval "$as_ac_Header=yes"
10903 >  ac_header_compiler=yes
10904   else
10905    echo "$as_me: failed program was:" >&5
10906   sed 's/^/| /' conftest.$ac_ext >&5
10907  
10908 < eval "$as_ac_Header=no"
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
# Line 4953 | Line 11004 | done
11004   done
11005  
11006  
11007 + fi
11008  
11009  
11010  
11011  
11012 <
4961 <
4962 <
4963 <
4964 <
4965 < for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
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
# Line 4995 | Line 11042 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11042    cat conftest.err >&5
11043    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11044    (exit $ac_status); } &&
11045 <         { ac_try='test -z "$ac_c_werror_flag"
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
# Line 5039 | Line 11086 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
11090 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 5060 | Line 11107 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11107   echo "${ECHO_T}$ac_header_preproc" >&6
11108  
11109   # So?  What about this header?
11110 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
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;}
# Line 5114 | Line 11161 | done
11161  
11162  
11163  
11164 <
11165 <
11166 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
5120 < do
5121 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5122 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5123 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5124 < if eval "test \"\${$as_ac_var+set}\" = set"; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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.  */
5133 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5134   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5135 #define $ac_func innocuous_$ac_func
11187  
11188 < /* System header to define __stub macros and hopefully few prototypes,
11189 <    which can conflict with char $ac_func (); below.
5139 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5140 <    <limits.h> exists even on freestanding compilers.  */
5141 <
5142 < #ifdef __STDC__
5143 < # include <limits.h>
11188 > #ifdef HAVE_IOSTREAM
11189 > #include <iostream>
11190   #else
11191 < # include <assert.h>
11191 > #include <iostream.h>
11192   #endif
11193  
11194 < #undef $ac_func
11195 <
11196 < /* Override any gcc2 internal prototype to avoid an error.  */
11197 < #ifdef __cplusplus
11198 < extern "C"
11199 < {
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
5155 /* We use char because int might match the return type of a gcc2
5156   builtin and then its argument prototype would still apply.  */
5157 char $ac_func ();
5158 /* The GNU C library defines this for functions which it implements
5159    to always fail with ENOSYS.  Some functions are actually named
5160    something starting with __ and the normal name is an alias.  */
5161 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5162 choke me
5163 #else
5164 char (*f) () = $ac_func;
11201   #endif
11202 < #ifdef __cplusplus
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 < return f != $ac_func;
11264 > std::cout<<"Hello World"<<std::endl;return 0;
11265    ;
11266    return 0;
11267   }
11268   _ACEOF
11269 < rm -f conftest.$ac_objext conftest$ac_exeext
11270 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11271 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"
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_exeext'
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 <  eval "$as_ac_var=yes"
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  
5205 eval "$as_ac_var=no"
11296   fi
11297 < rm -f conftest.err conftest.$ac_objext \
11298 <      conftest$ac_exeext conftest.$ac_ext
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: `eval echo '${'$as_ac_var'}'`" >&5
11308 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11309 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11310 <  cat >>confdefs.h <<_ACEOF
11311 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
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 < done
11315 >  fi
11316 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11317  
11318 < # special check for _system_configuration because AIX <4.3.2 do not
11319 < # contain the `physmem' member.
11320 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11321 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
11322 < cat >conftest.$ac_ext <<_ACEOF
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 <sys/systemcfg.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 < double x = _system_configuration.physmem;
11362 > std::list<int> foo;return 0;
11363    ;
11364    return 0;
11365   }
# Line 5245 | Line 11373 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11373    cat conftest.err >&5
11374    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11375    (exit $ac_status); } &&
11376 <         { ac_try='test -z "$ac_c_werror_flag"
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
# Line 5258 | Line 11386 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11386    ac_status=$?
11387    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11388    (exit $ac_status); }; }; then
11389 <  echo "$as_me:$LINENO: result: yes" >&5
11390 < echo "${ECHO_T}yes" >&6
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__SYSTEM_CONFIGURATION 1
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  
5272 echo "$as_me:$LINENO: result: no" >&5
5273 echo "${ECHO_T}no" >&6
11491   fi
11492   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11493 <
11494 <  # clean out junk possibly left behind by a previous configuration
11495 <  rm -f src/getopt.h
11496 <  # Check for getopt_long support
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 < for ac_header in getopt.h
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
# Line 5311 | Line 11714 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11714    cat conftest.err >&5
11715    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11716    (exit $ac_status); } &&
11717 <         { ac_try='test -z "$ac_c_werror_flag"
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
# Line 5355 | Line 11758 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
11762 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 5376 | Line 11779 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11779   echo "${ECHO_T}$ac_header_preproc" >&6
11780  
11781   # So?  What about this header?
11782 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
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;}
# Line 5427 | Line 11830 | done
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 < for ac_func in getopt_long
11841 < do
11842 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11843 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5435 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5436 < if eval "test \"\${$as_ac_var+set}\" = set"; then
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
# Line 5442 | Line 11849 | cat >>conftest.$ac_ext <<_ACEOF
11849   cat confdefs.h >>conftest.$ac_ext
11850   cat >>conftest.$ac_ext <<_ACEOF
11851   /* end confdefs.h.  */
5445 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5446   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5447 #define $ac_func innocuous_$ac_func
11852  
11853 < /* System header to define __stub macros and hopefully few prototypes,
11854 <    which can conflict with char $ac_func (); below.
11855 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11856 <    <limits.h> exists even on freestanding compilers.  */
11857 <
11858 < #ifdef __STDC__
5455 < # include <limits.h>
5456 < #else
5457 < # include <assert.h>
5458 < #endif
5459 <
5460 < #undef $ac_func
5461 <
5462 < /* Override any gcc2 internal prototype to avoid an error.  */
5463 < #ifdef __cplusplus
5464 < extern "C"
5465 < {
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
5467 /* We use char because int might match the return type of a gcc2
5468   builtin and then its argument prototype would still apply.  */
5469 char $ac_func ();
5470 /* The GNU C library defines this for functions which it implements
5471    to always fail with ENOSYS.  Some functions are actually named
5472    something starting with __ and the normal name is an alias.  */
5473 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5474 choke me
5475 #else
5476 char (*f) () = $ac_func;
11860   #endif
5478 #ifdef __cplusplus
5479 }
5480 #endif
5481
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  
5517 eval "$as_ac_var=no"
5518 fi
5519 rm -f conftest.err conftest.$ac_objext \
5520      conftest$ac_exeext conftest.$ac_ext
5521 fi
5522 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5523 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5524 if test `eval echo '${'$as_ac_var'}'` = yes; then
5525  cat >>confdefs.h <<_ACEOF
5526 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5527 _ACEOF
5528
5529 else
5530  # FreeBSD has a gnugetopt library for this
5531    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5532 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5533 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5534  echo $ECHO_N "(cached) $ECHO_C" >&6
5535 else
5536  ac_check_lib_save_LIBS=$LIBS
5537 LIBS="-lgnugetopt  $LIBS"
11896   cat >conftest.$ac_ext <<_ACEOF
11897   /* confdefs.h.  */
11898   _ACEOF
# Line 5542 | 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
5550 <   builtin and then its argument prototype would still apply.  */
5551 < 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 \
5590 <      conftest$ac_exeext conftest.$ac_ext
5591 < 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
5601 <  # use the GNU replacement
5602 <      case $LIBOBJS in
5603 <    "getopt.$ac_objext"   | \
5604 <  *" getopt.$ac_objext"   | \
5605 <    "getopt.$ac_objext "* | \
5606 <  *" getopt.$ac_objext "* ) ;;
5607 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5608 < esac
11960 > elif test $ac_cv_cpp_func = no; then
11961  
11962 <      case $LIBOBJS in
11963 <    "getopt1.$ac_objext"   | \
11964 <  *" getopt1.$ac_objext"   | \
5613 <    "getopt1.$ac_objext "* | \
5614 <  *" getopt1.$ac_objext "* ) ;;
5615 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5616 < esac
11962 > cat >>confdefs.h <<\_ACEOF
11963 > #define __func__ ""
11964 > _ACEOF
11965  
5618                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5619
11966   fi
11967  
5622 fi
5623 done
11968  
11969  
11970  
11971 +
11972   case $debug in
11973    1)
11974       ;;
11975    *)
11976 +
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 5642 | 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 5680 | 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 5710 | Line 12168 | if test "$ac_test_CFLAGS" != "set"; then
12168     *darwin*)
12169          if test "$CC" = xlc -o "$CC" = cc; then
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 5723 | 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 5750 | 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 5781 | 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 5804 | 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 5833 | 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 5856 | 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 5889 | 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 5947 | 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 5980 | 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 6008 | 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 6053 | 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 6103 | 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 6141 | 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 6162 | Line 12625 | if test "$ac_test_CXXFLAGS" != "set"; then
12625     *darwin*)
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 6175 | 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 6202 | 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 6233 | 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 6256 | 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 6285 | 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 6308 | 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 6341 | 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 6382 | Line 12848 | if { ac_try='${CXX-c++} -E conftest.cpp'
12848   #endif
12849   EOF
12850   if { ac_try='${CXX-c++} -E conftest.cpp'
6385  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6386  (eval $ac_try) 2>&5
6387  ac_status=$?
6388  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6389  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
6390  ac_cv_prog_gxx_2_95=yes
6391 else
6392  ac_cv_prog_gxx_2_95=no
6393 fi
6394
6395 fi
6396 echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
6397 echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
6398 if test "$ac_cv_prog_gxx_2_95" = yes; then
6399        :
6400
6401
6402 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
6403 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
6404 if test "${ac_m_cpu_750+set}" = set; then
6405  echo $ECHO_N "(cached) $ECHO_C" >&6
6406 else
6407  echo 'void f(){}' > conftest.cpp
6408 if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
6409        ac_m_cpu_750=yes
6410 else
6411        ac_m_cpu_750=no
6412 fi
6413 rm -f conftest*
6414
6415 fi
6416 echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
6417 echo "${ECHO_T}$ac_m_cpu_750" >&6
6418 if test "$ac_m_cpu_750" = yes; then
6419        :
6420        CPU_FLAGS=-mcpu=750
6421 else
6422        :
6423
6424 fi
6425
6426 else
6427        :
6428
6429 fi
6430
6431                fi
6432                if test -z "$CPU_FLAGS"; then
6433
6434
6435 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
6436 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
6437 if test "${ac_m_cpu_powerpc+set}" = set; then
6438  echo $ECHO_N "(cached) $ECHO_C" >&6
6439 else
6440  echo 'void f(){}' > conftest.cpp
6441 if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
6442        ac_m_cpu_powerpc=yes
6443 else
6444        ac_m_cpu_powerpc=no
6445 fi
6446 rm -f conftest*
6447
6448 fi
6449 echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
6450 echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
6451 if test "$ac_m_cpu_powerpc" = yes; then
6452        :
6453        CPU_FLAGS=-mcpu=powerpc
6454 else
6455        :
6456
6457 fi
6458
6459                fi
6460                if test -z "$CPU_FLAGS"; then
6461
6462
6463 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
6464 echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
6465 if test "${ac_m_powerpc+set}" = set; then
6466  echo $ECHO_N "(cached) $ECHO_C" >&6
6467 else
6468  echo 'void f(){}' > conftest.cpp
6469 if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
6470        ac_m_powerpc=yes
6471 else
6472        ac_m_powerpc=no
6473 fi
6474 rm -f conftest*
6475
6476 fi
6477 echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
6478 echo "${ECHO_T}$ac_m_powerpc" >&6
6479 if test "$ac_m_powerpc" = yes; then
6480        :
6481        CPU_FLAGS=-mpowerpc
6482 else
6483        :
6484
6485 fi
6486
6487                fi
6488          esac
6489  fi
6490
6491  if test -n "$CPU_FLAGS"; then
6492        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6493  fi
6494
6495  if test -z "$CXXFLAGS"; then
6496        echo ""
6497        echo "**********************************************************"
6498        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6499        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6500        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6501        echo "**********************************************************"
6502        echo ""
6503        CXXFLAGS="-O3"
6504  fi
6505
6506
6507
6508 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6509 echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6510 if test "${ac_guessed_cxxflags+set}" = set; then
6511  echo $ECHO_N "(cached) $ECHO_C" >&6
6512 else
6513  echo 'void f(){}' > conftest.cpp
6514 if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6515        ac_guessed_cxxflags=yes
6516 else
6517        ac_guessed_cxxflags=no
6518 fi
6519 rm -f conftest*
6520
6521 fi
6522 echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6523 echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6524 if test "$ac_guessed_cxxflags" = yes; then
6525        :
6526
6527 else
6528        :
6529
6530        echo ""
6531        echo "**********************************************************"
6532        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6533        echo "* your compiler.                                         *"
6534        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6535        echo "**********************************************************"
6536        echo ""
6537        CXXFLAGS=""
6538
6539 fi
6540
6541
6542 fi
6543
6544
6545
6546
6547
6548 # Try to determine "good" native compiler flags if none specified on command
6549 # line
6550
6551 if test x"$F90FLAGS" = x ; then
6552  F90FLAGS=""
6553  case "${host_cpu}-${host_os}" in
6554
6555  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6556                    F90FLAGS="-O"
6557                fi;;
6558   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6559                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6560                fi;;
6561   powerpc*-aix*)
6562        if test "$F90" = f90 -o "$F90" = xlf90; then
6563                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6564                echo "*******************************************************"
6565                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6566                echo "*  recommended that you use                           *"
6567                echo "*                                                     *"
6568                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6569                echo "*                                 ^^^                 *"
6570                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6571                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6572                echo "*******************************************************"
6573        fi;;
6574   *darwin*)
6575        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6576                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6577        fi;;
6578  esac
6579
6580  if test -n "$CPU_FLAGS"; then
6581        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6582  fi
6583
6584  if test -z "$F90FLAGS"; then
6585        echo ""
6586        echo "**********************************************************"
6587        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6588        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6589        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6590        echo "**********************************************************"
6591        echo ""
6592        F90FLAGS="-O3"
6593  fi
6594
6595
6596 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6597 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6598 if test "${ac_guessed_f90flags+set}" = set; then
6599  echo $ECHO_N "(cached) $ECHO_C" >&6
6600 else
6601
6602
6603
6604 ac_ext=f90
6605 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6606 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6607 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6608
6609 echo 'program main' > conftest.$ac_ext
6610 echo 'end program main' >> conftest.$ac_ext
6611 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6612 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6613  (eval $ac_compile) 2>&5
6614  ac_status=$?
6615  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6616  (exit $ac_status); }; then
6617        ac_guessed_f90flags=yes
6618 else
6619        ac_guessed_f90flags=no
6620 fi
6621 rm -f conftest*
6622 ac_ext=c
6623 ac_cpp='$CPP $CPPFLAGS'
6624 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6625 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6626 ac_compiler_gnu=$ac_cv_c_compiler_gnu
6627
6628
6629 fi
6630 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6631 echo "${ECHO_T}$ac_guessed_f90flags" >&6
6632 if test "$ac_guessed_f90flags" = yes; then
6633        :
6634
6635 else
6636        :
6637
6638        echo ""
6639        echo "**********************************************************"
6640        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6641        echo "* your compiler.                                         *"
6642        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6643        echo "**********************************************************"
6644        echo ""
6645        F90FLAGS=""
6646
6647 fi
6648
6649
6650 fi
6651
6652     ;;
6653 esac
6654
6655 # Find a good install program.  We prefer a C program (faster),
6656 # so one script is as good as another.  But avoid the broken or
6657 # incompatible versions:
6658 # SysV /etc/install, /usr/sbin/install
6659 # SunOS /usr/etc/install
6660 # IRIX /sbin/install
6661 # AIX /bin/install
6662 # AmigaOS /C/install, which installs bootblocks on floppy discs
6663 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6664 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6665 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6666 # OS/2's system install, which has a completely different semantic
6667 # ./install, which can be erroneously created by make from ./install.sh.
6668 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6669 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6670 if test -z "$INSTALL"; then
6671 if test "${ac_cv_path_install+set}" = set; then
6672  echo $ECHO_N "(cached) $ECHO_C" >&6
6673 else
6674  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6675 for as_dir in $PATH
6676 do
6677  IFS=$as_save_IFS
6678  test -z "$as_dir" && as_dir=.
6679  # Account for people who put trailing slashes in PATH elements.
6680 case $as_dir/ in
6681  ./ | .// | /cC/* | \
6682  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6683  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6684  /usr/ucb/* ) ;;
6685  *)
6686    # OSF1 and SCO ODT 3.0 have their own names for install.
6687    # Don't use installbsd from OSF since it installs stuff as root
6688    # by default.
6689    for ac_prog in ginstall scoinst install; do
6690      for ac_exec_ext in '' $ac_executable_extensions; do
6691        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6692          if test $ac_prog = install &&
6693            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6694            # AIX install.  It has an incompatible calling convention.
6695            :
6696          elif test $ac_prog = install &&
6697            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6698            # program-specific install script used by HP pwplus--don't use.
6699            :
6700          else
6701            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6702            break 3
6703          fi
6704        fi
6705      done
6706    done
6707    ;;
6708 esac
6709 done
6710
6711
6712 fi
6713  if test "${ac_cv_path_install+set}" = set; then
6714    INSTALL=$ac_cv_path_install
6715  else
6716    # As a last resort, use the slow shell script.  We don't cache a
6717    # path for INSTALL within a source directory, because that will
6718    # break other packages using the cache if that directory is
6719    # removed, or if the path is relative.
6720    INSTALL=$ac_install_sh
6721  fi
6722 fi
6723 echo "$as_me:$LINENO: result: $INSTALL" >&5
6724 echo "${ECHO_T}$INSTALL" >&6
6725
6726 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6727 # It thinks the first close brace ends the variable substitution.
6728 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6729
6730 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6731
6732 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6733
6734 echo "$as_me:$LINENO: checking whether ln -s works" >&5
6735 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6736 LN_S=$as_ln_s
6737 if test "$LN_S" = "ln -s"; then
6738  echo "$as_me:$LINENO: result: yes" >&5
6739 echo "${ECHO_T}yes" >&6
6740 else
6741  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6742 echo "${ECHO_T}no, using $LN_S" >&6
6743 fi
6744
6745 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6746 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6747 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6748 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6749  echo $ECHO_N "(cached) $ECHO_C" >&6
6750 else
6751  cat >conftest.make <<\_ACEOF
6752 all:
6753        @echo 'ac_maketemp="$(MAKE)"'
6754 _ACEOF
6755 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6756 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6757 if test -n "$ac_maketemp"; then
6758  eval ac_cv_prog_make_${ac_make}_set=yes
6759 else
6760  eval ac_cv_prog_make_${ac_make}_set=no
6761 fi
6762 rm -f conftest.make
6763 fi
6764 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6765  echo "$as_me:$LINENO: result: yes" >&5
6766 echo "${ECHO_T}yes" >&6
6767  SET_MAKE=
6768 else
6769  echo "$as_me:$LINENO: result: no" >&5
6770 echo "${ECHO_T}no" >&6
6771  SET_MAKE="MAKE=${MAKE-make}"
6772 fi
6773
6774 if test -n "$ac_tool_prefix"; then
6775  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6776 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6777 echo "$as_me:$LINENO: checking for $ac_word" >&5
6778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6779 if test "${ac_cv_prog_RANLIB+set}" = set; then
6780  echo $ECHO_N "(cached) $ECHO_C" >&6
6781 else
6782  if test -n "$RANLIB"; then
6783  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6784 else
6785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6786 for as_dir in $PATH
6787 do
6788  IFS=$as_save_IFS
6789  test -z "$as_dir" && as_dir=.
6790  for ac_exec_ext in '' $ac_executable_extensions; do
6791  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6792    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6793    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6794    break 2
6795  fi
6796 done
6797 done
6798
6799 fi
6800 fi
6801 RANLIB=$ac_cv_prog_RANLIB
6802 if test -n "$RANLIB"; then
6803  echo "$as_me:$LINENO: result: $RANLIB" >&5
6804 echo "${ECHO_T}$RANLIB" >&6
6805 else
6806  echo "$as_me:$LINENO: result: no" >&5
6807 echo "${ECHO_T}no" >&6
6808 fi
6809
6810 fi
6811 if test -z "$ac_cv_prog_RANLIB"; then
6812  ac_ct_RANLIB=$RANLIB
6813  # Extract the first word of "ranlib", so it can be a program name with args.
6814 set dummy ranlib; ac_word=$2
6815 echo "$as_me:$LINENO: checking for $ac_word" >&5
6816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6817 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6818  echo $ECHO_N "(cached) $ECHO_C" >&6
6819 else
6820  if test -n "$ac_ct_RANLIB"; then
6821  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6822 else
6823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6824 for as_dir in $PATH
6825 do
6826  IFS=$as_save_IFS
6827  test -z "$as_dir" && as_dir=.
6828  for ac_exec_ext in '' $ac_executable_extensions; do
6829  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6830    ac_cv_prog_ac_ct_RANLIB="ranlib"
6831    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6832    break 2
6833  fi
6834 done
6835 done
6836
6837  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6838 fi
6839 fi
6840 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6841 if test -n "$ac_ct_RANLIB"; then
6842  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6843 echo "${ECHO_T}$ac_ct_RANLIB" >&6
6844 else
6845  echo "$as_me:$LINENO: result: no" >&5
6846 echo "${ECHO_T}no" >&6
6847 fi
6848
6849  RANLIB=$ac_ct_RANLIB
6850 else
6851  RANLIB="$ac_cv_prog_RANLIB"
6852 fi
6853
6854 for ac_prog in 'bison -y' byacc
6855 do
6856  # Extract the first word of "$ac_prog", so it can be a program name with args.
6857 set dummy $ac_prog; ac_word=$2
6858 echo "$as_me:$LINENO: checking for $ac_word" >&5
6859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6860 if test "${ac_cv_prog_YACC+set}" = set; then
6861  echo $ECHO_N "(cached) $ECHO_C" >&6
6862 else
6863  if test -n "$YACC"; then
6864  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6865 else
6866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6867 for as_dir in $PATH
6868 do
6869  IFS=$as_save_IFS
6870  test -z "$as_dir" && as_dir=.
6871  for ac_exec_ext in '' $ac_executable_extensions; do
6872  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6873    ac_cv_prog_YACC="$ac_prog"
6874    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6875    break 2
6876  fi
6877 done
6878 done
6879
6880 fi
6881 fi
6882 YACC=$ac_cv_prog_YACC
6883 if test -n "$YACC"; then
6884  echo "$as_me:$LINENO: result: $YACC" >&5
6885 echo "${ECHO_T}$YACC" >&6
6886 else
6887  echo "$as_me:$LINENO: result: no" >&5
6888 echo "${ECHO_T}no" >&6
6889 fi
6890
6891  test -n "$YACC" && break
6892 done
6893 test -n "$YACC" || YACC="yacc"
6894
6895 for ac_prog in flex lex
6896 do
6897  # Extract the first word of "$ac_prog", so it can be a program name with args.
6898 set dummy $ac_prog; ac_word=$2
6899 echo "$as_me:$LINENO: checking for $ac_word" >&5
6900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6901 if test "${ac_cv_prog_LEX+set}" = set; then
6902  echo $ECHO_N "(cached) $ECHO_C" >&6
6903 else
6904  if test -n "$LEX"; then
6905  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6906 else
6907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6908 for as_dir in $PATH
6909 do
6910  IFS=$as_save_IFS
6911  test -z "$as_dir" && as_dir=.
6912  for ac_exec_ext in '' $ac_executable_extensions; do
6913  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6914    ac_cv_prog_LEX="$ac_prog"
6915    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6916    break 2
6917  fi
6918 done
6919 done
6920
6921 fi
6922 fi
6923 LEX=$ac_cv_prog_LEX
6924 if test -n "$LEX"; then
6925  echo "$as_me:$LINENO: result: $LEX" >&5
6926 echo "${ECHO_T}$LEX" >&6
6927 else
6928  echo "$as_me:$LINENO: result: no" >&5
6929 echo "${ECHO_T}no" >&6
6930 fi
6931
6932  test -n "$LEX" && break
6933 done
6934 test -n "$LEX" || LEX=":"
6935
6936 if test -z "$LEXLIB"
6937 then
6938  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6939 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6940 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6941  echo $ECHO_N "(cached) $ECHO_C" >&6
6942 else
6943  ac_check_lib_save_LIBS=$LIBS
6944 LIBS="-lfl  $LIBS"
6945 cat >conftest.$ac_ext <<_ACEOF
6946 /* confdefs.h.  */
6947 _ACEOF
6948 cat confdefs.h >>conftest.$ac_ext
6949 cat >>conftest.$ac_ext <<_ACEOF
6950 /* end confdefs.h.  */
6951
6952 /* Override any gcc2 internal prototype to avoid an error.  */
6953 #ifdef __cplusplus
6954 extern "C"
6955 #endif
6956 /* We use char because int might match the return type of a gcc2
6957   builtin and then its argument prototype would still apply.  */
6958 char yywrap ();
6959 int
6960 main ()
6961 {
6962 yywrap ();
6963  ;
6964  return 0;
6965 }
6966 _ACEOF
6967 rm -f conftest.$ac_objext conftest$ac_exeext
6968 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6969  (eval $ac_link) 2>conftest.er1
6970  ac_status=$?
6971  grep -v '^ *+' conftest.er1 >conftest.err
6972  rm -f conftest.er1
6973  cat conftest.err >&5
6974  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6975  (exit $ac_status); } &&
6976         { ac_try='test -z "$ac_c_werror_flag"
6977                         || test ! -s conftest.err'
6978  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6979  (eval $ac_try) 2>&5
6980  ac_status=$?
6981  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6982  (exit $ac_status); }; } &&
6983         { ac_try='test -s conftest$ac_exeext'
6984  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6985  (eval $ac_try) 2>&5
6986  ac_status=$?
6987  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6988  (exit $ac_status); }; }; then
6989  ac_cv_lib_fl_yywrap=yes
6990 else
6991  echo "$as_me: failed program was:" >&5
6992 sed 's/^/| /' conftest.$ac_ext >&5
6993
6994 ac_cv_lib_fl_yywrap=no
6995 fi
6996 rm -f conftest.err conftest.$ac_objext \
6997      conftest$ac_exeext conftest.$ac_ext
6998 LIBS=$ac_check_lib_save_LIBS
6999 fi
7000 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
7001 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
7002 if test $ac_cv_lib_fl_yywrap = yes; then
7003  LEXLIB="-lfl"
7004 else
7005  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
7006 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
7007 if test "${ac_cv_lib_l_yywrap+set}" = set; then
7008  echo $ECHO_N "(cached) $ECHO_C" >&6
7009 else
7010  ac_check_lib_save_LIBS=$LIBS
7011 LIBS="-ll  $LIBS"
7012 cat >conftest.$ac_ext <<_ACEOF
7013 /* confdefs.h.  */
7014 _ACEOF
7015 cat confdefs.h >>conftest.$ac_ext
7016 cat >>conftest.$ac_ext <<_ACEOF
7017 /* end confdefs.h.  */
7018
7019 /* Override any gcc2 internal prototype to avoid an error.  */
7020 #ifdef __cplusplus
7021 extern "C"
7022 #endif
7023 /* We use char because int might match the return type of a gcc2
7024   builtin and then its argument prototype would still apply.  */
7025 char yywrap ();
7026 int
7027 main ()
7028 {
7029 yywrap ();
7030  ;
7031  return 0;
7032 }
7033 _ACEOF
7034 rm -f conftest.$ac_objext conftest$ac_exeext
7035 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7036  (eval $ac_link) 2>conftest.er1
7037  ac_status=$?
7038  grep -v '^ *+' conftest.er1 >conftest.err
7039  rm -f conftest.er1
7040  cat conftest.err >&5
7041  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7042  (exit $ac_status); } &&
7043         { ac_try='test -z "$ac_c_werror_flag"
7044                         || test ! -s conftest.err'
12851    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12852    (eval $ac_try) 2>&5
12853    ac_status=$?
12854    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12855 <  (exit $ac_status); }; } &&
12856 <         { ac_try='test -s conftest$ac_exeext'
7051 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7052 <  (eval $ac_try) 2>&5
7053 <  ac_status=$?
7054 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7055 <  (exit $ac_status); }; }; then
7056 <  ac_cv_lib_l_yywrap=yes
12855 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12856 >  ac_cv_prog_gxx_2_95=yes
12857   else
12858 <  echo "$as_me: failed program was:" >&5
7059 < sed 's/^/| /' conftest.$ac_ext >&5
7060 <
7061 < ac_cv_lib_l_yywrap=no
12858 >  ac_cv_prog_gxx_2_95=no
12859   fi
7063 rm -f conftest.err conftest.$ac_objext \
7064      conftest$ac_exeext conftest.$ac_ext
7065 LIBS=$ac_check_lib_save_LIBS
7066 fi
7067 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
7068 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
7069 if test $ac_cv_lib_l_yywrap = yes; then
7070  LEXLIB="-ll"
7071 fi
12860  
12861   fi
12862 + echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12863 + echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12864 + if test "$ac_cv_prog_gxx_2_95" = yes; then
12865 +        :
12866  
7075 fi
12867  
12868 < if test "x$LEX" != "x:"; then
12869 <  echo "$as_me:$LINENO: checking lex output file root" >&5
12870 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
7080 < if test "${ac_cv_prog_lex_root+set}" = set; then
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 <  # The minimal lex program is just a single line: %%.  But some broken lexes
12874 < # (Solaris, I think it was) want two %% lines, so accommodate them.
12875 < cat >conftest.l <<_ACEOF
7086 < %%
7087 < %%
7088 < _ACEOF
7089 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
7090 <  (eval $LEX conftest.l) 2>&5
7091 <  ac_status=$?
7092 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7093 <  (exit $ac_status); }
7094 < if test -f lex.yy.c; then
7095 <  ac_cv_prog_lex_root=lex.yy
7096 < elif test -f lexyy.c; then
7097 <  ac_cv_prog_lex_root=lexyy
12873 >  echo 'void f(){}' > conftest.cpp
12874 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12875 >        ac_m_cpu_750=yes
12876   else
12877 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7100 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7101 <   { (exit 1); exit 1; }; }
12877 >        ac_m_cpu_750=no
12878   fi
12879 < fi
7104 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7105 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7106 < rm -f conftest.l
7107 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12879 > rm -f conftest*
12880  
12881 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
12882 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
12883 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
12884 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12881 > fi
12882 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12883 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12884 > if test "$ac_m_cpu_750" = yes; then
12885 >        :
12886 >        CPU_FLAGS=-mcpu=750
12887   else
12888 <  # POSIX says lex can declare yytext either as a pointer or an array; the
7115 < # default is implementation-dependent. Figure out which it is, since
7116 < # not all implementations provide the %pointer and %array declarations.
7117 < ac_cv_prog_lex_yytext_pointer=no
7118 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
7119 < ac_save_LIBS=$LIBS
7120 < LIBS="$LIBS $LEXLIB"
7121 < cat >conftest.$ac_ext <<_ACEOF
7122 < `cat $LEX_OUTPUT_ROOT.c`
7123 < _ACEOF
7124 < rm -f conftest.$ac_objext conftest$ac_exeext
7125 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7126 <  (eval $ac_link) 2>conftest.er1
7127 <  ac_status=$?
7128 <  grep -v '^ *+' conftest.er1 >conftest.err
7129 <  rm -f conftest.er1
7130 <  cat conftest.err >&5
7131 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7132 <  (exit $ac_status); } &&
7133 <         { ac_try='test -z "$ac_c_werror_flag"
7134 <                         || test ! -s conftest.err'
7135 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7136 <  (eval $ac_try) 2>&5
7137 <  ac_status=$?
7138 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7139 <  (exit $ac_status); }; } &&
7140 <         { ac_try='test -s conftest$ac_exeext'
7141 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7142 <  (eval $ac_try) 2>&5
7143 <  ac_status=$?
7144 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7145 <  (exit $ac_status); }; }; then
7146 <  ac_cv_prog_lex_yytext_pointer=yes
7147 < else
7148 <  echo "$as_me: failed program was:" >&5
7149 < sed 's/^/| /' conftest.$ac_ext >&5
12888 >        :
12889  
12890   fi
7152 rm -f conftest.err conftest.$ac_objext \
7153      conftest$ac_exeext conftest.$ac_ext
7154 LIBS=$ac_save_LIBS
7155 rm -f "${LEX_OUTPUT_ROOT}.c"
12891  
12892 < fi
12893 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
7159 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
7160 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12892 > else
12893 >        :
12894  
7162 cat >>confdefs.h <<\_ACEOF
7163 #define YYTEXT_POINTER 1
7164 _ACEOF
7165
12895   fi
12896  
12897 < fi
12897 >                fi
12898 >                if test -z "$CPU_FLAGS"; then
12899  
12900 <   # Extract the first word of "perl", so it can be a program name with args.
12901 < set dummy perl; ac_word=$2
12902 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12903 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7174 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
12900 >
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 <  case $PERLINTERP in
12907 <  [\\/]* | ?:[\\/]*)
12908 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
12909 <  ;;
12910 <  *)
7182 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7183 < for as_dir in $PATH
7184 < do
7185 <  IFS=$as_save_IFS
7186 <  test -z "$as_dir" && as_dir=.
7187 <  for ac_exec_ext in '' $ac_executable_extensions; do
7188 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7189 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
7190 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7191 <    break 2
7192 <  fi
7193 < done
7194 < done
7195 <
7196 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
7197 <  ;;
7198 < esac
12906 >  echo 'void f(){}' > conftest.cpp
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
12911   fi
12912 < PERLINTERP=$ac_cv_path_PERLINTERP
12912 > rm -f conftest*
12913  
12914 < if test -n "$PERLINTERP"; then
12915 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
12916 < echo "${ECHO_T}$PERLINTERP" >&6
12914 > fi
12915 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12916 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12917 > if test "$ac_m_cpu_powerpc" = yes; then
12918 >        :
12919 >        CPU_FLAGS=-mcpu=powerpc
12920   else
12921 <  echo "$as_me:$LINENO: result: no" >&5
12922 < echo "${ECHO_T}no" >&6
12921 >        :
12922 >
12923   fi
12924  
12925 <   ac_cv_path_perlinterp="$PERLINTERP"
12926 <   _sHpB='#!'
12925 >                fi
12926 >                if test -z "$CPU_FLAGS"; then
12927  
12928  
12929 < # Check whether --with-perl-shebang or --without-perl-shebang was given.
12930 < if test "${with_perl_shebang+set}" = set; then
12931 <  withval="$with_perl_shebang"
7217 <  opt_perl_shebang="$withval"
7218 < else
7219 <                opt_perl_shebang="not_set"
7220 < fi;
7221 <   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
7222 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
7223 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
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 <   case "$opt_perl_shebang" in
12935 <                      not_set  ) ax_cv_opt_perl_shebang=''
12936 <                               ;;
12937 <                         *     )
12938 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
7231 <                    esac
7232 <
12934 >  echo 'void f(){}' > conftest.cpp
12935 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12936 >        ac_m_powerpc=yes
12937 > else
12938 >        ac_m_powerpc=no
12939   fi
12940 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
7235 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
7236 <   if test "A$ax_cv_opt_perl_shebang" != "A"
7237 <     then
7238 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
7239 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
7240 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
7241 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
12940 > rm -f conftest*
12941  
12942 < # Automatic detection of sharpbang formula starts here
12943 <     else
12944 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
12945 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
12946 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
12947 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
7249 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
7250 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12942 > fi
12943 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12944 > echo "${ECHO_T}$ac_m_powerpc" >&6
12945 > if test "$ac_m_powerpc" = yes; then
12946 >        :
12947 >        CPU_FLAGS=-mpowerpc
12948   else
12949 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
7253 <        if test "x$_somian_kspb_perl" == x
7254 <          then _somian_ksbp_warn_empty='durnit'
7255 <          else
7256 <          case "A$_somian_kspb_perl" in
7257 <                 A#!*perl* )
7258 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
7259 <                        ;;
7260 <                     A*    )  _somian_ksbp_warn_defau='trouble'
7261 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
7262 <          esac
7263 <        fi
12949 >        :
12950  
12951   fi
7266 echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
7267 echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
7268 # The above prints Checking ... result message to user.
7269   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
12952  
12953 <    if test A${_somian_ksbp_warn_empty+set} == Aset
12954 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
7273 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
7274 <    fi
7275 < # Inform user after printing result value
7276 <    if test A${_somian_ksbp_warn_defau+set} == Aset
7277 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
7278 < echo "$as_me: Maybe Not good -" >&6;}
7279 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
7280 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
7281 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
7282 < echo "$as_me: OK Good result - " >&6;}
7283 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
7284 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
7285 <    fi
12953 >                fi
12954 >          esac
12955    fi
12956  
12957 < # Extract the first word of "ar", so it can be a program name with args.
12958 < set dummy ar; ac_word=$2
7290 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7291 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7292 < if test "${ac_cv_prog_AR+set}" = set; then
7293 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7294 < else
7295 <  if test -n "$AR"; then
7296 <  ac_cv_prog_AR="$AR" # Let the user override the test.
7297 < else
7298 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7299 < for as_dir in $PATH
7300 < do
7301 <  IFS=$as_save_IFS
7302 <  test -z "$as_dir" && as_dir=.
7303 <  for ac_exec_ext in '' $ac_executable_extensions; do
7304 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7305 <    ac_cv_prog_AR="ar"
7306 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7307 <    break 2
12957 >  if test -n "$CPU_FLAGS"; then
12958 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12959    fi
7309 done
7310 done
12960  
12961 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12962 < fi
12963 < fi
12964 < AR=$ac_cv_prog_AR
12965 < if test -n "$AR"; then
12966 <  echo "$as_me:$LINENO: result: $AR" >&5
12967 < echo "${ECHO_T}$AR" >&6
12968 < else
12969 <  echo "$as_me:$LINENO: result: no" >&5
12970 < echo "${ECHO_T}no" >&6
7322 < fi
12961 >  if test -z "$CXXFLAGS"; then
12962 >        echo ""
12963 >        echo "**********************************************************"
12964 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12965 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12966 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12967 >        echo "**********************************************************"
12968 >        echo ""
12969 >        CXXFLAGS="-O3"
12970 >  fi
12971  
7324 if test "$AR" = "NONE"; then
7325  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
7326 echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7327   { (exit 1); exit 1; }; }
7328  cat >confcache <<\_ACEOF
7329 # This file is a shell script that caches the results of configure
7330 # tests run on this system so they can be shared between configure
7331 # scripts and configure runs, see configure's option --config-cache.
7332 # It is not useful on other systems.  If it contains results you don't
7333 # want to keep, you may remove or edit it.
7334 #
7335 # config.status only pays attention to the cache file if you give it
7336 # the --recheck option to rerun configure.
7337 #
7338 # `ac_cv_env_foo' variables (set or unset) will be overridden when
7339 # loading this file, other *unset* `ac_cv_foo' will be assigned the
7340 # following values.
12972  
7342 _ACEOF
12973  
12974 < # The following way of writing the cache mishandles newlines in values,
12975 < # but we know of no workaround that is simple, portable, and efficient.
12976 < # So, don't put newlines in cache variables' values.
7347 < # Ultrix sh set writes to stderr and can't be redirected directly,
7348 < # and sets the high bit in the cache file unless we assign to the vars.
7349 < {
7350 <  (set) 2>&1 |
7351 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
7352 <    *ac_space=\ *)
7353 <      # `set' does not quote correctly, so add quotes (double-quote
7354 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7355 <      sed -n \
7356 <        "s/'/'\\\\''/g;
7357 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7358 <      ;;
7359 <    *)
7360 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
7361 <      sed -n \
7362 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7363 <      ;;
7364 <    esac;
7365 < } |
7366 <  sed '
7367 <     t clear
7368 <     : clear
7369 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7370 <     t end
7371 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7372 <     : end' >>confcache
7373 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
7374 <  if test -w $cache_file; then
7375 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7376 <    cat confcache >$cache_file
7377 <  else
7378 <    echo "not updating unwritable cache $cache_file"
7379 <  fi
7380 < fi
7381 < rm -f confcache
7382 <  exit 1
7383 < fi
7384 <
7385 < # Extract the first word of "ps", so it can be a program name with args.
7386 < set dummy ps; ac_word=$2
7387 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7388 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7389 < if test "${ac_cv_path_PS+set}" = set; then
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 <  case $PS in
12980 <  [\\/]* | ?:[\\/]*)
12981 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
12982 <  ;;
12983 <  *)
7397 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7398 < for as_dir in $PATH
7399 < do
7400 <  IFS=$as_save_IFS
7401 <  test -z "$as_dir" && as_dir=.
7402 <  for ac_exec_ext in '' $ac_executable_extensions; do
7403 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7404 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7405 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7406 <    break 2
7407 <  fi
7408 < done
7409 < done
7410 <
7411 <  ;;
7412 < esac
12979 >  echo 'void f(){}' > conftest.cpp
12980 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12981 >        ac_guessed_cxxflags=yes
12982 > else
12983 >        ac_guessed_cxxflags=no
12984   fi
12985 < PS=$ac_cv_path_PS
12985 > rm -f conftest*
12986  
7416 if test -n "$PS"; then
7417  echo "$as_me:$LINENO: result: $PS" >&5
7418 echo "${ECHO_T}$PS" >&6
7419 else
7420  echo "$as_me:$LINENO: result: no" >&5
7421 echo "${ECHO_T}no" >&6
12987   fi
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 +        :
12992  
7424 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
7425 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
7426 if test "${ac_cv_prog_ps_syntax+set}" = set; then
7427  echo $ECHO_N "(cached) $ECHO_C" >&6
12993   else
12994 +        :
12995  
12996 <        if $PS ax -o rss > /dev/null 2>&1; then
12997 <                ac_cv_prog_ps_ax=yes
12998 <        else
12999 <                ac_cv_prog_ps_ax=no
13000 <        fi
13001 <        if $PS -ef -o rss > /dev/null 2>&1; then
13002 <                ac_cv_prog_ps_ef=yes
13003 <        else
7438 <                ac_cv_prog_ps_ef=no
7439 <        fi
7440 <        if test "$ac_cv_prog_ps_ax" = yes; then
7441 <                ac_cv_prog_ps_syntax=BSD
7442 <        else
7443 <                if test "$ac_cv_prog_ps_ef" = yes; then
7444 <                        ac_cv_prog_ps_syntax=POSIX
7445 <                else
7446 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7447 < echo "$as_me: error: Could not determine ps syntax" >&2;}
7448 <   { (exit 1); exit 1; }; }
7449 <                fi
7450 <        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
7453 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7454 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
13006  
13007  
13008 < cat >>confdefs.h <<_ACEOF
7458 < #define PSCOMMAND $PS
7459 < _ACEOF
13008 > fi
13009  
13010 +     ;;
13011 + esac
13012  
7462 if test "$ac_cv_prog_ps_syntax" = BSD; then
7463  cat >>confdefs.h <<\_ACEOF
7464 #define PSTYPE_IS_BSD 1
7465 _ACEOF
13013  
13014 < else
13015 <   if test "$ac_cv_prog_ps_syntax" = POSIX; then
7469 <       cat >>confdefs.h <<\_ACEOF
7470 < #define PSTYPE_IS_POSIX 1
13014 > cat >>confdefs.h <<\_ACEOF
13015 > #define OBAPI
13016   _ACEOF
13017  
7473   else
7474       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
7475 echo "$as_me: error: Unknown ps syntax type!" >&2;}
7476   { (exit 1); exit 1; }; }
7477   fi
7478 fi
13018  
13019  
13020 +
13021   # Check whether --with-mpi or --without-mpi was given.
13022   if test "${with_mpi+set}" = set; then
13023    withval="$with_mpi"
# Line 7506 | 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 7529 | 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 7588 | 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 7658 | 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 7729 | 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 7800 | 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 7844 | Line 13420 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
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="-lmpich -lpmpich"
13423 >  MPI_LIB="-lpmpich -lmpich"
13424   fi
13425  
13426   fi
# Line 7872 | Line 13448 | int
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 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   {
# Line 7948 | Line 13532 | fi
13532  
13533  
13534  
7951
13535   USE_CGAL=no
13536   cgal_makefile=auto
13537  
# Line 7964 | Line 13547 | if test "x$cgal_makefile" != xno; then
13547      cgal_makefile="$CGAL_MAKEFILE"
13548    fi
13549  
13550 <  echo "cgal_makefile      $cgal_makefile"
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    if test -f "$cgal_makefile"; then
13554  
# Line 8026 | Line 13610 | EOF
13610        GMP_RLIBDIR=""
13611      fi
13612  
13613 <    echo "CGAL_OS_COMPILER   $CGAL_OS_COMPILER"
13614 <    echo "CGAL_INCLDIR       $CGAL_INCLDIR"
13615 <    echo "CGAL_INCLCONFDIR   $CGAL_INCLCONFDIR"
13616 <    echo "CGAL_LIBDIR        $CGAL_LIBDIR"
13617 <    echo "CGAL_CXXFLAGS      $CGAL_CXXFLAGS"
13618 <    echo "LEDA_INCLDIR       $LEDA_INCLDIR"
13619 <    echo "LEDA_LIBDIR        $LEDA_LIBDIR"
13620 <    echo "GMP_INCLDIR        $GMP_INCLDIR"
13621 <    echo "GMP_LIBDIR         $GMP_LIBDIR"
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'
# Line 8044 | Line 13637 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13637  
13638      save_CXXFLAGS="$CXXFLAGS"
13639      CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13640 <
8048 < ac_ext=cc
8049 < ac_cpp='$CXXCPP $CPPFLAGS'
8050 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8051 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8052 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8053 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
8054 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
8055 < if test -z "$CXXCPP"; then
8056 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
8057 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8058 < else
8059 <      # Double quotes because CXXCPP needs to be expanded
8060 <    for CXXCPP in "$CXX -E" "/lib/cpp"
8061 <    do
8062 <      ac_preproc_ok=false
8063 < for ac_cxx_preproc_warn_flag in '' yes
8064 < do
8065 <  # Use a header file that comes with gcc, so configuring glibc
8066 <  # with a fresh cross-compiler works.
8067 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8068 <  # <limits.h> exists even on freestanding compilers.
8069 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8070 <  # not just through cpp. "Syntax error" is here to catch this case.
8071 <  cat >conftest.$ac_ext <<_ACEOF
8072 < /* confdefs.h.  */
8073 < _ACEOF
8074 < cat confdefs.h >>conftest.$ac_ext
8075 < cat >>conftest.$ac_ext <<_ACEOF
8076 < /* end confdefs.h.  */
8077 < #ifdef __STDC__
8078 < # include <limits.h>
8079 < #else
8080 < # include <assert.h>
8081 < #endif
8082 <                     Syntax error
8083 < _ACEOF
8084 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8085 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8086 <  ac_status=$?
8087 <  grep -v '^ *+' conftest.er1 >conftest.err
8088 <  rm -f conftest.er1
8089 <  cat conftest.err >&5
8090 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8091 <  (exit $ac_status); } >/dev/null; then
8092 <  if test -s conftest.err; then
8093 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8094 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8095 <  else
8096 <    ac_cpp_err=
8097 <  fi
8098 < else
8099 <  ac_cpp_err=yes
8100 < fi
8101 < if test -z "$ac_cpp_err"; then
8102 <  :
8103 < else
8104 <  echo "$as_me: failed program was:" >&5
8105 < sed 's/^/| /' conftest.$ac_ext >&5
8106 <
8107 <  # Broken: fails on valid input.
8108 < continue
8109 < fi
8110 < rm -f conftest.err conftest.$ac_ext
8111 <
8112 <  # OK, works on sane cases.  Now check whether non-existent headers
8113 <  # can be detected and how.
8114 <  cat >conftest.$ac_ext <<_ACEOF
8115 < /* confdefs.h.  */
8116 < _ACEOF
8117 < cat confdefs.h >>conftest.$ac_ext
8118 < cat >>conftest.$ac_ext <<_ACEOF
8119 < /* end confdefs.h.  */
8120 < #include <ac_nonexistent.h>
8121 < _ACEOF
8122 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8123 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8124 <  ac_status=$?
8125 <  grep -v '^ *+' conftest.er1 >conftest.err
8126 <  rm -f conftest.er1
8127 <  cat conftest.err >&5
8128 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8129 <  (exit $ac_status); } >/dev/null; then
8130 <  if test -s conftest.err; then
8131 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8132 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8133 <  else
8134 <    ac_cpp_err=
8135 <  fi
8136 < else
8137 <  ac_cpp_err=yes
8138 < fi
8139 < if test -z "$ac_cpp_err"; then
8140 <  # Broken: success on invalid input.
8141 < continue
8142 < else
8143 <  echo "$as_me: failed program was:" >&5
8144 < sed 's/^/| /' conftest.$ac_ext >&5
8145 <
8146 <  # Passes both tests.
8147 < ac_preproc_ok=:
8148 < break
8149 < fi
8150 < rm -f conftest.err conftest.$ac_ext
8151 <
8152 < done
8153 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8154 < rm -f conftest.err conftest.$ac_ext
8155 < if $ac_preproc_ok; then
8156 <  break
8157 < fi
8158 <
8159 <    done
8160 <    ac_cv_prog_CXXCPP=$CXXCPP
8161 <
8162 < fi
8163 <  CXXCPP=$ac_cv_prog_CXXCPP
8164 < else
8165 <  ac_cv_prog_CXXCPP=$CXXCPP
8166 < fi
8167 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
8168 < echo "${ECHO_T}$CXXCPP" >&6
8169 < ac_preproc_ok=false
8170 < for ac_cxx_preproc_warn_flag in '' yes
8171 < do
8172 <  # Use a header file that comes with gcc, so configuring glibc
8173 <  # with a fresh cross-compiler works.
8174 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8175 <  # <limits.h> exists even on freestanding compilers.
8176 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8177 <  # not just through cpp. "Syntax error" is here to catch this case.
8178 <  cat >conftest.$ac_ext <<_ACEOF
8179 < /* confdefs.h.  */
8180 < _ACEOF
8181 < cat confdefs.h >>conftest.$ac_ext
8182 < cat >>conftest.$ac_ext <<_ACEOF
8183 < /* end confdefs.h.  */
8184 < #ifdef __STDC__
8185 < # include <limits.h>
8186 < #else
8187 < # include <assert.h>
8188 < #endif
8189 <                     Syntax error
8190 < _ACEOF
8191 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8192 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8193 <  ac_status=$?
8194 <  grep -v '^ *+' conftest.er1 >conftest.err
8195 <  rm -f conftest.er1
8196 <  cat conftest.err >&5
8197 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8198 <  (exit $ac_status); } >/dev/null; then
8199 <  if test -s conftest.err; then
8200 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8201 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8202 <  else
8203 <    ac_cpp_err=
8204 <  fi
8205 < else
8206 <  ac_cpp_err=yes
8207 < fi
8208 < if test -z "$ac_cpp_err"; then
8209 <  :
8210 < else
8211 <  echo "$as_me: failed program was:" >&5
8212 < sed 's/^/| /' conftest.$ac_ext >&5
8213 <
8214 <  # Broken: fails on valid input.
8215 < continue
8216 < fi
8217 < rm -f conftest.err conftest.$ac_ext
8218 <
8219 <  # OK, works on sane cases.  Now check whether non-existent headers
8220 <  # can be detected and how.
8221 <  cat >conftest.$ac_ext <<_ACEOF
8222 < /* confdefs.h.  */
8223 < _ACEOF
8224 < cat confdefs.h >>conftest.$ac_ext
8225 < cat >>conftest.$ac_ext <<_ACEOF
8226 < /* end confdefs.h.  */
8227 < #include <ac_nonexistent.h>
8228 < _ACEOF
8229 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8230 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8231 <  ac_status=$?
8232 <  grep -v '^ *+' conftest.er1 >conftest.err
8233 <  rm -f conftest.er1
8234 <  cat conftest.err >&5
8235 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8236 <  (exit $ac_status); } >/dev/null; then
8237 <  if test -s conftest.err; then
8238 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8239 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8240 <  else
8241 <    ac_cpp_err=
8242 <  fi
8243 < else
8244 <  ac_cpp_err=yes
8245 < fi
8246 < if test -z "$ac_cpp_err"; then
8247 <  # Broken: success on invalid input.
8248 < continue
8249 < else
8250 <  echo "$as_me: failed program was:" >&5
8251 < sed 's/^/| /' conftest.$ac_ext >&5
8252 <
8253 <  # Passes both tests.
8254 < ac_preproc_ok=:
8255 < break
8256 < fi
8257 < rm -f conftest.err conftest.$ac_ext
8258 <
8259 < done
8260 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8261 < rm -f conftest.err conftest.$ac_ext
8262 < if $ac_preproc_ok; then
8263 <  :
8264 < else
8265 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8266 < See \`config.log' for more details." >&5
8267 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8268 < See \`config.log' for more details." >&2;}
8269 <   { (exit 1); exit 1; }; }
8270 < fi
8271 <
8272 < ac_ext=cc
8273 < ac_cpp='$CXXCPP $CPPFLAGS'
8274 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8275 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8276 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8277 <
8278 <
8279 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
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
# Line 8474 | Line 13835 | echo "${ECHO_T}no" >&6
13835  
13836        CGAL_CXXFLAGS="-ftemplate-depth-50"
13837  
13838 <      echo "CGAL_USES_LEDA     $CGAL_USES_LEDA"
13839 <      echo "CGAL_USES_GMP      $CGAL_USES_GMP"
13840 <      echo "CGAL_INCLDIR       $CGAL_INCLDIR"
13841 <      echo "CGAL_LIBDIR        $CGAL_LIBDIR"
13842 <      echo "CGAL_DEFINES       $CGAL_DEFINES"
13843 <      echo "CGAL_CXXFLAGS      $CGAL_CXXFLAGS"
13844 <      echo "CGAL_LIBS          $CGAL_LIBS"
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
# Line 8505 | Line 13873 | int
13873   cat >>conftest.$ac_ext <<_ACEOF
13874   /* end confdefs.h.  */
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 + #endif
13884   int
13885   main ()
13886   {
# Line 8587 | Line 13963 | else
13963    fi
13964   else
13965     if test "x$cgal_makefile" != xno; then
13966 <    { echo "$as_me:$LINENO: WARNING: *********************************************************" >&5
13967 < echo "$as_me: WARNING: *********************************************************" >&2;}
8592 <    { echo "$as_me:$LINENO: WARNING: *** Warning: CGAL was not found.                      ***" >&5
8593 < echo "$as_me: WARNING: *** Warning: CGAL was not found.                      ***" >&2;}
8594 <    { echo "$as_me:$LINENO: WARNING: *** Run \"configure\" with the appropriate options.     ***" >&5
8595 < echo "$as_me: WARNING: *** Run \"configure\" with the appropriate options.     ***" >&2;}
8596 <    { echo "$as_me:$LINENO: WARNING: *** CGAL support will be disabled.                    ***" >&5
8597 < echo "$as_me: WARNING: *** CGAL support will be disabled.                    ***" >&2;}
8598 <    { echo "$as_me:$LINENO: WARNING: *********************************************************" >&5
8599 < echo "$as_me: WARNING: *********************************************************" >&2;}
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=
# Line 8618 | Line 13986 | CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13986  
13987  
13988  
8621
13989   # Check whether --enable-doxygen or --disable-doxygen was given.
13990   if test "${enable_doxygen+set}" = set; then
13991    enableval="$enable_doxygen"
# Line 8760 | Line 14127 | OBJEXT=".$OBJEXT"
14127  
14128  
14129  
8763 OBJEXT=".$OBJEXT"
14130  
8765 OOPSE=oopse
14131  
8767 if test "x${prefix}" = "xNONE"
8768 then
8769  OOPSE_HOME=${ac_default_prefix}/oopse
8770 else
8771  OOPSE_HOME=${prefix}/oopse
8772 fi
8773 # Check whether --enable-oopse-home or --disable-oopse-home was given.
8774 if test "${enable_oopse_home+set}" = set; then
8775  enableval="$enable_oopse_home"
8776  OOPSE_HOME="${enableval}"
8777 fi;
14132  
8779 case "x$INSTALL" in
8780   x/*) ;;
8781   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
8782 esac
14133  
8784 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14134  
8786 CFLAGS=${CFLAGS-""}
8787 CXXFLAGS=${CXXFLAGS-""}
8788 CPPFLAGS=${CPPFLAGS-""}
8789 FFLAGS=${FFLAGS-""}
8790 F90FLAGS=${F90FLAGS-""}
8791 LDFLAGS=${LDFLAGS-""}
8792 DEBUG=${DEBUG-"-g"}
14135  
8794 case $debug in
8795  1)
8796     FFLAGS="$DEBUG $FFLAGS"
8797     F90FLAGS="$DEBUG $F90FLAGS"
8798     ;;
8799  *)
8800     ;;
8801 esac
14136  
14137  
14138  
14139  
14140  
14141  
8808
8809
8810
8811
8812
8813
8814
8815
8816
8817
8818
8819
8820          ac_config_headers="$ac_config_headers src/config.h"
8821
14142                                          ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14143  
14144  
# Line 9184 | 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 9247 | 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 9441 | 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
9444 s,@PROGNAME@,$PROGNAME,;t t
9445 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 9451 | 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
9467 < s,@F90FLAGS@,$F90FLAGS,;t t
9468 < s,@ac_ct_F90@,$ac_ct_F90,;t t
9469 < s,@PREPFLAG@,$PREPFLAG,;t t
9470 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
9471 < s,@F90LIBS@,$F90LIBS,;t t
9472 < s,@F90_FUNC@,$F90_FUNC,;t t
9473 < s,@F90_FUNC_@,$F90_FUNC_,;t t
9474 < s,@MOD@,$MOD,;t t
9475 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
9476 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
9477 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
9478 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;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
9481 s,@LIBOBJS@,$LIBOBJS,;t t
9482 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
9483 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
9484 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
9489 s,@YACC@,$YACC,;t t
9490 s,@LEX@,$LEX,;t t
9491 s,@LEXLIB@,$LEXLIB,;t t
9492 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
9503 s,@CXXCPP@,$CXXCPP,;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
# Line 9519 | Line 14839 | s,@FFLAGS@,$FFLAGS,;t t
14839   s,@OOPSE@,$OOPSE,;t t
14840   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14841   s,@SUBDIRS@,$SUBDIRS,;t t
9522 s,@FFLAGS@,$FFLAGS,;t t
14842   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14843   CEOF
14844  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines