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 2027 by gezelter, Tue Feb 15 06:11:22 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 AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI SPRNG_LIB_DIR SPRNG_INC_DIR SPRNG_LIB USE_SPRNG MKL_LIBDIR MKL_LIB MKL_INC HAVE_MKL 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}
791   ac_cv_env_CPP_value=$CPP
792 + ac_env_CXXCPP_set=${CXXCPP+set}
793 + ac_env_CXXCPP_value=$CXXCPP
794 + ac_cv_env_CXXCPP_set=${CXXCPP+set}
795 + ac_cv_env_CXXCPP_value=$CXXCPP
796  
797   #
798   # Report the --help message.
# Line 797 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 858 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
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)
873  --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-sprng=<prefix>   compile with SPRNG installed in <prefix>
880 <                          [default=/usr/local]
881 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
890 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
891  
892   Some influential environment variables:
893 <  CC          C compiler command
894 <  CFLAGS      C compiler flags
893 >  CXX         C++ compiler command
894 >  CXXFLAGS    C++ compiler flags
895    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
896                nonstandard directory <lib dir>
897    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
898                headers in a nonstandard directory <include dir>
899 <  CXX         C++ compiler command
900 <  CXXFLAGS    C++ compiler flags
901 <  F90         Fortran 90 compiler command
902 <  F90FLAGS    Fortran 90 compiler flags
899 >  CC          C compiler command
900 >  CFLAGS      C compiler flags
901 >  FC          Fortran compiler command
902 >  FCFLAGS     Fortran compiler flags
903    CPP         C preprocessor
904 +  CXXCPP      C++ preprocessor
905  
906   Use these variables to override the choices made by `configure' or to help
907   it to find libraries and programs with nonstandard names/locations.
# Line 992 | 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 1006 | 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 1368 | 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 -*-
1372 < # Programming languages support.
1373 < # Copyright 2000, 2001
1374 < # Free Software Foundation, Inc.
1375 < #
1376 < # This program is free software; you can redistribute it and/or modify
1377 < # it under the terms of the GNU General Public License as published by
1378 < # the Free Software Foundation; either version 2, or (at your option)
1379 < # any later version.
1380 < #
1381 < # This program is distributed in the hope that it will be useful,
1382 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1383 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1384 < # GNU General Public License for more details.
1385 < #
1386 < # You should have received a copy of the GNU General Public License
1387 < # along with this program; if not, write to the Free Software
1388 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1389 < # 02111-1307, USA.
1390 < #
1391 < # As a special exception, the Free Software Foundation gives unlimited
1392 < # permission to copy, distribute and modify the configure scripts that
1393 < # are the output of Autoconf.  You need not follow the terms of the GNU
1394 < # General Public License when using or distributing such scripts, even
1395 < # though portions of the text of Autoconf appear in them.  The GNU
1396 < # General Public License (GPL) does govern all other use of the material
1397 < # that constitutes the Autoconf program.
1398 < #
1399 < # Certain portions of the Autoconf source text are designed to be copied
1400 < # (in certain cases, depending on the input) into the output of
1401 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1402 < # source text consists of comments plus executable code that decides which
1403 < # of the data portions to output in any given case.  We call these
1404 < # comments and executable code the "non-data" portions.  Autoconf never
1405 < # copies any of the non-data portions into its output.
1406 < #
1407 < # This special exception to the GPL applies to versions of Autoconf
1408 < # released by the Free Software Foundation.  When you make and
1409 < # distribute a modified version of Autoconf, you may extend this special
1410 < # exception to the GPL to apply to your modified version as well, *unless*
1411 < # your modified version has the potential to copy into its output some
1412 < # of the text that was the non-data portion of the version that you started
1413 < # with.  (In other words, unless your change moves or copies text from
1414 < # the non-data portions to the data portions.)  If your modification has
1415 < # such potential, you must delete any notice of this special exception
1416 < # to the GPL from your modified version.
1417 < #
1418 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1419 < # many others).
1381 >          ac_config_headers="$ac_config_headers src/config.h"
1382  
1383  
1422 # Table of Contents:
1423 #
1424 # 1. Language selection
1425 #    and routines to produce programs in a given language.
1426 #  a. Fortran 77 (to be moved from aclang.m4)
1427 #  b. Fortran 90
1428 #  c. Fortran 95
1429 #
1430 # 2. Producing 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 # 3. Looking for a compiler
1436 #    And possibly the associated preprocessor.
1437 #  a. Fortran 77 (to be moved from aclang.m4)
1438 #  b. Fortran 90
1439 #  c. Fortran 95
1440 #
1441 # 4. Compilers' characteristics.
1442 #  a. Fortran 77 (to be moved from aclang.m4)
1443 #  b. Fortran 90
1444 #  c. Fortran 95
1384  
1446 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1447 # ---------------------------------------------------------------------------
1448 #
1449 # Processing the elements of a list is tedious in shell programming,
1450 # as lists tend to be implemented as space delimited strings.
1451 #
1452 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1453 # if ELEMENT is a member of LIST, otherwise it executes
1454 # ACTION-IF-NOT-FOUND.
1455 # _AC_LIST_MEMBER_IF
1385  
1386  
1387  
1459 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1460 # -------------------------------------------------
1461 #
1462 # Specifying options to the compiler (whether it be the C, C++ or
1463 # Fortran 77 compiler) that are meant for the linker is compiler
1464 # dependent.  This macro lets you give options to the compiler that
1465 # are meant for the linker in a portable, compiler-independent way.
1466 #
1467 # This macro take two arguments, a list of linker options that the
1468 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1469 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1470 # appended to the shell variable in a compiler-dependent way.
1471 #
1472 # For example, if the selected language is C, then this:
1473 #
1474 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1475 #
1476 # will expand into this if the selected C compiler is gcc:
1477 #
1478 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1479 #
1480 # otherwise, it will expand into this:
1481 #
1482 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1483 #
1484 # You are encouraged to add support for compilers that this macro
1485 # doesn't currently support.
1486 # FIXME: Get rid of this macro.
1487 # _AC_LINKER_OPTION
1388  
1389  
1390  
1491 ## ----------------------- ##
1492 ## 1. Language selection.  ##
1493 ## ----------------------- ##
1391  
1495 # ----------------------------- #
1496 # 1b. The Fortran 90 language.  #
1497 # ----------------------------- #
1392  
1499 # AC_LANG(Fortran 90)
1500 # -------------------
1393  
1394  
1395  
1504 # _AC_LANG_ABBREV(Fortran 90)
1505 # ---------------------------
1396  
1397  
1398  
1509 # ----------------------------- #
1510 # 1c. The Fortran 95 language.  #
1511 # ----------------------------- #
1399  
1513 # AC_LANG(Fortran 95)
1514 # -------------------
1400  
1401  
1402  
1518 # _AC_LANG_ABBREV(Fortran 95)
1519 # ---------------------------
1403  
1404  
1405  
1523 ## ---------------------- ##
1524 ## 2.Producing programs.  ##
1525 ## ---------------------- ##
1406  
1527 # ------------------------ #
1528 # 2b. Fortran 90 sources.  #
1529 # ------------------------ #
1407  
1531 # AC_LANG_SOURCE(Fortran 90)(BODY)
1532 # --------------------------------
1408  
1409  
1410  
1536 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1537 # -----------------------------------------------
1411  
1412  
1540 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1541 # --------------------------------------------
1413  
1414  
1415  
1545 # ------------------------ #
1546 # 2c. Fortran 95 sources.  #
1547 # ------------------------ #
1416  
1549 # AC_LANG_SOURCE(Fortran 95)(BODY)
1550 # --------------------------------
1417  
1418  
1553 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1554 # -----------------------------------------------
1419  
1556
1557 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1558 # --------------------------------------------
1559
1560
1561
1562 ## -------------------------------------------- ##
1563 ## 3. Looking for Compilers and Preprocessors.  ##
1564 ## -------------------------------------------- ##
1565
1566 # ----------------------------- #
1567 # 3b. The Fortran 90 compiler.  #
1568 # ----------------------------- #
1569
1570
1571 # AC_LANG_PREPROC(Fortran 90)
1572 # ---------------------------
1573 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1420  
1421  
1422  
1577 # AC_LANG_COMPILER(Fortran 90)
1578 # ----------------------------
1579 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1580 # AC_REQUIRE'able.
1423  
1424  
1425  
1584 # AC_PROG_F90([COMPILERS...])
1585 # ---------------------------
1586 # COMPILERS is a space separated list of Fortran 90 compilers to search
1587 # for.
1426   #
1589 # Compilers are ordered by
1590 #  1. F90, F95
1591 #  2. Good/tested native compilers, bad/untested native compilers
1427   #
1593 # pgf90 is the Portland Group F90 compilers.
1594 # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1595 # lf95 is the Lahey-Fujitsu compiler.
1596 # epcf90 is the "Edinburgh Portable Compiler" F90.
1597 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1598 # AC_PROG_F90
1599
1600
1601 # ----------------------------- #
1602 # 3c. The Fortran 95 compiler.  #
1603 # ----------------------------- #
1604
1605
1606 # AC_LANG_PREPROC(Fortran 95)
1607 # ---------------------------
1608 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1609
1610
1611
1612 # AC_LANG_COMPILER(Fortran 95)
1613 # ----------------------------
1614 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1615 # AC_REQUIRE'able.
1616
1617
1618
1619 # AC_PROG_F95([COMPILERS...])
1620 # ---------------------------
1621 # COMPILERS is a space separated list of Fortran 95 compilers to search
1622 # for.
1428   #
1624 # Compilers are ordered by
1625 #  1. Good/tested native compilers, bad/untested native compilers
1626 #
1627 # xlf95 is the IBM (AIX) F95 compiler.
1628 # lf95 is the Lahey-Fujitsu compiler.
1629 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1630 # AC_PROG_F95
1429  
1430  
1633 ## ------------------------------- ##
1634 ## 4. Compilers' characteristics.  ##
1635 ## ------------------------------- ##
1431  
1432  
1638 # ---------------------------------------- #
1639 # 4b. Fortan 90 compiler characteristics.  #
1640 # ---------------------------------------- #
1433  
1434 <
1435 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1644 < # -------------------------------------------------
1645 < # Link a trivial Fortran program, compiling with a verbose output FLAG
1646 < # (which default value, $ac_cv_prog_f90_v, is computed by
1647 < # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1648 < # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1649 < # so that any link flags that are echoed by the compiler appear as
1650 < # space-separated items.
1651 < # _AC_PROG_F90_V_OUTPUT
1652 <
1653 <
1654 < # _AC_PROG_F90_V
1655 < # --------------
1434 > # AC_F90_MODULE_NAMES
1435 > # -------------------
1436   #
1437 < # Determine the flag that causes the Fortran 90 compiler to print
1658 < # information of library and object files (normally -v)
1659 < # Needed for AC_F90_LIBRARY_FLAGS
1660 < # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1661 < # _AC_PROG_F90_V
1662 <
1663 <
1664 < # AC_F90_LIBRARY_LDFLAGS
1665 < # ----------------------
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
1668 < # intrinsic and run-time libraries that are required to successfully
1669 < # link a Fortran 90 program or shared library.  The output variable
1670 < # F90LIBS is set to these flags.
1671 < #
1672 < # This macro is intended to be used in those situations when it is
1673 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1674 < # program or shared library.
1675 < #
1676 < # For example, if object files from a C++ and Fortran 90 compiler must
1677 < # be linked together, then the C++ compiler/linker must be used for
1678 < # linking (since special C++-ish things need to happen at link time
1679 < # like calling global constructors, instantiating templates, enabling
1680 < # exception support, etc.).
1681 < #
1682 < # However, the Fortran 90 intrinsic and run-time libraries must be
1683 < # linked in as well, but the C++ compiler/linker doesn't know how to
1684 < # add these Fortran 90 libraries.  Hence, the macro
1685 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1686 < # libraries.
1687 < #
1688 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1689 < # AC_F90_LIBRARY_LDFLAGS
1439 > # AC_F90_MODULE_NAMES
1440  
1441  
1692 # _AC_F90_NAME_MANGLING
1693 # ---------------------
1694 # Test for the name mangling scheme used by the Fortran 90 compiler.
1695 #
1696 # Sets ac_cv_f90_mangling. The value contains three fields, separated
1697 # by commas:
1698 #
1699 # lower case / upper case:
1700 #    case translation of the Fortan 90 symbols
1701 # underscore / no underscore:
1702 #    whether the compiler appends "_" to symbol names
1703 # extra underscore / no extra underscore:
1704 #    whether the compiler appends an extra "_" to symbol names already
1705 #    containing at least one underscore
1706 #
1707 # _AC_F90_NAME_MANGLING
1442  
1709 # The replacement is empty.
1710
1711
1712
1713 # AC_F90_WRAPPERS
1714 # ---------------
1715 # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1716 # properly mangle the names of C identifiers, and C identifiers with
1717 # underscores, respectively, so that they match the name mangling
1718 # scheme used by the Fortran 90 compiler.
1719 # AC_F90_WRAPPERS
1443  
1444  
1722 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1723 # ------------------------------------
1724 # For a Fortran subroutine of given NAME, define a shell variable
1725 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1726 # argument is not supplied, it defaults to NAME.
1727 # AC_F90_FUNC
1445  
1446  
1730 # ---------------------------------------- #
1731 # 4c. Fortan 95 compiler characteristics.  #
1732 # ---------------------------------------- #
1447  
1448  
1735 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1736 # -------------------------------------------------
1737 # Link a trivial Fortran program, compiling with a verbose output FLAG
1738 # (which default value, $ac_cv_prog_f95_v, is computed by
1739 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1740 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1741 # so that any link flags that are echoed by the compiler appear as
1742 # space-separated items.
1743 # _AC_PROG_F95_V_OUTPUT
1449  
1450  
1746 # _AC_PROG_F95_V
1747 # --------------
1748 #
1749 # Determine the flag that causes the Fortran 95 compiler to print
1750 # information of library and object files (normally -v)
1751 # Needed for AC_F95_LIBRARY_FLAGS
1752 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1753 # _AC_PROG_F95_V
1451  
1452  
1756 # AC_F95_LIBRARY_LDFLAGS
1757 # ----------------------
1758 #
1759 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1760 # intrinsic and run-time libraries that are required to successfully
1761 # link a Fortran 95 program or shared library.  The output variable
1762 # F95LIBS is set to these flags.
1763 #
1764 # This macro is intended to be used in those situations when it is
1765 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1766 # program or shared library.
1767 #
1768 # For example, if object files from a C++ and Fortran 95 compiler must
1769 # be linked together, then the C++ compiler/linker must be used for
1770 # linking (since special C++-ish things need to happen at link time
1771 # like calling global constructors, instantiating templates, enabling
1772 # exception support, etc.).
1773 #
1774 # However, the Fortran 95 intrinsic and run-time libraries must be
1775 # linked in as well, but the C++ compiler/linker doesn't know how to
1776 # add these Fortran 95 libraries.  Hence, the macro
1777 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1778 # libraries.
1779 #
1780 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1781 # AC_F95_LIBRARY_LDFLAGS
1453  
1454  
1784 # _AC_F95_NAME_MANGLING
1785 # ---------------------
1786 # Test for the name mangling scheme used by the Fortran 95 compiler.
1787 #
1788 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1789 # by commas:
1790 #
1791 # lower case / upper case:
1792 #    case translation of the Fortan 95 symbols
1793 # underscore / no underscore:
1794 #    whether the compiler appends "_" to symbol names
1795 # extra underscore / no extra underscore:
1796 #    whether the compiler appends an extra "_" to symbol names already
1797 #    containing at least one underscore
1798 #
1799 # _AC_F95_NAME_MANGLING
1455  
1801 # The replacement is empty.
1456  
1457  
1458  
1805 # AC_F95_WRAPPERS
1806 # ---------------
1807 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1808 # properly mangle the names of C identifiers, and C identifiers with
1809 # underscores, respectively, so that they match the name mangling
1810 # scheme used by the Fortran 95 compiler.
1811 # AC_F95_WRAPPERS
1459  
1460  
1814 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1815 # ------------------------------------
1816 # For a Fortran subroutine of given NAME, define a shell variable
1817 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1818 # argument is not supplied, it defaults to NAME.
1819 # AC_F95_FUNC
1461  
1821 # AC_F90_MODULE_NAMES
1822 # -------------------
1823 #
1824 # Figure out how the Fortran 90 compiler constructs module file names
1825 #
1826 # AC_F90_MODULE_NAMES
1462  
1463  
1464  
# Line 1883 | Line 1518 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1518  
1519  
1520  
1886 # set program name
1887 PROGNAME="oopse"
1521  
1522  
1890 # there are two ways to do debugging.  One with the --enable-debug flag
1891 # and one using the DEBUG environment variable
1523  
1893 debug=0
1894 # Check whether --enable-debug or --disable-debug was given.
1895 if test "${enable_debug+set}" = set; then
1896  enableval="$enable_debug"
1897  debug=1
1898 fi;
1899 if test "${DEBUG}"; then
1524  
1901 cat >>confdefs.h <<\_ACEOF
1902 #define debug 1
1903 _ACEOF
1525  
1905  msg="$msg, debug mode"
1906 fi
1526  
1527  
1528   # who am i
# Line 1964 | 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 1989 | 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 1998 | 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 2031 | 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 2040 | 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  
2059 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2060 See \`config.log' for more details." >&5
2061 echo "$as_me: error: no acceptable C compiler found in \$PATH
2062 See \`config.log' for more details." >&2;}
2063   { (exit 1); exit 1; }; }
2064
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 2102 | 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 2146 | 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 2159 | 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 2175 | 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 2283 | 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 2677 | 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'
2684 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2685 < 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 2703 | 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 2712 | 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 2745 | 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 2754 | 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
2768 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 2790 | 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.  */
2801 < _ACEOF
2802 < cat confdefs.h >>conftest.$ac_ext
2803 < cat >>conftest.$ac_ext <<_ACEOF
2804 < /* end confdefs.h.  */
2805 <
2806 < int
2807 < main ()
2808 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2814 <  return 0;
2815 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2823 | 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 2844 | 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
2864 < cat confdefs.h >>conftest.$ac_ext
2865 < cat >>conftest.$ac_ext <<_ACEOF
2866 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2869 < main ()
2870 < {
2871 <
2872 <  ;
2873 <  return 0;
2874 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2882 | 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 2895 | 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);
2944 <  ;
2945 <  return 0;
2946 < }
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
2950 <  (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
2967 <  ac_status=$?
2968 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2969 <  (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
2985 < int
2986 < main ()
2987 < {
2988 < exit (42);
2989 <  ;
2990 <  return 0;
2991 < }
3007 > #include <ac_nonexistent.h>
3008   _ACEOF
3009 < rm -f conftest.$ac_objext
3010 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2995 <  (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 3033 | 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
3043 <    echo "$as_me:$LINENO: result: yes" >&5
3179 >
3180 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3181 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3182 > LN_S=$as_ln_s
3183 > if test "$LN_S" = "ln -s"; then
3184 >  echo "$as_me:$LINENO: result: yes" >&5
3185   echo "${ECHO_T}yes" >&6
3186 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3187 <  else
3188 <    echo "$as_me:$LINENO: result: no" >&5
3189 < echo "${ECHO_T}no" >&6
3190 <  fi
3191 <  rm -f conftest*
3192 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3193 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3194 <  echo 'void f(){}' > conftest.cc
3195 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3196 <    echo "$as_me:$LINENO: result: yes" >&5
3186 > else
3187 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3188 > echo "${ECHO_T}no, using $LN_S" >&6
3189 > fi
3190 >
3191 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3192 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3193 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3194 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3196 > else
3197 >  cat >conftest.make <<\_ACEOF
3198 > all:
3199 >        @echo 'ac_maketemp="$(MAKE)"'
3200 > _ACEOF
3201 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3202 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3203 > if test -n "$ac_maketemp"; then
3204 >  eval ac_cv_prog_make_${ac_make}_set=yes
3205 > else
3206 >  eval ac_cv_prog_make_${ac_make}_set=no
3207 > fi
3208 > rm -f conftest.make
3209 > fi
3210 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3211 >  echo "$as_me:$LINENO: result: yes" >&5
3212   echo "${ECHO_T}yes" >&6
3213 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3213 >  SET_MAKE=
3214 > else
3215 >  echo "$as_me:$LINENO: result: no" >&5
3216   echo "${ECHO_T}no" >&6
3217 +  SET_MAKE="MAKE=${MAKE-make}"
3218 + fi
3219 +
3220 + if test -n "$ac_tool_prefix"; then
3221 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3222 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3223 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3226 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3227 + else
3228 +  if test -n "$RANLIB"; then
3229 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3230 + else
3231 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 + for as_dir in $PATH
3233 + do
3234 +  IFS=$as_save_IFS
3235 +  test -z "$as_dir" && as_dir=.
3236 +  for ac_exec_ext in '' $ac_executable_extensions; do
3237 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3239 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240 +    break 2
3241    fi
3242 <  rm -f conftest*
3243 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3244 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3245 <  echo 'void f(){}' > conftest.cc
3246 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3247 <    echo "$as_me:$LINENO: result: yes" >&5
3248 < echo "${ECHO_T}yes" >&6
3249 <    OOPSE_TEMPLATE_FLAGS="-pto"
3250 <  else
3251 <    echo "$as_me:$LINENO: result: no" >&5
3242 > done
3243 > done
3244 >
3245 > fi
3246 > fi
3247 > RANLIB=$ac_cv_prog_RANLIB
3248 > if test -n "$RANLIB"; then
3249 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3250 > echo "${ECHO_T}$RANLIB" >&6
3251 > else
3252 >  echo "$as_me:$LINENO: result: no" >&5
3253   echo "${ECHO_T}no" >&6
3254 + fi
3255 +
3256 + fi
3257 + if test -z "$ac_cv_prog_RANLIB"; then
3258 +  ac_ct_RANLIB=$RANLIB
3259 +  # Extract the first word of "ranlib", so it can be a program name with args.
3260 + set dummy ranlib; ac_word=$2
3261 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3262 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3263 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3264 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3265 + else
3266 +  if test -n "$ac_ct_RANLIB"; then
3267 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3268 + else
3269 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3270 + for as_dir in $PATH
3271 + do
3272 +  IFS=$as_save_IFS
3273 +  test -z "$as_dir" && as_dir=.
3274 +  for ac_exec_ext in '' $ac_executable_extensions; do
3275 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3276 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3277 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3278 +    break 2
3279    fi
3280 <  rm -f conftest*
3281 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3076 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3077 <  echo 'void f(){}' > conftest.cc
3078 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3079 <    echo "$as_me:$LINENO: result: yes" >&5
3080 < echo "${ECHO_T}yes" >&6
3280 > done
3281 > done
3282  
3283 +  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284 + fi
3285 + fi
3286 + ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3287 + if test -n "$ac_ct_RANLIB"; then
3288 +  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3289 + echo "${ECHO_T}$ac_ct_RANLIB" >&6
3290 + else
3291 +  echo "$as_me:$LINENO: result: no" >&5
3292 + echo "${ECHO_T}no" >&6
3293 + fi
3294  
3295 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3296 <  else
3297 <    echo "$as_me:$LINENO: result: no" >&5
3295 >  RANLIB=$ac_ct_RANLIB
3296 > else
3297 >  RANLIB="$ac_cv_prog_RANLIB"
3298 > fi
3299 >
3300 >
3301 >   # Extract the first word of "perl", so it can be a program name with args.
3302 > set dummy perl; ac_word=$2
3303 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3304 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3305 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3307 > else
3308 >  case $PERLINTERP in
3309 >  [\\/]* | ?:[\\/]*)
3310 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3311 >  ;;
3312 >  *)
3313 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3314 > for as_dir in $PATH
3315 > do
3316 >  IFS=$as_save_IFS
3317 >  test -z "$as_dir" && as_dir=.
3318 >  for ac_exec_ext in '' $ac_executable_extensions; do
3319 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3320 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3321 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3322 >    break 2
3323 >  fi
3324 > done
3325 > done
3326 >
3327 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3328 >  ;;
3329 > esac
3330 > fi
3331 > PERLINTERP=$ac_cv_path_PERLINTERP
3332 >
3333 > if test -n "$PERLINTERP"; then
3334 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3335 > echo "${ECHO_T}$PERLINTERP" >&6
3336 > else
3337 >  echo "$as_me:$LINENO: result: no" >&5
3338   echo "${ECHO_T}no" >&6
3339 + fi
3340 +
3341 +   ac_cv_path_perlinterp="$PERLINTERP"
3342 +   _sHpB='#!'
3343 +
3344 +
3345 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3346 + if test "${with_perl_shebang+set}" = set; then
3347 +  withval="$with_perl_shebang"
3348 +  opt_perl_shebang="$withval"
3349 + else
3350 +                opt_perl_shebang="not_set"
3351 + fi;
3352 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3353 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3354 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3356 + else
3357 +   case "$opt_perl_shebang" in
3358 +                      not_set  ) ax_cv_opt_perl_shebang=''
3359 +                               ;;
3360 +                         *     )
3361 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3362 +                    esac
3363 +
3364 + fi
3365 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3366 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3367 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3368 +     then
3369 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3370 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3371 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3372 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3373 +
3374 + # Automatic detection of sharpbang formula starts here
3375 +     else
3376 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3377 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3378 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3379 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3380 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3381 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3382 + else
3383 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3384 +        if test "x$_somian_kspb_perl" == x
3385 +          then _somian_ksbp_warn_empty='durnit'
3386 +          else
3387 +          case "A$_somian_kspb_perl" in
3388 +                 A#!*perl* )
3389 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3390 +                        ;;
3391 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3392 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3393 +          esac
3394 +        fi
3395 +
3396 + fi
3397 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3398 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3399 + # The above prints Checking ... result message to user.
3400 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3401 +
3402 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3403 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3404 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3405 +    fi
3406 + # Inform user after printing result value
3407 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3408 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3409 + echo "$as_me: Maybe Not good -" >&6;}
3410 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3411 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3412 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3413 + echo "$as_me: OK Good result - " >&6;}
3414 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3415 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3416 +    fi
3417    fi
3418 +
3419 + # Find a good install program.  We prefer a C program (faster),
3420 + # so one script is as good as another.  But avoid the broken or
3421 + # incompatible versions:
3422 + # SysV /etc/install, /usr/sbin/install
3423 + # SunOS /usr/etc/install
3424 + # IRIX /sbin/install
3425 + # AIX /bin/install
3426 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3427 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3428 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3429 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3430 + # OS/2's system install, which has a completely different semantic
3431 + # ./install, which can be erroneously created by make from ./install.sh.
3432 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3433 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3434 + if test -z "$INSTALL"; then
3435 + if test "${ac_cv_path_install+set}" = set; then
3436 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3437 + else
3438 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3439 + for as_dir in $PATH
3440 + do
3441 +  IFS=$as_save_IFS
3442 +  test -z "$as_dir" && as_dir=.
3443 +  # Account for people who put trailing slashes in PATH elements.
3444 + case $as_dir/ in
3445 +  ./ | .// | /cC/* | \
3446 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3447 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3448 +  /usr/ucb/* ) ;;
3449 +  *)
3450 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3451 +    # Don't use installbsd from OSF since it installs stuff as root
3452 +    # by default.
3453 +    for ac_prog in ginstall scoinst install; do
3454 +      for ac_exec_ext in '' $ac_executable_extensions; do
3455 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3456 +          if test $ac_prog = install &&
3457 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3458 +            # AIX install.  It has an incompatible calling convention.
3459 +            :
3460 +          elif test $ac_prog = install &&
3461 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3462 +            # program-specific install script used by HP pwplus--don't use.
3463 +            :
3464 +          else
3465 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3466 +            break 3
3467 +          fi
3468 +        fi
3469 +      done
3470 +    done
3471 +    ;;
3472 + esac
3473 + done
3474 +
3475 +
3476   fi
3477 +  if test "${ac_cv_path_install+set}" = set; then
3478 +    INSTALL=$ac_cv_path_install
3479 +  else
3480 +    # As a last resort, use the slow shell script.  We don't cache a
3481 +    # path for INSTALL within a source directory, because that will
3482 +    # break other packages using the cache if that directory is
3483 +    # removed, or if the path is relative.
3484 +    INSTALL=$ac_install_sh
3485 +  fi
3486 + fi
3487 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3488 + echo "${ECHO_T}$INSTALL" >&6
3489  
3490 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3491 + # It thinks the first close brace ends the variable substitution.
3492 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3493  
3494 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3495  
3496 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3497  
3498 < ac_ext=f90
3499 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3500 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3501 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3502 < if test -n "$ac_tool_prefix"; then
3503 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3504 <  do
3100 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3101 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3498 > case "x$INSTALL" in
3499 >   x/*) ;;
3500 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3501 > esac
3502 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3503 > # Extract the first word of "ar", so it can be a program name with args.
3504 > set dummy ar; ac_word=$2
3505   echo "$as_me:$LINENO: checking for $ac_word" >&5
3506   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3507 < if test "${ac_cv_prog_F90+set}" = set; then
3507 > if test "${ac_cv_prog_AR+set}" = set; then
3508    echo $ECHO_N "(cached) $ECHO_C" >&6
3509   else
3510 <  if test -n "$F90"; then
3511 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3510 >  if test -n "$AR"; then
3511 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3512   else
3513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3514   for as_dir in $PATH
# Line 3114 | Line 3517 | do
3517    test -z "$as_dir" && as_dir=.
3518    for ac_exec_ext in '' $ac_executable_extensions; do
3519    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3520 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3520 >    ac_cv_prog_AR="ar"
3521      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3522      break 2
3523    fi
3524   done
3525   done
3526  
3527 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3528   fi
3529   fi
3530 < F90=$ac_cv_prog_F90
3531 < if test -n "$F90"; then
3532 <  echo "$as_me:$LINENO: result: $F90" >&5
3533 < echo "${ECHO_T}$F90" >&6
3530 > AR=$ac_cv_prog_AR
3531 > if test -n "$AR"; then
3532 >  echo "$as_me:$LINENO: result: $AR" >&5
3533 > echo "${ECHO_T}$AR" >&6
3534   else
3535    echo "$as_me:$LINENO: result: no" >&5
3536   echo "${ECHO_T}no" >&6
3537   fi
3538  
3539 <    test -n "$F90" && break
3540 <  done
3539 > if test "$AR" = "NONE"; then
3540 >  cat >confcache <<\_ACEOF
3541 > # This file is a shell script that caches the results of configure
3542 > # tests run on this system so they can be shared between configure
3543 > # scripts and configure runs, see configure's option --config-cache.
3544 > # It is not useful on other systems.  If it contains results you don't
3545 > # want to keep, you may remove or edit it.
3546 > #
3547 > # config.status only pays attention to the cache file if you give it
3548 > # the --recheck option to rerun configure.
3549 > #
3550 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3551 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3552 > # following values.
3553 >
3554 > _ACEOF
3555 >
3556 > # The following way of writing the cache mishandles newlines in values,
3557 > # but we know of no workaround that is simple, portable, and efficient.
3558 > # So, don't put newlines in cache variables' values.
3559 > # Ultrix sh set writes to stderr and can't be redirected directly,
3560 > # and sets the high bit in the cache file unless we assign to the vars.
3561 > {
3562 >  (set) 2>&1 |
3563 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3564 >    *ac_space=\ *)
3565 >      # `set' does not quote correctly, so add quotes (double-quote
3566 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3567 >      sed -n \
3568 >        "s/'/'\\\\''/g;
3569 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3570 >      ;;
3571 >    *)
3572 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3573 >      sed -n \
3574 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3575 >      ;;
3576 >    esac;
3577 > } |
3578 >  sed '
3579 >     t clear
3580 >     : clear
3581 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3582 >     t end
3583 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3584 >     : end' >>confcache
3585 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3586 >  if test -w $cache_file; then
3587 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3588 >    cat confcache >$cache_file
3589 >  else
3590 >    echo "not updating unwritable cache $cache_file"
3591 >  fi
3592   fi
3593 < if test -z "$F90"; then
3594 <  ac_ct_F90=$F90
3595 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3596 < do
3597 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3143 < set dummy $ac_prog; ac_word=$2
3593 > rm -f confcache
3594 >  exit 1
3595 > fi
3596 > # Extract the first word of "ps", so it can be a program name with args.
3597 > set dummy ps; ac_word=$2
3598   echo "$as_me:$LINENO: checking for $ac_word" >&5
3599   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3600 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3600 > if test "${ac_cv_path_PS+set}" = set; then
3601    echo $ECHO_N "(cached) $ECHO_C" >&6
3602   else
3603 <  if test -n "$ac_ct_F90"; then
3604 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3605 < else
3606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3603 >  case $PS in
3604 >  [\\/]* | ?:[\\/]*)
3605 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3606 >  ;;
3607 >  *)
3608 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3609   for as_dir in $PATH
3610   do
3611    IFS=$as_save_IFS
3612    test -z "$as_dir" && as_dir=.
3613    for ac_exec_ext in '' $ac_executable_extensions; do
3614    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3615 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3615 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3616      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3617      break 2
3618    fi
3619   done
3620   done
3621  
3622 +  ;;
3623 + esac
3624   fi
3625 < fi
3626 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3627 < if test -n "$ac_ct_F90"; then
3628 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3629 < echo "${ECHO_T}$ac_ct_F90" >&6
3625 > PS=$ac_cv_path_PS
3626 >
3627 > if test -n "$PS"; then
3628 >  echo "$as_me:$LINENO: result: $PS" >&5
3629 > echo "${ECHO_T}$PS" >&6
3630   else
3631    echo "$as_me:$LINENO: result: no" >&5
3632   echo "${ECHO_T}no" >&6
3633   fi
3634  
3635 <  test -n "$ac_ct_F90" && break
3636 < done
3635 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3636 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3637 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3639 > else
3640  
3641 <  F90=$ac_ct_F90
3641 >        if $PS ax -o rss > /dev/null 2>&1; then
3642 >                ac_cv_prog_ps_ax=yes
3643 >        else
3644 >                ac_cv_prog_ps_ax=no
3645 >        fi
3646 >        if $PS -ef -o rss > /dev/null 2>&1; then
3647 >                ac_cv_prog_ps_ef=yes
3648 >        else
3649 >                ac_cv_prog_ps_ef=no
3650 >        fi
3651 >        if test "$ac_cv_prog_ps_ax" = yes; then
3652 >                ac_cv_prog_ps_syntax=BSD
3653 >        else
3654 >                if test "$ac_cv_prog_ps_ef" = yes; then
3655 >                        ac_cv_prog_ps_syntax=POSIX
3656 >                else
3657 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3658 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3659 >   { (exit 1); exit 1; }; }
3660 >                fi
3661 >        fi
3662 >
3663   fi
3664 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3665 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3666  
3667 + cat >>confdefs.h <<_ACEOF
3668 + #define PSCOMMAND $PS
3669 + _ACEOF
3670  
3671 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3185 < # input file.
3186 < ac_save_ext=$ac_ext
3187 < ac_ext=F90
3188 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3189 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3190 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3191 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3192 < else
3193 <  cat >conftest.$ac_ext <<_ACEOF
3671 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3672  
3673 < program main
3673 > cat >>confdefs.h <<\_ACEOF
3674 > #define PSTYPE_IS_BSD 1
3675 > _ACEOF
3676  
3677 < #ifndef __GNUC__
3678 <       choke me
3199 < #endif
3677 > else
3678 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679  
3680 < end program main
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
# Line 3210 | 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 3223 | 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  
3231 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 3255 | 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 3277 | 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
3297 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3301
3302 end program main
3303
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3311 | 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 3333 | 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'
3342 < 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 3366 | 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 3388 | 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
3408 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3416
3417 end program main
3418
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3426 | 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 3448 | 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'
3457 < 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  
3460
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3471 | 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 <
3481 < ac_ext=f90
3482 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3483 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3484 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3485 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3486 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3487 < 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
3492 <
3493 < program main
3494 <
3495 <
3496 < end program main
3497 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3505 | 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 3518 | 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'
3526 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3527 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3530 <
3531 < program main
3532 <
3533 <
3534 < end program main
3535 <
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:3545: \"$ac_link\") >&5
3546 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3547 < echo "$ac_f90_v_output" >&5
3548 < 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 3587 | Line 4088 | echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4088   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089  
4090   fi
4091 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4092 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4093 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4094 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4095 < if test "${ac_cv_flibs+set}" = set; then
4091 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4092 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4093 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4094 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4095 > if test "${ac_cv_fc_libs+set}" = set; then
4096    echo $ECHO_N "(cached) $ECHO_C" >&6
4097   else
4098 <  if test "x$F90LIBS" != "x"; then
4099 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4098 >  if test "x$FCLIBS" != "x"; then
4099 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4100   else
4101  
3601 ac_ext=f90
3602 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3603 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3604 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3605
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3609 <
3610 <
3611 < end program main
3612 <
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:3622: \"$ac_link\") >&5
3623 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3624 < echo "$ac_f90_v_output" >&5
3625 < 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
3642 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3643 < 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 3664 | 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 3682 | 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"
3707
4209                  shift; shift
4210                  set X $ac_arg "$@"
4211                  ;;
# Line 3713 | 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 3724 | 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 3741 | 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 3756 | 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 &&
3762
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  
3779 ac_ext=f90
3780 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3781 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3782 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 3808 | 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 3821 | 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
3831
3832  ac_save_LIBS=$LIBS
3833  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3834
4508    ac_success=no
4509    for ac_foobar in foobar FOOBAR; do
4510      for ac_underscore in "" "_"; do
# Line 3850 | 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 3890 | 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 <
3910 <        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 3921 | 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 3960 | 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 +     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_f90_mangling="$ac_case case"
4666 >        ac_cv_fc_mangling="$ac_case case"
4667          if test -z "$ac_underscore"; then
4668 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4668 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4669          else
4670 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
3970 <
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"
3982 <
4681 >     ac_cv_fc_mangling="unknown"
4682    fi
4683  
4684    LIBS=$ac_save_LIBS
4685 <  ac_ext=f90
3987 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3988 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3989 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3990 <  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
3997 ac_ext=f90
3998 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3999 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4000 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 4102 | 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 4147 | 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 4155 | 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 4165 | 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 4173 | 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 4192 | 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 4222 | 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 4243 | 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 4359 | 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 4457 | 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
4465 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4466 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4467 < # On Suns, sometimes $CPP names a directory.
4468 < if test -n "$CPP" && test -d "$CPP"; then
4469 <  CPP=
4470 < fi
4471 < if test -z "$CPP"; then
4472 <  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
4478 <      ac_preproc_ok=false
4479 < for ac_c_preproc_warn_flag in '' yes
4480 < do
4481 <  # Use a header file that comes with gcc, so configuring glibc
4482 <  # with a fresh cross-compiler works.
4483 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4484 <  # <limits.h> exists even on freestanding compilers.
4485 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4486 <  # not just through cpp. "Syntax error" is here to catch this case.
4487 <  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
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=
# Line 4515 | Line 9714 | if test -z "$ac_cpp_err"; then
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
# Line 4544 | Line 10163 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
10167 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 4573 | Line 10192 | fi
10192   fi
10193  
10194      done
10195 <    ac_cv_prog_CPP=$CPP
10195 >    ac_cv_prog_CXXCPP=$CXXCPP
10196  
10197   fi
10198 <  CPP=$ac_cv_prog_CPP
10198 >  CXXCPP=$ac_cv_prog_CXXCPP
10199   else
10200 <  ac_cv_prog_CPP=$CPP
10200 >  ac_cv_prog_CXXCPP=$CXXCPP
10201   fi
10202 < echo "$as_me:$LINENO: result: $CPP" >&5
10203 < echo "${ECHO_T}$CPP" >&6
10202 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10203 > echo "${ECHO_T}$CXXCPP" >&6
10204   ac_preproc_ok=false
10205 < for ac_c_preproc_warn_flag in '' yes
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.
# Line 4613 | Line 10232 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
10236 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 4623 | Line 10242 | else
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 <  # Broken: fails on valid input.
10384 < continue
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_ext
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 <  # OK, works on sane cases.  Now check whether non-existent headers
10612 <  # can be detected and how.
10613 <  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 4651 | 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 4660 | 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.
4664 < 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.
4670 < ac_preproc_ok=:
4671 < 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
4682 < See \`config.log' for more details." >&5
4683 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4684 < See \`config.log' for more details." >&2;}
4685 <   { (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
4698 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4699 < else
4700 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4701 <    then ac_cv_prog_egrep='grep -E'
4702 <    else ac_cv_prog_egrep='egrep'
4703 <    fi
10701 > done
10702 >
10703 >
10704   fi
4705 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4706 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4707 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>
4723 < #include <string.h>
4724 < #include <float.h>
4725 <
4726 < int
4727 < main ()
4728 < {
4729 <
4730 <  ;
4731 <  return 0;
4732 < }
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 4740 | 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 4753 | 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>
4774 <
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 <
4807 < if test $ac_cv_header_stdc = yes; then
4808 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4809 <  if test "$cross_compiling" = yes; then
4810 <  :
4811 < else
4812 <  cat >conftest.$ac_ext <<_ACEOF
4813 < /* confdefs.h.  */
4814 < _ACEOF
4815 < cat confdefs.h >>conftest.$ac_ext
4816 < cat >>conftest.$ac_ext <<_ACEOF
4817 < /* end confdefs.h.  */
4818 < #include <ctype.h>
4819 < #if ((' ' & 0x0FF) == 0x020)
4820 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4821 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4822 < #else
4823 < # define ISLOWER(c) \
4824 <                   (('a' <= (c) && (c) <= 'i') \
4825 <                     || ('j' <= (c) && (c) <= 'r') \
4826 <                     || ('s' <= (c) && (c) <= 'z'))
4827 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4828 < #endif
10846 > if test $ac_cv_header_iomanip = yes; then
10847  
4830 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4831 int
4832 main ()
4833 {
4834  int i;
4835  for (i = 0; i < 256; i++)
4836    if (XOR (islower (i), ISLOWER (i))
4837        || toupper (i) != TOUPPER (i))
4838      exit(2);
4839  exit (0);
4840 }
4841 _ACEOF
4842 rm -f conftest$ac_exeext
4843 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4844  (eval $ac_link) 2>&5
4845  ac_status=$?
4846  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4847  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4848  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4849  (eval $ac_try) 2>&5
4850  ac_status=$?
4851  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4852  (exit $ac_status); }; }; then
4853  :
4854 else
4855  echo "$as_me: program exited with status $ac_status" >&5
4856 echo "$as_me: failed program was:" >&5
4857 sed 's/^/| /' conftest.$ac_ext >&5
10848  
4859 ( exit $ac_status )
4860 ac_cv_header_stdc=no
4861 fi
4862 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4863 fi
4864 fi
4865 fi
4866 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4867 echo "${ECHO_T}$ac_cv_header_stdc" >&6
4868 if test $ac_cv_header_stdc = yes; then
4869
10849   cat >>confdefs.h <<\_ACEOF
10850 < #define STDC_HEADERS 1
10850 > #define HAVE_IOMANIP 1
10851   _ACEOF
10852  
4874 fi
10853  
10854 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
10854 > else
10855  
10856  
10857 <
4880 <
4881 <
4882 <
4883 <
4884 <
4885 <
4886 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4887 <                  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
4902
10879   #include <$ac_header>
10880   _ACEOF
10881   rm -f conftest.$ac_objext
# Line 4911 | 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 4924 | 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 4945 | Line 11004 | done
11004   done
11005  
11006  
11007 + fi
11008  
11009  
11010  
11011  
11012 <
4953 <
4954 <
4955 <
4956 <
4957 < 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 4987 | 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 5031 | 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 5052 | 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 5106 | Line 11161 | done
11161  
11162  
11163  
11164 <
11165 <
11166 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
5112 < do
5113 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5114 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5115 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5116 < 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.  */
5125 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5126   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5127 #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.
5131 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5132 <    <limits.h> exists even on freestanding compilers.  */
5133 <
5134 < #ifdef __STDC__
5135 < # 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
5147 /* We use char because int might match the return type of a gcc2
5148   builtin and then its argument prototype would still apply.  */
5149 char $ac_func ();
5150 /* The GNU C library defines this for functions which it implements
5151    to always fail with ENOSYS.  Some functions are actually named
5152    something starting with __ and the normal name is an alias.  */
5153 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5154 choke me
5155 #else
5156 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  
5197 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 5237 | 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 5250 | 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  
11491 < echo "$as_me:$LINENO: result: no" >&5
11492 < echo "${ECHO_T}no" >&6
11491 > fi
11492 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11493 >    ac_ext=cc
11494 > ac_cpp='$CXXCPP $CPPFLAGS'
11495 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11496 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11497 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11498 >
11499 >
11500   fi
11501 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11502 + echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11503 +  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11504 +
11505 + cat >>confdefs.h <<\_ACEOF
11506 + #define HAVE_FSTREAM_ATTACH 1
11507 + _ACEOF
11508 +
11509 +  fi
11510 +
11511 +
11512 +
11513 +  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11514 + echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11515 + if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11516 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11517 + else
11518 +
11519 +    ac_cv_cxx_have_fstream_open=no
11520 +    ac_cv_cxx_fstream_open_prot=no
11521 +
11522 +
11523 +    ac_ext=cc
11524 + ac_cpp='$CXXCPP $CPPFLAGS'
11525 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11526 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11527 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11528 +
11529 +    # Try with 2 parameters
11530 +    cat >conftest.$ac_ext <<_ACEOF
11531 + /* confdefs.h.  */
11532 + _ACEOF
11533 + cat confdefs.h >>conftest.$ac_ext
11534 + cat >>conftest.$ac_ext <<_ACEOF
11535 + /* end confdefs.h.  */
11536 +
11537 + #ifdef HAVE_IOSTREAM
11538 + #include <fstream>
11539 + #else
11540 + #include <fstream.h>
11541 + #endif
11542 + #ifdef HAVE_STD_IOSTREAM
11543 + using namespace std;
11544 + #endif
11545 +
11546 + #ifdef FC_DUMMY_MAIN
11547 + #ifndef FC_DUMMY_MAIN_EQ_F77
11548 + #  ifdef __cplusplus
11549 +     extern "C"
11550 + #  endif
11551 +   int FC_DUMMY_MAIN() { return 1; }
11552 + #endif
11553 + #endif
11554 + int
11555 + main ()
11556 + {
11557 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11558 +  ;
11559 +  return 0;
11560 + }
11561 + _ACEOF
11562 + rm -f conftest.$ac_objext
11563 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11564 +  (eval $ac_compile) 2>conftest.er1
11565 +  ac_status=$?
11566 +  grep -v '^ *+' conftest.er1 >conftest.err
11567 +  rm -f conftest.er1
11568 +  cat conftest.err >&5
11569 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11570 +  (exit $ac_status); } &&
11571 +         { ac_try='test -z "$ac_cxx_werror_flag"
11572 +                         || test ! -s conftest.err'
11573 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11574 +  (eval $ac_try) 2>&5
11575 +  ac_status=$?
11576 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11577 +  (exit $ac_status); }; } &&
11578 +         { ac_try='test -s conftest.$ac_objext'
11579 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11580 +  (eval $ac_try) 2>&5
11581 +  ac_status=$?
11582 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11583 +  (exit $ac_status); }; }; then
11584 +  ac_cv_cxx_have_fstream_open=yes
11585 + else
11586 +  echo "$as_me: failed program was:" >&5
11587 + sed 's/^/| /' conftest.$ac_ext >&5
11588 +
11589 + fi
11590   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11591 +    # Try with mode parameter
11592 +    cat >conftest.$ac_ext <<_ACEOF
11593 + /* confdefs.h.  */
11594 + _ACEOF
11595 + cat confdefs.h >>conftest.$ac_ext
11596 + cat >>conftest.$ac_ext <<_ACEOF
11597 + /* end confdefs.h.  */
11598  
11599 <  # clean out junk possibly left behind by a previous configuration
11600 <  rm -f src/getopt.h
11601 <  # Check for getopt_long support
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 < for ac_header in getopt.h
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 5303 | 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 5347 | 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 5368 | 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 5419 | 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
5427 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5428 < 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 5434 | Line 11849 | cat >>conftest.$ac_ext <<_ACEOF
11849   cat confdefs.h >>conftest.$ac_ext
11850   cat >>conftest.$ac_ext <<_ACEOF
11851   /* end confdefs.h.  */
5437 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5438   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5439 #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__
5447 < # include <limits.h>
5448 < #else
5449 < # include <assert.h>
5450 < #endif
5451 <
5452 < #undef $ac_func
5453 <
5454 < /* Override any gcc2 internal prototype to avoid an error.  */
5455 < #ifdef __cplusplus
5456 < extern "C"
5457 < {
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
5459 /* We use char because int might match the return type of a gcc2
5460   builtin and then its argument prototype would still apply.  */
5461 char $ac_func ();
5462 /* The GNU C library defines this for functions which it implements
5463    to always fail with ENOSYS.  Some functions are actually named
5464    something starting with __ and the normal name is an alias.  */
5465 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5466 choke me
5467 #else
5468 char (*f) () = $ac_func;
11860   #endif
5470 #ifdef __cplusplus
5471 }
5472 #endif
5473
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  
5509 eval "$as_ac_var=no"
5510 fi
5511 rm -f conftest.err conftest.$ac_objext \
5512      conftest$ac_exeext conftest.$ac_ext
5513 fi
5514 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5515 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5516 if test `eval echo '${'$as_ac_var'}'` = yes; then
5517  cat >>confdefs.h <<_ACEOF
5518 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5519 _ACEOF
5520
5521 else
5522  # FreeBSD has a gnugetopt library for this
5523    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5524 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5525 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5526  echo $ECHO_N "(cached) $ECHO_C" >&6
5527 else
5528  ac_check_lib_save_LIBS=$LIBS
5529 LIBS="-lgnugetopt  $LIBS"
11896   cat >conftest.$ac_ext <<_ACEOF
11897   /* confdefs.h.  */
11898   _ACEOF
# Line 5534 | 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
5542 <   builtin and then its argument prototype would still apply.  */
5543 < 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 \
5582 <      conftest$ac_exeext conftest.$ac_ext
5583 < 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
5593 <  # use the GNU replacement
5594 <      case $LIBOBJS in
5595 <    "getopt.$ac_objext"   | \
5596 <  *" getopt.$ac_objext"   | \
5597 <    "getopt.$ac_objext "* | \
5598 <  *" getopt.$ac_objext "* ) ;;
5599 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5600 < esac
11960 > elif test $ac_cv_cpp_func = no; then
11961  
11962 <      case $LIBOBJS in
11963 <    "getopt1.$ac_objext"   | \
11964 <  *" getopt1.$ac_objext"   | \
5605 <    "getopt1.$ac_objext "* | \
5606 <  *" getopt1.$ac_objext "* ) ;;
5607 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5608 < esac
11962 > cat >>confdefs.h <<\_ACEOF
11963 > #define __func__ ""
11964 > _ACEOF
11965  
5610                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5611
11966   fi
11967  
5614 fi
5615 done
11968  
11969  
11970  
11971 +
11972   case $debug in
11973    1)
11974       ;;
# Line 5624 | Line 11977 | case $debug in
11977  
11978  
11979  
11980 + # Try to determine "good" native compiler flags if none specified on command
11981 + # line
11982  
11983 + if test "$ac_test_FFLAGS" != "set"; then
11984 +  FCFLAGS=""
11985 +  case "${host_cpu}-${host_os}" in
11986  
11987 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11988 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11989 +                fi;;
11990 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11991 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11992 +                fi;;
11993 +   powerpc*-aix*)
11994 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11995 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11996 +                echo "*******************************************************"
11997 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11998 +                echo "*  recommended that you use                           *"
11999 +                echo "*                                                     *"
12000 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12001 +                echo "*                                 ^^^                 *"
12002 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12003 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12004 +                echo "*******************************************************"
12005 +        fi;;
12006 +   *darwin*)
12007 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12008 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12009 +        fi
12010 +        if test "$FC" = ifort; then
12011 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12012 +        fi;;
12013 +  esac
12014 +
12015 +  if test -n "$CPU_FLAGS"; then
12016 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12017 +  fi
12018 +
12019 +  if test -z "$FCFLAGS"; then
12020 +        echo ""
12021 +        echo "*********************************************************"
12022 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12023 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12024 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12025 +        echo "*********************************************************"
12026 +        echo ""
12027 +        FCFLAGS="-O3"
12028 +  fi
12029 +
12030 +
12031 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12032 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12033 + if test "${ac_guessed_f90flags+set}" = set; then
12034 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12035 + else
12036 +
12037 +
12038 +
12039 + ac_ext=${FC_SRCEXT-f}
12040 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12041 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12042 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12043 +
12044 + echo 'program main' > conftest.$ac_ext
12045 + echo 'end program main' >> conftest.$ac_ext
12046 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12047 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12048 +  (eval $ac_compile) 2>&5
12049 +  ac_status=$?
12050 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12051 +  (exit $ac_status); }; then
12052 +        ac_guessed_f90flags=yes
12053 + else
12054 +        ac_guessed_f90flags=no
12055 + fi
12056 + rm -f conftest*
12057 + ac_ext=cc
12058 + ac_cpp='$CXXCPP $CPPFLAGS'
12059 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12060 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12061 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12062 +
12063 +
12064 + fi
12065 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12066 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12067 + if test "$ac_guessed_f90flags" = yes; then
12068 +        :
12069 +
12070 + else
12071 +        :
12072 +
12073 +        echo ""
12074 +        echo "**********************************************************"
12075 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12076 +        echo "* your compiler.                                        *"
12077 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12078 +        echo "*********************************************************"
12079 +        echo ""
12080 +        FCFLAGS=""
12081 +
12082 + fi
12083 +
12084 +
12085 + fi
12086 +
12087 +
12088 +
12089 +
12090 +
12091 +
12092 +
12093   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12094   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12095   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5634 | 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 5672 | 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 5702 | 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 5715 | 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 5742 | 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 5773 | 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 5796 | 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 5825 | 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 5848 | 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 5881 | 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 5939 | 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 5972 | 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 6000 | 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 6045 | 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 6095 | 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 6133 | 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 6154 | 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 6167 | 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 6194 | 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 6225 | 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 6248 | 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 6277 | 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 6300 | 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 6333 | 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 6391 | Line 12865 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12865          :
12866  
12867  
12868 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12869 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12868 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12869 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12870   if test "${ac_m_cpu_750+set}" = set; then
12871    echo $ECHO_N "(cached) $ECHO_C" >&6
12872   else
12873    echo 'void f(){}' > conftest.cpp
12874 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12874 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12875          ac_m_cpu_750=yes
12876   else
12877          ac_m_cpu_750=no
# Line 6424 | Line 12898 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12898                  if test -z "$CPU_FLAGS"; then
12899  
12900  
12901 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12902 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12901 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12902 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12903   if test "${ac_m_cpu_powerpc+set}" = set; then
12904    echo $ECHO_N "(cached) $ECHO_C" >&6
12905   else
12906    echo 'void f(){}' > conftest.cpp
12907 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12907 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12908          ac_m_cpu_powerpc=yes
12909   else
12910          ac_m_cpu_powerpc=no
# Line 6452 | Line 12926 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12926                  if test -z "$CPU_FLAGS"; then
12927  
12928  
12929 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12930 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12929 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12930 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12931   if test "${ac_m_powerpc+set}" = set; then
12932    echo $ECHO_N "(cached) $ECHO_C" >&6
12933   else
12934    echo 'void f(){}' > conftest.cpp
12935 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12935 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12936          ac_m_powerpc=yes
12937   else
12938          ac_m_powerpc=no
# Line 6469 | Line 12943 | if test "$ac_m_powerpc" = yes; then
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
6474 < else
6475 <        :
6476 <
6477 < fi
6478 <
6479 <                fi
6480 <          esac
6481 <  fi
6482 <
6483 <  if test -n "$CPU_FLAGS"; then
6484 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6485 <  fi
6486 <
6487 <  if test -z "$CXXFLAGS"; then
6488 <        echo ""
6489 <        echo "**********************************************************"
6490 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6491 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6492 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6493 <        echo "**********************************************************"
6494 <        echo ""
6495 <        CXXFLAGS="-O3"
6496 <  fi
6497 <
6498 <
6499 <
6500 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6501 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6502 < if test "${ac_guessed_cxxflags+set}" = set; then
6503 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6504 < else
6505 <  echo 'void f(){}' > conftest.cpp
6506 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6507 <        ac_guessed_cxxflags=yes
6508 < else
6509 <        ac_guessed_cxxflags=no
6510 < fi
6511 < rm -f conftest*
6512 <
6513 < fi
6514 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6515 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6516 < if test "$ac_guessed_cxxflags" = yes; then
6517 <        :
6518 <
6519 < else
6520 <        :
6521 <
6522 <        echo ""
6523 <        echo "**********************************************************"
6524 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6525 <        echo "* your compiler.                                         *"
6526 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6527 <        echo "**********************************************************"
6528 <        echo ""
6529 <        CXXFLAGS=""
6530 <
6531 < fi
6532 <
6533 <
6534 < fi
6535 <
6536 <
6537 <
6538 <
6539 <
6540 < # Try to determine "good" native compiler flags if none specified on command
6541 < # line
6542 <
6543 < if test x"$F90FLAGS" = x ; then
6544 <  F90FLAGS=""
6545 <  case "${host_cpu}-${host_os}" in
6546 <
6547 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6548 <                    F90FLAGS="-O"
6549 <                fi;;
6550 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6551 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6552 <                fi;;
6553 <   powerpc*-aix*)
6554 <        if test "$F90" = f90 -o "$F90" = xlf90; then
6555 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6556 <                echo "*******************************************************"
6557 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6558 <                echo "*  recommended that you use                           *"
6559 <                echo "*                                                     *"
6560 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6561 <                echo "*                                 ^^^                 *"
6562 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6563 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6564 <                echo "*******************************************************"
6565 <        fi;;
6566 <   *darwin*)
6567 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6568 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6569 <        fi;;
6570 <  esac
6571 <
6572 <  if test -n "$CPU_FLAGS"; then
6573 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6574 <  fi
6575 <
6576 <  if test -z "$F90FLAGS"; then
6577 <        echo ""
6578 <        echo "**********************************************************"
6579 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6580 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6581 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6582 <        echo "**********************************************************"
6583 <        echo ""
6584 <        F90FLAGS="-O3"
6585 <  fi
6586 <
6587 <
6588 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6589 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6590 < if test "${ac_guessed_f90flags+set}" = set; then
6591 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6592 < else
6593 <
6594 <
6595 <
6596 < ac_ext=f90
6597 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6598 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6599 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6600 <
6601 < echo 'program main' > conftest.$ac_ext
6602 < echo 'end program main' >> conftest.$ac_ext
6603 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6604 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6605 <  (eval $ac_compile) 2>&5
6606 <  ac_status=$?
6607 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6608 <  (exit $ac_status); }; then
6609 <        ac_guessed_f90flags=yes
6610 < else
6611 <        ac_guessed_f90flags=no
6612 < fi
6613 < rm -f conftest*
6614 < ac_ext=c
6615 < ac_cpp='$CPP $CPPFLAGS'
6616 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6617 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6618 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6619 <
6620 <
6621 < fi
6622 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6623 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
6624 < if test "$ac_guessed_f90flags" = yes; then
6625 <        :
6626 <
6627 < else
6628 <        :
6629 <
6630 <        echo ""
6631 <        echo "**********************************************************"
6632 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6633 <        echo "* your compiler.                                         *"
6634 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6635 <        echo "**********************************************************"
6636 <        echo ""
6637 <        F90FLAGS=""
6638 <
6639 < fi
6640 <
6641 <
6642 < fi
6643 <
6644 <     ;;
6645 < esac
6646 <
6647 < # Find a good install program.  We prefer a C program (faster),
6648 < # so one script is as good as another.  But avoid the broken or
6649 < # incompatible versions:
6650 < # SysV /etc/install, /usr/sbin/install
6651 < # SunOS /usr/etc/install
6652 < # IRIX /sbin/install
6653 < # AIX /bin/install
6654 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6655 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6656 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6657 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6658 < # OS/2's system install, which has a completely different semantic
6659 < # ./install, which can be erroneously created by make from ./install.sh.
6660 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6661 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6662 < if test -z "$INSTALL"; then
6663 < if test "${ac_cv_path_install+set}" = set; then
6664 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6665 < else
6666 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6667 < for as_dir in $PATH
6668 < do
6669 <  IFS=$as_save_IFS
6670 <  test -z "$as_dir" && as_dir=.
6671 <  # Account for people who put trailing slashes in PATH elements.
6672 < case $as_dir/ in
6673 <  ./ | .// | /cC/* | \
6674 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6675 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6676 <  /usr/ucb/* ) ;;
6677 <  *)
6678 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6679 <    # Don't use installbsd from OSF since it installs stuff as root
6680 <    # by default.
6681 <    for ac_prog in ginstall scoinst install; do
6682 <      for ac_exec_ext in '' $ac_executable_extensions; do
6683 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6684 <          if test $ac_prog = install &&
6685 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6686 <            # AIX install.  It has an incompatible calling convention.
6687 <            :
6688 <          elif test $ac_prog = install &&
6689 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6690 <            # program-specific install script used by HP pwplus--don't use.
6691 <            :
6692 <          else
6693 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6694 <            break 3
6695 <          fi
6696 <        fi
6697 <      done
6698 <    done
6699 <    ;;
6700 < esac
6701 < done
6702 <
6703 <
6704 < fi
6705 <  if test "${ac_cv_path_install+set}" = set; then
6706 <    INSTALL=$ac_cv_path_install
6707 <  else
6708 <    # As a last resort, use the slow shell script.  We don't cache a
6709 <    # path for INSTALL within a source directory, because that will
6710 <    # break other packages using the cache if that directory is
6711 <    # removed, or if the path is relative.
6712 <    INSTALL=$ac_install_sh
6713 <  fi
6714 < fi
6715 < echo "$as_me:$LINENO: result: $INSTALL" >&5
6716 < echo "${ECHO_T}$INSTALL" >&6
6717 <
6718 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6719 < # It thinks the first close brace ends the variable substitution.
6720 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6721 <
6722 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6723 <
6724 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6725 <
6726 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
6727 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6728 < LN_S=$as_ln_s
6729 < if test "$LN_S" = "ln -s"; then
6730 <  echo "$as_me:$LINENO: result: yes" >&5
6731 < echo "${ECHO_T}yes" >&6
6732 < else
6733 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6734 < echo "${ECHO_T}no, using $LN_S" >&6
6735 < fi
6736 <
6737 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6738 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6739 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6740 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6741 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6742 < else
6743 <  cat >conftest.make <<\_ACEOF
6744 < all:
6745 <        @echo 'ac_maketemp="$(MAKE)"'
6746 < _ACEOF
6747 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6748 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6749 < if test -n "$ac_maketemp"; then
6750 <  eval ac_cv_prog_make_${ac_make}_set=yes
6751 < else
6752 <  eval ac_cv_prog_make_${ac_make}_set=no
6753 < fi
6754 < rm -f conftest.make
6755 < fi
6756 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6757 <  echo "$as_me:$LINENO: result: yes" >&5
6758 < echo "${ECHO_T}yes" >&6
6759 <  SET_MAKE=
6760 < else
6761 <  echo "$as_me:$LINENO: result: no" >&5
6762 < echo "${ECHO_T}no" >&6
6763 <  SET_MAKE="MAKE=${MAKE-make}"
6764 < fi
6765 <
6766 < if test -n "$ac_tool_prefix"; then
6767 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6768 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6769 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6770 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6771 < if test "${ac_cv_prog_RANLIB+set}" = set; then
6772 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6773 < else
6774 <  if test -n "$RANLIB"; then
6775 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6776 < else
6777 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6778 < for as_dir in $PATH
6779 < do
6780 <  IFS=$as_save_IFS
6781 <  test -z "$as_dir" && as_dir=.
6782 <  for ac_exec_ext in '' $ac_executable_extensions; do
6783 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6784 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6785 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6786 <    break 2
6787 <  fi
6788 < done
6789 < done
6790 <
6791 < fi
6792 < fi
6793 < RANLIB=$ac_cv_prog_RANLIB
6794 < if test -n "$RANLIB"; then
6795 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6796 < echo "${ECHO_T}$RANLIB" >&6
6797 < else
6798 <  echo "$as_me:$LINENO: result: no" >&5
6799 < echo "${ECHO_T}no" >&6
6800 < fi
6801 <
6802 < fi
6803 < if test -z "$ac_cv_prog_RANLIB"; then
6804 <  ac_ct_RANLIB=$RANLIB
6805 <  # Extract the first word of "ranlib", so it can be a program name with args.
6806 < set dummy ranlib; ac_word=$2
6807 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6808 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6809 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6810 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6811 < else
6812 <  if test -n "$ac_ct_RANLIB"; then
6813 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6814 < else
6815 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6816 < for as_dir in $PATH
6817 < do
6818 <  IFS=$as_save_IFS
6819 <  test -z "$as_dir" && as_dir=.
6820 <  for ac_exec_ext in '' $ac_executable_extensions; do
6821 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6822 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6823 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6824 <    break 2
6825 <  fi
6826 < done
6827 < done
6828 <
6829 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6830 < fi
6831 < fi
6832 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6833 < if test -n "$ac_ct_RANLIB"; then
6834 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6835 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6836 < else
6837 <  echo "$as_me:$LINENO: result: no" >&5
6838 < echo "${ECHO_T}no" >&6
6839 < fi
6840 <
6841 <  RANLIB=$ac_ct_RANLIB
6842 < else
6843 <  RANLIB="$ac_cv_prog_RANLIB"
6844 < fi
6845 <
6846 < for ac_prog in 'bison -y' byacc
6847 < do
6848 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6849 < set dummy $ac_prog; ac_word=$2
6850 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6851 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6852 < if test "${ac_cv_prog_YACC+set}" = set; then
6853 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6854 < else
6855 <  if test -n "$YACC"; then
6856 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6857 < else
6858 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6859 < for as_dir in $PATH
6860 < do
6861 <  IFS=$as_save_IFS
6862 <  test -z "$as_dir" && as_dir=.
6863 <  for ac_exec_ext in '' $ac_executable_extensions; do
6864 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6865 <    ac_cv_prog_YACC="$ac_prog"
6866 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6867 <    break 2
6868 <  fi
6869 < done
6870 < done
6871 <
6872 < fi
6873 < fi
6874 < YACC=$ac_cv_prog_YACC
6875 < if test -n "$YACC"; then
6876 <  echo "$as_me:$LINENO: result: $YACC" >&5
6877 < echo "${ECHO_T}$YACC" >&6
6878 < else
6879 <  echo "$as_me:$LINENO: result: no" >&5
6880 < echo "${ECHO_T}no" >&6
6881 < fi
6882 <
6883 <  test -n "$YACC" && break
6884 < done
6885 < test -n "$YACC" || YACC="yacc"
6886 <
6887 < for ac_prog in flex lex
6888 < do
6889 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6890 < set dummy $ac_prog; ac_word=$2
6891 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6892 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6893 < if test "${ac_cv_prog_LEX+set}" = set; then
6894 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6895 < else
6896 <  if test -n "$LEX"; then
6897 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6898 < else
6899 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6900 < for as_dir in $PATH
6901 < do
6902 <  IFS=$as_save_IFS
6903 <  test -z "$as_dir" && as_dir=.
6904 <  for ac_exec_ext in '' $ac_executable_extensions; do
6905 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6906 <    ac_cv_prog_LEX="$ac_prog"
6907 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6908 <    break 2
6909 <  fi
6910 < done
6911 < done
6912 <
6913 < fi
6914 < fi
6915 < LEX=$ac_cv_prog_LEX
6916 < if test -n "$LEX"; then
6917 <  echo "$as_me:$LINENO: result: $LEX" >&5
6918 < echo "${ECHO_T}$LEX" >&6
6919 < else
6920 <  echo "$as_me:$LINENO: result: no" >&5
6921 < echo "${ECHO_T}no" >&6
6922 < fi
6923 <
6924 <  test -n "$LEX" && break
6925 < done
6926 < test -n "$LEX" || LEX=":"
6927 <
6928 < if test -z "$LEXLIB"
6929 < then
6930 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6931 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6932 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6933 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6934 < else
6935 <  ac_check_lib_save_LIBS=$LIBS
6936 < LIBS="-lfl  $LIBS"
6937 < cat >conftest.$ac_ext <<_ACEOF
6938 < /* confdefs.h.  */
6939 < _ACEOF
6940 < cat confdefs.h >>conftest.$ac_ext
6941 < cat >>conftest.$ac_ext <<_ACEOF
6942 < /* end confdefs.h.  */
6943 <
6944 < /* Override any gcc2 internal prototype to avoid an error.  */
6945 < #ifdef __cplusplus
6946 < extern "C"
6947 < #endif
6948 < /* We use char because int might match the return type of a gcc2
6949 <   builtin and then its argument prototype would still apply.  */
6950 < char yywrap ();
6951 < int
6952 < main ()
6953 < {
6954 < yywrap ();
6955 <  ;
6956 <  return 0;
6957 < }
6958 < _ACEOF
6959 < rm -f conftest.$ac_objext conftest$ac_exeext
6960 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6961 <  (eval $ac_link) 2>conftest.er1
6962 <  ac_status=$?
6963 <  grep -v '^ *+' conftest.er1 >conftest.err
6964 <  rm -f conftest.er1
6965 <  cat conftest.err >&5
6966 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6967 <  (exit $ac_status); } &&
6968 <         { ac_try='test -z "$ac_c_werror_flag"
6969 <                         || test ! -s conftest.err'
6970 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6971 <  (eval $ac_try) 2>&5
6972 <  ac_status=$?
6973 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6974 <  (exit $ac_status); }; } &&
6975 <         { ac_try='test -s conftest$ac_exeext'
6976 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6977 <  (eval $ac_try) 2>&5
6978 <  ac_status=$?
6979 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6980 <  (exit $ac_status); }; }; then
6981 <  ac_cv_lib_fl_yywrap=yes
6982 < else
6983 <  echo "$as_me: failed program was:" >&5
6984 < sed 's/^/| /' conftest.$ac_ext >&5
6985 <
6986 < ac_cv_lib_fl_yywrap=no
6987 < fi
6988 < rm -f conftest.err conftest.$ac_objext \
6989 <      conftest$ac_exeext conftest.$ac_ext
6990 < LIBS=$ac_check_lib_save_LIBS
6991 < fi
6992 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6993 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6994 < if test $ac_cv_lib_fl_yywrap = yes; then
6995 <  LEXLIB="-lfl"
6996 < else
6997 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6998 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6999 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
7000 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7001 < else
7002 <  ac_check_lib_save_LIBS=$LIBS
7003 < LIBS="-ll  $LIBS"
7004 < cat >conftest.$ac_ext <<_ACEOF
7005 < /* confdefs.h.  */
7006 < _ACEOF
7007 < cat confdefs.h >>conftest.$ac_ext
7008 < cat >>conftest.$ac_ext <<_ACEOF
7009 < /* end confdefs.h.  */
7010 <
7011 < /* Override any gcc2 internal prototype to avoid an error.  */
7012 < #ifdef __cplusplus
7013 < extern "C"
7014 < #endif
7015 < /* We use char because int might match the return type of a gcc2
7016 <   builtin and then its argument prototype would still apply.  */
7017 < char yywrap ();
7018 < int
7019 < main ()
7020 < {
7021 < yywrap ();
7022 <  ;
7023 <  return 0;
7024 < }
7025 < _ACEOF
7026 < rm -f conftest.$ac_objext conftest$ac_exeext
7027 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7028 <  (eval $ac_link) 2>conftest.er1
7029 <  ac_status=$?
7030 <  grep -v '^ *+' conftest.er1 >conftest.err
7031 <  rm -f conftest.er1
7032 <  cat conftest.err >&5
7033 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7034 <  (exit $ac_status); } &&
7035 <         { ac_try='test -z "$ac_c_werror_flag"
7036 <                         || test ! -s conftest.err'
7037 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7038 <  (eval $ac_try) 2>&5
7039 <  ac_status=$?
7040 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7041 <  (exit $ac_status); }; } &&
7042 <         { ac_try='test -s conftest$ac_exeext'
7043 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7044 <  (eval $ac_try) 2>&5
7045 <  ac_status=$?
7046 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7047 <  (exit $ac_status); }; }; then
7048 <  ac_cv_lib_l_yywrap=yes
7049 < else
7050 <  echo "$as_me: failed program was:" >&5
7051 < sed 's/^/| /' conftest.$ac_ext >&5
7052 <
7053 < ac_cv_lib_l_yywrap=no
7054 < fi
7055 < rm -f conftest.err conftest.$ac_objext \
7056 <      conftest$ac_exeext conftest.$ac_ext
7057 < LIBS=$ac_check_lib_save_LIBS
7058 < fi
7059 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
7060 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
7061 < if test $ac_cv_lib_l_yywrap = yes; then
7062 <  LEXLIB="-ll"
7063 < fi
7064 <
7065 < fi
7066 <
7067 < fi
7068 <
7069 < if test "x$LEX" != "x:"; then
7070 <  echo "$as_me:$LINENO: checking lex output file root" >&5
7071 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
7072 < if test "${ac_cv_prog_lex_root+set}" = set; then
7073 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7074 < else
7075 <  # The minimal lex program is just a single line: %%.  But some broken lexes
7076 < # (Solaris, I think it was) want two %% lines, so accommodate them.
7077 < cat >conftest.l <<_ACEOF
7078 < %%
7079 < %%
7080 < _ACEOF
7081 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
7082 <  (eval $LEX conftest.l) 2>&5
7083 <  ac_status=$?
7084 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7085 <  (exit $ac_status); }
7086 < if test -f lex.yy.c; then
7087 <  ac_cv_prog_lex_root=lex.yy
7088 < elif test -f lexyy.c; then
7089 <  ac_cv_prog_lex_root=lexyy
7090 < else
7091 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7092 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7093 <   { (exit 1); exit 1; }; }
7094 < fi
7095 < fi
7096 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7097 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7098 < rm -f conftest.l
7099 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
7100 <
7101 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
7102 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
7103 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
7104 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12946 >        :
12947 >        CPU_FLAGS=-mpowerpc
12948   else
12949 <  # POSIX says lex can declare yytext either as a pointer or an array; the
7107 < # default is implementation-dependent. Figure out which it is, since
7108 < # not all implementations provide the %pointer and %array declarations.
7109 < ac_cv_prog_lex_yytext_pointer=no
7110 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
7111 < ac_save_LIBS=$LIBS
7112 < LIBS="$LIBS $LEXLIB"
7113 < cat >conftest.$ac_ext <<_ACEOF
7114 < `cat $LEX_OUTPUT_ROOT.c`
7115 < _ACEOF
7116 < rm -f conftest.$ac_objext conftest$ac_exeext
7117 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7118 <  (eval $ac_link) 2>conftest.er1
7119 <  ac_status=$?
7120 <  grep -v '^ *+' conftest.er1 >conftest.err
7121 <  rm -f conftest.er1
7122 <  cat conftest.err >&5
7123 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7124 <  (exit $ac_status); } &&
7125 <         { ac_try='test -z "$ac_c_werror_flag"
7126 <                         || test ! -s conftest.err'
7127 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7128 <  (eval $ac_try) 2>&5
7129 <  ac_status=$?
7130 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7131 <  (exit $ac_status); }; } &&
7132 <         { ac_try='test -s conftest$ac_exeext'
7133 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7134 <  (eval $ac_try) 2>&5
7135 <  ac_status=$?
7136 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7137 <  (exit $ac_status); }; }; then
7138 <  ac_cv_prog_lex_yytext_pointer=yes
7139 < else
7140 <  echo "$as_me: failed program was:" >&5
7141 < sed 's/^/| /' conftest.$ac_ext >&5
12949 >        :
12950  
12951   fi
7144 rm -f conftest.err conftest.$ac_objext \
7145      conftest$ac_exeext conftest.$ac_ext
7146 LIBS=$ac_save_LIBS
7147 rm -f "${LEX_OUTPUT_ROOT}.c"
12952  
12953 < fi
12954 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
12955 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
7152 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12953 >                fi
12954 >          esac
12955 >  fi
12956  
12957 < cat >>confdefs.h <<\_ACEOF
12958 < #define YYTEXT_POINTER 1
12959 < _ACEOF
12957 >  if test -n "$CPU_FLAGS"; then
12958 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12959 >  fi
12960  
12961 < 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  
12972 < fi
12973 < # Extract the first word of "ar", so it can be a program name with args.
12974 < set dummy ar; ac_word=$2
12975 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12976 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7165 < if test "${ac_cv_prog_AR+set}" = set; then
12972 >
12973 >
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 <  if test -n "$AR"; then
12980 <  ac_cv_prog_AR="$AR" # Let the user override the test.
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 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7172 < for as_dir in $PATH
7173 < do
7174 <  IFS=$as_save_IFS
7175 <  test -z "$as_dir" && as_dir=.
7176 <  for ac_exec_ext in '' $ac_executable_extensions; do
7177 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7178 <    ac_cv_prog_AR="ar"
7179 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7180 <    break 2
7181 <  fi
7182 < done
7183 < done
7184 <
7185 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12983 >        ac_guessed_cxxflags=no
12984   fi
12985 < fi
7188 < AR=$ac_cv_prog_AR
7189 < if test -n "$AR"; then
7190 <  echo "$as_me:$LINENO: result: $AR" >&5
7191 < echo "${ECHO_T}$AR" >&6
7192 < else
7193 <  echo "$as_me:$LINENO: result: no" >&5
7194 < echo "${ECHO_T}no" >&6
7195 < fi
12985 > rm -f conftest*
12986  
7197 if test "$AR" = "NONE"; then
7198  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
7199 echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7200   { (exit 1); exit 1; }; }
7201  cat >confcache <<\_ACEOF
7202 # This file is a shell script that caches the results of configure
7203 # tests run on this system so they can be shared between configure
7204 # scripts and configure runs, see configure's option --config-cache.
7205 # It is not useful on other systems.  If it contains results you don't
7206 # want to keep, you may remove or edit it.
7207 #
7208 # config.status only pays attention to the cache file if you give it
7209 # the --recheck option to rerun configure.
7210 #
7211 # `ac_cv_env_foo' variables (set or unset) will be overridden when
7212 # loading this file, other *unset* `ac_cv_foo' will be assigned the
7213 # following values.
7214
7215 _ACEOF
7216
7217 # The following way of writing the cache mishandles newlines in values,
7218 # but we know of no workaround that is simple, portable, and efficient.
7219 # So, don't put newlines in cache variables' values.
7220 # Ultrix sh set writes to stderr and can't be redirected directly,
7221 # and sets the high bit in the cache file unless we assign to the vars.
7222 {
7223  (set) 2>&1 |
7224    case `(ac_space=' '; set | grep ac_space) 2>&1` in
7225    *ac_space=\ *)
7226      # `set' does not quote correctly, so add quotes (double-quote
7227      # substitution turns \\\\ into \\, and sed turns \\ into \).
7228      sed -n \
7229        "s/'/'\\\\''/g;
7230          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7231      ;;
7232    *)
7233      # `set' quotes correctly as required by POSIX, so do not add quotes.
7234      sed -n \
7235        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7236      ;;
7237    esac;
7238 } |
7239  sed '
7240     t clear
7241     : clear
7242     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7243     t end
7244     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7245     : end' >>confcache
7246 if diff $cache_file confcache >/dev/null 2>&1; then :; else
7247  if test -w $cache_file; then
7248    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7249    cat confcache >$cache_file
7250  else
7251    echo "not updating unwritable cache $cache_file"
7252  fi
12987   fi
12988 < rm -f confcache
12989 <  exit 1
12990 < 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  
7258 # Extract the first word of "ps", so it can be a program name with args.
7259 set dummy ps; ac_word=$2
7260 echo "$as_me:$LINENO: checking for $ac_word" >&5
7261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7262 if test "${ac_cv_path_PS+set}" = set; then
7263  echo $ECHO_N "(cached) $ECHO_C" >&6
12993   else
12994 <  case $PS in
7266 <  [\\/]* | ?:[\\/]*)
7267 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
7268 <  ;;
7269 <  *)
7270 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7271 < for as_dir in $PATH
7272 < do
7273 <  IFS=$as_save_IFS
7274 <  test -z "$as_dir" && as_dir=.
7275 <  for ac_exec_ext in '' $ac_executable_extensions; do
7276 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7277 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7278 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7279 <    break 2
7280 <  fi
7281 < done
7282 < done
12994 >        :
12995  
12996 <  ;;
12997 < esac
12998 < fi
12999 < PS=$ac_cv_path_PS
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  
7289 if test -n "$PS"; then
7290  echo "$as_me:$LINENO: result: $PS" >&5
7291 echo "${ECHO_T}$PS" >&6
7292 else
7293  echo "$as_me:$LINENO: result: no" >&5
7294 echo "${ECHO_T}no" >&6
13005   fi
13006  
7297 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
7298 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
7299 if test "${ac_cv_prog_ps_syntax+set}" = set; then
7300  echo $ECHO_N "(cached) $ECHO_C" >&6
7301 else
13007  
7303        if $PS ax -o rss > /dev/null 2>&1; then
7304                ac_cv_prog_ps_ax=yes
7305        else
7306                ac_cv_prog_ps_ax=no
7307        fi
7308        if $PS -ef -o rss > /dev/null 2>&1; then
7309                ac_cv_prog_ps_ef=yes
7310        else
7311                ac_cv_prog_ps_ef=no
7312        fi
7313        if test "$ac_cv_prog_ps_ax" = yes; then
7314                ac_cv_prog_ps_syntax=BSD
7315        else
7316                if test "$ac_cv_prog_ps_es" = yes; then
7317                        ac_cv_prog_ps_syntax=POSIX
7318                else
7319                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7320 echo "$as_me: error: Could not determine ps syntax" >&2;}
7321   { (exit 1); exit 1; }; }
7322                fi
7323        fi
7324
13008   fi
7326 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7327 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
13009  
13010 < cat >>confdefs.h <<_ACEOF
13011 < #define PSCOMMAND $PS
7331 < _ACEOF
13010 >     ;;
13011 > esac
13012  
13013  
13014 < cat >>confdefs.h <<_ACEOF
13015 < #define PSTYPE $ac_cv_prog_ps_syntax
13014 > cat >>confdefs.h <<\_ACEOF
13015 > #define OBAPI
13016   _ACEOF
13017  
13018  
# Line 7366 | 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 7389 | 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 7448 | 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 7518 | 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 7589 | 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 7660 | 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 7704 | 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 7732 | 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 7808 | Line 13532 | fi
13532  
13533  
13534  
13535 < # Check whether --with-sprng or --without-sprng was given.
13536 < if test "${with_sprng+set}" = set; then
7813 <  withval="$with_sprng"
7814 <  with_sprng=$withval
7815 < else
7816 <  with_sprng="/usr/local"
7817 < fi;
13535 > USE_CGAL=no
13536 > cgal_makefile=auto
13537  
13538 < case "x$with_sprng" in
13539 <        xyes | "x")  USE_SPRNG=yes;;
13540 <        xno) USE_SPRNG=no ;;
13541 <        *) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
13542 < esac
7824 < if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7825 <        SPRNG="/usr/local"
7826 < fi
7827 < if test "$USE_SPRNG" = "yes"; then
13538 > # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13539 > if test "${with_cgal_makefile+set}" = set; then
13540 >  withval="$with_cgal_makefile"
13541 >  cgal_makefile="$withval"
13542 > fi;
13543  
13544 + if test "x$cgal_makefile" != xno; then
13545  
13546 < # Set variables...
13547 < SPRNG_LIB_DIR="$SPRNG/lib"
13548 < SPRNG_INC_DIR="$SPRNG/include"
13546 >  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13547 >    cgal_makefile="$CGAL_MAKEFILE"
13548 >  fi
13549  
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  
13555 < echo "$as_me:$LINENO: checking for sprng.h" >&5
13556 < echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
13557 < have_sprng_h=0
13558 < echo '#include <sprng.h>' > conftest.cc
13559 < if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
13560 <        echo "$as_me:$LINENO: result: yes" >&5
13561 < echo "${ECHO_T}yes" >&6
13562 <        have_sprng_h=1
13563 < else
13564 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
13565 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
13566 <        USE_SPRNG="no"
13567 < fi
13568 < rm -f conftest*
13569 < if test "$have_sprng_h" = 1; then
13555 >    cat >config.tmp.Makefile <<EOF
13556 > include $cgal_makefile
13557 > default:
13558 >        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13559 >        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13560 >        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13561 >        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13562 >        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13563 >        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13564 >        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13565 >        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13566 >        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13567 >        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13568 >        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13569 >        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13570 > EOF
13571  
13572 < cat >>confdefs.h <<\_ACEOF
13573 < #define HAVE_SPRNG_H 1
7854 < _ACEOF
13572 >    make -s -f config.tmp.Makefile
13573 >    . config.tmp.cgalvariables
13574  
13575 < fi
13575 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
13576  
13577 < ac_ext=c
13578 < ac_cpp='$CPP $CPPFLAGS'
13579 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13580 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13581 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13577 >    if test "x$CGAL_INCLDIR" = "x"; then
13578 >      CGAL_INCLDIR=""
13579 >    fi
13580 >
13581 >    if test "x$CGAL_LIBDIR" = "x"; then
13582 >      CGAL_LIBDIR=""
13583 >    fi
13584  
13585 < ac_save_LDFLAGS=$LDFLAGS
13586 < LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
13585 >    if test "x$CGAL_RLIBDIR" = "x"; then
13586 >      CGAL_RLIBDIR=""
13587 >    fi
13588  
13589 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
13590 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
13591 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
7870 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7871 < else
7872 <  ac_check_lib_save_LIBS=$LIBS
7873 < LIBS="-lsprng  $LIBS"
7874 < cat >conftest.$ac_ext <<_ACEOF
7875 < /* confdefs.h.  */
7876 < _ACEOF
7877 < cat confdefs.h >>conftest.$ac_ext
7878 < cat >>conftest.$ac_ext <<_ACEOF
7879 < /* end confdefs.h.  */
13589 >    if test "x$LEDA_INCLDIR" = "x"; then
13590 >      LEDA_INCLDIR=""
13591 >    fi
13592  
13593 < /* Override any gcc2 internal prototype to avoid an error.  */
13594 < #ifdef __cplusplus
13595 < extern "C"
7884 < #endif
7885 < /* We use char because int might match the return type of a gcc2
7886 <   builtin and then its argument prototype would still apply.  */
7887 < char init_rng ();
7888 < int
7889 < main ()
7890 < {
7891 < init_rng ();
7892 <  ;
7893 <  return 0;
7894 < }
7895 < _ACEOF
7896 < rm -f conftest.$ac_objext conftest$ac_exeext
7897 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7898 <  (eval $ac_link) 2>conftest.er1
7899 <  ac_status=$?
7900 <  grep -v '^ *+' conftest.er1 >conftest.err
7901 <  rm -f conftest.er1
7902 <  cat conftest.err >&5
7903 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7904 <  (exit $ac_status); } &&
7905 <         { ac_try='test -z "$ac_c_werror_flag"
7906 <                         || test ! -s conftest.err'
7907 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7908 <  (eval $ac_try) 2>&5
7909 <  ac_status=$?
7910 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7911 <  (exit $ac_status); }; } &&
7912 <         { ac_try='test -s conftest$ac_exeext'
7913 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7914 <  (eval $ac_try) 2>&5
7915 <  ac_status=$?
7916 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7917 <  (exit $ac_status); }; }; then
7918 <  ac_cv_lib_sprng_init_rng=yes
7919 < else
7920 <  echo "$as_me: failed program was:" >&5
7921 < sed 's/^/| /' conftest.$ac_ext >&5
13593 >    if test "x$LEDA_LIBDIR" = "x"; then
13594 >      LEDA_LIBDIR=""
13595 >    fi
13596  
13597 < ac_cv_lib_sprng_init_rng=no
13598 < fi
13599 < rm -f conftest.err conftest.$ac_objext \
7926 <      conftest$ac_exeext conftest.$ac_ext
7927 < LIBS=$ac_check_lib_save_LIBS
7928 < fi
7929 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
7930 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
7931 < if test $ac_cv_lib_sprng_init_rng = yes; then
7932 <  SPRNG_LIB="-lsprng"
7933 < else
13597 >    if test "x$LEDA_RLIBDIR" = "x"; then
13598 >      LEDA_RLIBDIR=""
13599 >    fi
13600  
13601 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13602 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13603 <   { (exit 1); exit 1; }; }
7938 <             USE_SPRNG="no"
13601 >    if test "x$GMP_INCLDIR" = "x"; then
13602 >      GMP_INCLDIR=""
13603 >    fi
13604  
13605 < fi
13606 <
13607 <
7943 < if test "$USE_SPRNG" = "no"; then
7944 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
7945 < echo "$as_me: error: No working SPRNG library found" >&2;}
7946 <   { (exit 1); exit 1; }; }
7947 < fi
7948 <
7949 <
7950 < fi
7951 <
7952 <
7953 <
7954 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
7955 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
13605 >    if test "x$GMP_LIBDIR" = "x"; then
13606 >      GMP_LIBDIR=""
13607 >    fi
13608  
13609 < # Check whether --with-mkl or --without-mkl was given.
13610 < if test "${with_mkl+set}" = set; then
7959 <  withval="$with_mkl"
7960 <     echo "$as_me:$LINENO: result: yes" >&5
7961 < echo "${ECHO_T}yes" >&6
7962 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7963 <        mkldir="$dir"
7964 <        if test -f "$dir/include/mkl.h"; then
7965 <            found_mkl="yes";
7966 <            break;
7967 <        fi
7968 <    done
7969 <    if test x_$found_mkl != x_yes; then
7970 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7971 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7972 <   { (exit 1); exit 1; }; }
7973 <    else
7974 <        printf "MKL includes found in $mkldir/include\n";
13609 >    if test "x$GMP_RLIBDIR" = "x"; then
13610 >      GMP_RLIBDIR=""
13611      fi
13612  
13613 +    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13614 + echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13615 +    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13616 + echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13617 +    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13618 + echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13619 +    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13620 + echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13621 +    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13622 + echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13623 +    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13624 + echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13625 +    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13626 + echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13627 +    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13628 + echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13629 +    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13630 + echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13631  
13632 +    ac_ext=cc
13633 + ac_cpp='$CXXCPP $CPPFLAGS'
13634 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13635 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13636 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13637  
13638 <  ac_ext=c
13639 < ac_cpp='$CPP $CPPFLAGS'
13640 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13641 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13642 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13643 <
7985 <  ac_save_CPPFLAGS=$CPPFLAGS
7986 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
7987 <  ac_save_LDFLAGS=$LDFLAGS
7988 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
7989 <  if test "${ac_cv_header_mkl_h+set}" = set; then
7990 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
7991 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7992 < if test "${ac_cv_header_mkl_h+set}" = set; then
13638 >    save_CXXFLAGS="$CXXFLAGS"
13639 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13640 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13641 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13642 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13643 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13644    echo $ECHO_N "(cached) $ECHO_C" >&6
13645   fi
13646 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13647 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13646 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13647 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13648   else
13649    # Is the header compilable?
13650 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
13651 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13650 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13651 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13652   cat >conftest.$ac_ext <<_ACEOF
13653   /* confdefs.h.  */
13654   _ACEOF
# Line 8005 | Line 13656 | $ac_includes_default
13656   cat >>conftest.$ac_ext <<_ACEOF
13657   /* end confdefs.h.  */
13658   $ac_includes_default
13659 < #include <mkl.h>
13659 > #include <CGAL/Cartesian.h>
13660   _ACEOF
13661   rm -f conftest.$ac_objext
13662   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 8016 | Line 13667 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13667    cat conftest.err >&5
13668    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13669    (exit $ac_status); } &&
13670 <         { ac_try='test -z "$ac_c_werror_flag"
13670 >         { ac_try='test -z "$ac_cxx_werror_flag"
13671                           || test ! -s conftest.err'
13672    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13673    (eval $ac_try) 2>&5
# Line 8041 | Line 13692 | echo "$as_me:$LINENO: checking mkl.h presence" >&5
13692   echo "${ECHO_T}$ac_header_compiler" >&6
13693  
13694   # Is the header present?
13695 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
13696 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13695 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13696 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13697   cat >conftest.$ac_ext <<_ACEOF
13698   /* confdefs.h.  */
13699   _ACEOF
13700   cat confdefs.h >>conftest.$ac_ext
13701   cat >>conftest.$ac_ext <<_ACEOF
13702   /* end confdefs.h.  */
13703 < #include <mkl.h>
13703 > #include <CGAL/Cartesian.h>
13704   _ACEOF
13705   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13706    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 8060 | Line 13711 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13711    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13712    (exit $ac_status); } >/dev/null; then
13713    if test -s conftest.err; then
13714 <    ac_cpp_err=$ac_c_preproc_warn_flag
13715 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13714 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13715 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13716    else
13717      ac_cpp_err=
13718    fi
# Line 8081 | Line 13732 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
13732   echo "${ECHO_T}$ac_header_preproc" >&6
13733  
13734   # So?  What about this header?
13735 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13735 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13736    yes:no: )
13737 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13738 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13739 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
13740 < echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
13737 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13738 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13739 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13740 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13741      ac_header_preproc=yes
13742      ;;
13743    no:yes:* )
13744 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13745 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13746 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
13747 < echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
13748 <    { echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
13749 < echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
13750 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
13751 < echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13752 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13753 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13754 <    { echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
13755 < echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
13744 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13745 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13746 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13747 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13748 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13749 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13750 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13751 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13752 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13753 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13754 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13755 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13756      (
13757        cat <<\_ASBOX
13758   ## ------------------------------ ##
# Line 8112 | Line 13763 | echo "$as_me:$LINENO: checking for mkl.h" >&5
13763        sed "s/^/$as_me: WARNING:     /" >&2
13764      ;;
13765   esac
13766 < echo "$as_me:$LINENO: checking for mkl.h" >&5
13767 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13768 < if test "${ac_cv_header_mkl_h+set}" = set; then
13766 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13767 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13768 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13769    echo $ECHO_N "(cached) $ECHO_C" >&6
13770   else
13771 <  ac_cv_header_mkl_h=$ac_header_preproc
13771 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13772   fi
13773 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13774 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13773 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13774 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13775  
13776   fi
13777 < if test $ac_cv_header_mkl_h = yes; then
13778 <
8128 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
8129 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
8130 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
8131 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13777 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13778 >  cgal=yes
13779   else
13780 <  ac_check_lib_save_LIBS=$LIBS
13781 < LIBS="-lmkl  $LIBS"
13780 >  cgal=no
13781 > fi
13782 >
13783 >
13784 >    CXXFLAGS="$save_CXXFLAGS"
13785 >
13786 >    if test "x$cgal" = xyes; then
13787 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
13788 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
13789 >      LOCATION=${CGAL_INCLDIR}
13790 >      LOCATION=${LOCATION:-/usr/include}
13791 >      if test -f $LOCATION/CGAL/version.h; then
13792 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
13793 >      else
13794 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
13795 >      fi
13796 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
13797 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
13798 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
13799 >      else
13800 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
13801 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
13802 >        cgal=no
13803 >      fi
13804 >    fi
13805 >
13806 >    if test "x$cgal" = xyes; then
13807 >      CGAL_LIBS="-lCGAL"
13808 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13809 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13810 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13811 >        CGAL_USES_LEDA=yes
13812 >        echo "$as_me:$LINENO: result: yes" >&5
13813 > echo "${ECHO_T}yes" >&6
13814 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13815 >      else
13816 >        echo "$as_me:$LINENO: result: no" >&5
13817 > echo "${ECHO_T}no" >&6
13818 >        CGAL_USES_LEDA=no
13819 >      fi
13820 >
13821 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13822 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13823 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13824 >        CGAL_USES_GMP=yes
13825 >        echo "$as_me:$LINENO: result: yes" >&5
13826 > echo "${ECHO_T}yes" >&6
13827 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13828 >      else
13829 >        echo "$as_me:$LINENO: result: no" >&5
13830 > echo "${ECHO_T}no" >&6
13831 >        CGAL_USES_GMP=no
13832 >      fi
13833 >
13834 >      CGAL_LIBS="$CGAL_LIBS -lm"
13835 >
13836 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
13837 >
13838 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13839 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13840 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13841 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13842 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13843 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13844 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13845 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13846 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13847 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13848 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13849 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13850 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13851 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13852 >    fi
13853 >
13854 >    if test "x$cgal" = xyes; then
13855 >      save_LIBS="$LIBS"
13856 >      LIBS="$LIBS -L$CGAL_LIBDIR"
13857 >      if test "x$CGAL_USES_LEDA" = xyes; then
13858 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13859 >      fi
13860 >      # if test "x$CGAL_USES_GMP" = xyes; then
13861 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13862 >      # fi
13863 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13864 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13865 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13866 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13867 > save_LIBS_CHECK_CXX_LIB="$LIBS"
13868 > LIBS="-lCGAL  $LIBS"
13869   cat >conftest.$ac_ext <<_ACEOF
13870   /* confdefs.h.  */
13871   _ACEOF
13872   cat confdefs.h >>conftest.$ac_ext
13873   cat >>conftest.$ac_ext <<_ACEOF
13874   /* end confdefs.h.  */
13875 <
13876 < /* Override any gcc2 internal prototype to avoid an error.  */
13877 < #ifdef __cplusplus
13878 < extern "C"
13875 > #include <CGAL/Cartesian.h>
13876 > #ifdef FC_DUMMY_MAIN
13877 > #ifndef FC_DUMMY_MAIN_EQ_F77
13878 > #  ifdef __cplusplus
13879 >     extern "C"
13880 > #  endif
13881 >   int FC_DUMMY_MAIN() { return 1; }
13882   #endif
13883 < /* We use char because int might match the return type of a gcc2
8147 <   builtin and then its argument prototype would still apply.  */
8148 < char vslNewStream ();
13883 > #endif
13884   int
13885   main ()
13886   {
13887 < vslNewStream ();
13887 > ::CGAL::Cartesian<int>::Point_2 P
13888    ;
13889    return 0;
13890   }
# Line 8163 | Line 13898 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13898    cat conftest.err >&5
13899    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13900    (exit $ac_status); } &&
13901 <         { ac_try='test -z "$ac_c_werror_flag"
13901 >         { ac_try='test -z "$ac_cxx_werror_flag"
13902                           || test ! -s conftest.err'
13903    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13904    (eval $ac_try) 2>&5
# Line 8176 | Line 13911 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13911    ac_status=$?
13912    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13913    (exit $ac_status); }; }; then
13914 <  ac_cv_lib_mkl_vslNewStream=yes
13914 >  echo "$as_me:$LINENO: result: yes" >&5
13915 > echo "${ECHO_T}yes" >&6
13916 > cgal=yes
13917   else
13918    echo "$as_me: failed program was:" >&5
13919   sed 's/^/| /' conftest.$ac_ext >&5
13920  
13921 < ac_cv_lib_mkl_vslNewStream=no
13921 > echo "$as_me:$LINENO: result: no" >&5
13922 > echo "${ECHO_T}no" >&6
13923 > cgal=no
13924   fi
13925   rm -f conftest.err conftest.$ac_objext \
13926        conftest$ac_exeext conftest.$ac_ext
13927 < LIBS=$ac_check_lib_save_LIBS
13928 < fi
13929 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
13930 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
8192 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
8193 <  MKL_LIBDIR="${mkldir}/lib/32",
8194 <                     MKL_LIB="-lmkl -lvml -lguide",
8195 <                     HAVE_MKL="yes"
8196 < fi
13927 > CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13928 > LIBS="$save_LIBS_CHECK_CXX_LIB"
13929 >      LIBS="$save_LIBS"
13930 >    fi
13931  
13932 <
8199 < else
8200 <  MKL_INC="-I${mkldir}/include"
8201 < fi
8202 <
8203 <
8204 <  CPPFLAGS=$ac_save_CPPFLAGS
8205 <  LDFLAGS=$ac_save_LDFLAGS
13932 >  fi
13933    ac_ext=c
13934   ac_cpp='$CPP $CPPFLAGS'
13935   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8210 | Line 13937 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
13937   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13938  
13939  
13940 <  if test x_$HAVE_MKL != x_yes; then
8214 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
8215 < echo "$as_me: error: Can't build with MKL" >&2;}
8216 <   { (exit 1); exit 1; }; }
8217 <  fi
13940 > fi
13941  
13942 + if test "x$cgal" = xyes; then
13943 +  USE_CGAL=yes
13944  
13945 + cat >>confdefs.h <<\_ACEOF
13946 + #define HAVE_CGAL 1
13947 + _ACEOF
13948  
13949  
13950 + cat >>confdefs.h <<_ACEOF
13951 + #define CGAL_VERSION $CGAL_VERSION
13952 + _ACEOF
13953  
13954 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
13955 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13956 + echo "$as_me: WARNING: *****************************************************" >&2;}
13957 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
13958 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
13959 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
13960 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
13961 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13962 + echo "$as_me: WARNING: *****************************************************" >&2;}
13963 +  fi
13964   else
13965 +   if test "x$cgal_makefile" != xno; then
13966 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
13967 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
13968 +  fi
13969 +  CGAL_INCLDIR=
13970 +  CGAL_LIBDIR=
13971 +  CGAL_RLIBDIR=
13972 +  CGAL_DEFINES=
13973 +  CGAL_CXXFLAGS=
13974 +  CGAL_LIBS=
13975 + fi
13976  
8225    echo "$as_me:$LINENO: result: no" >&5
8226 echo "${ECHO_T}no" >&6
13977  
13978 < fi;
13978 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
13979  
13980 + CGAL_LIB_DIR=${CGAL_LIBDIR}
13981  
13982 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13983  
13984 +
13985 +
13986 +
13987 +
13988 +
13989   # Check whether --enable-doxygen or --disable-doxygen was given.
13990   if test "${enable_doxygen+set}" = set; then
13991    enableval="$enable_doxygen"
# Line 8370 | Line 14127 | OBJEXT=".$OBJEXT"
14127  
14128  
14129  
8373 OBJEXT=".$OBJEXT"
14130  
8375 OOPSE=oopse
14131  
8377 if test "x${prefix}" = "xNONE"
8378 then
8379  OOPSE_HOME=${ac_default_prefix}/oopse
8380 else
8381  OOPSE_HOME=${prefix}/oopse
8382 fi
8383 # Check whether --enable-oopse-home or --disable-oopse-home was given.
8384 if test "${enable_oopse_home+set}" = set; then
8385  enableval="$enable_oopse_home"
8386  OOPSE_HOME="${enableval}"
8387 fi;
14132  
8389 case "x$INSTALL" in
8390   x/*) ;;
8391   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
8392 esac
14133  
8394 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14134  
8396 CFLAGS=${CFLAGS-""}
8397 CXXFLAGS=${CXXFLAGS-""}
8398 CPPFLAGS=${CPPFLAGS-""}
8399 FFLAGS=${FFLAGS-""}
8400 F90FLAGS=${F90FLAGS-""}
8401 LDFLAGS=${LDFLAGS-""}
8402 DEBUG=${DEBUG-"-g"}
14135  
8404 case $debug in
8405  1)
8406     FFLAGS="$DEBUG $FFLAGS"
8407     F90FLAGS="$DEBUG $F90FLAGS"
8408     ;;
8409  *)
8410     ;;
8411 esac
14136  
14137  
14138  
14139  
14140  
14141  
14142 <
8419 <
8420 <
8421 <
8422 <
8423 <
8424 <
8425 <
8426 <
8427 <
8428 <
8429 <
8430 <          ac_config_headers="$ac_config_headers src/config.h"
14142 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14143  
8432                    ac_config_files="$ac_config_files make/Makefile src/utils/Makefile"
14144  
8434
14145   cat >confcache <<\_ACEOF
14146   # This file is a shell script that caches the results of configure
14147   # tests run on this system so they can be shared between configure
# Line 8794 | 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 8857 | 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 8962 | Line 14672 | do
14672    # Handling of arguments.
14673    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14674    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14675 +  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14676 +  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14677    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14678    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14679    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
# Line 9049 | 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
9052 s,@PROGNAME@,$PROGNAME,;t t
9053 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 9059 | 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
9075 < s,@F90FLAGS@,$F90FLAGS,;t t
9076 < s,@ac_ct_F90@,$ac_ct_F90,;t t
9077 < s,@PREPFLAG@,$PREPFLAG,;t t
9078 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
9079 < s,@F90LIBS@,$F90LIBS,;t t
9080 < s,@F90_FUNC@,$F90_FUNC,;t t
9081 < s,@F90_FUNC_@,$F90_FUNC_,;t t
9082 < s,@MOD@,$MOD,;t t
9083 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
9084 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
9085 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
9086 < 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
9089 s,@LIBOBJS@,$LIBOBJS,;t t
9090 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
9091 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
9092 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14789   s,@LN_S@,$LN_S,;t t
14790   s,@SET_MAKE@,$SET_MAKE,;t t
14791   s,@RANLIB@,$RANLIB,;t t
14792   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
14793 < s,@YACC@,$YACC,;t t
14794 < s,@LEX@,$LEX,;t t
14795 < s,@LEXLIB@,$LEXLIB,;t t
14796 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14793 > s,@PERLINTERP@,$PERLINTERP,;t t
14794 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14795 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14796 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14797 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14798   s,@AR@,$AR,;t t
14799   s,@PS@,$PS,;t t
14800 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14801 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14802 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14803 + s,@FCLIBS@,$FCLIBS,;t t
14804 + s,@FC_FUNC@,$FC_FUNC,;t t
14805 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14806 + s,@MOD@,$MOD,;t t
14807 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14808 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14809 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14810 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14811 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14812 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14813 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14814 + s,@LIBOBJS@,$LIBOBJS,;t t
14815 + s,@POW_LIB@,$POW_LIB,;t t
14816 + s,@CXXCPP@,$CXXCPP,;t t
14817 + s,@__func__@,$__func__,;t t
14818   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14819   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14820   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14821   s,@MPI_LIB@,$MPI_LIB,;t t
14822   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14823   s,@USE_MPI@,$USE_MPI,;t t
14824 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
14825 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
14826 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
14827 < s,@USE_SPRNG@,$USE_SPRNG,;t t
14828 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
14829 < s,@MKL_LIB@,$MKL_LIB,;t t
14830 < s,@MKL_INC@,$MKL_INC,;t t
9116 < s,@HAVE_MKL@,$HAVE_MKL,;t t
14824 > s,@USE_CGAL@,$USE_CGAL,;t t
14825 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14826 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
14827 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
14828 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
14829 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
14830 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14831   s,@DOXYGEN@,$DOXYGEN,;t t
14832   s,@DOT@,$DOT,;t t
14833   s,@DOC@,$DOC,;t t
# Line 9125 | 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
9128 s,@FFLAGS@,$FFLAGS,;t t
14842   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14843   CEOF
14844  
# Line 9363 | Line 15076 | done
15076      rm -f $tmp/out
15077    fi
15078  
15079 +  # Run the commands associated with the file.
15080 +  case $ac_file in
15081 +    make/Makefile ) chmod 0755 scripts/* ;;
15082 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15083 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15084 +    scripts/filepp ) chmod 0755 scripts/* ;;
15085 +  esac
15086   done
15087   _ACEOF
15088   cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines