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

Comparing trunk/configure (file contents):
Revision 493 by gezelter, Wed Apr 13 22:30:22 2005 UTC vs.
Revision 1197 by chuckv, Thu Dec 6 20:40:07 2007 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 4.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='4.0'
273 > PACKAGE_STRING='OOPSE 4.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX 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 CXXCPP USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug USE_SINGLE_PRECISION CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_CXXFLAGS CGAL_LDFLAGS CGAL_CPPFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 – ac_env_CC_set=${CC+set}
757 – ac_env_CC_value=$CC
758 – ac_cv_env_CC_set=${CC+set}
759 – ac_cv_env_CC_value=$CC
760 – ac_env_CFLAGS_set=${CFLAGS+set}
761 – ac_env_CFLAGS_value=$CFLAGS
762 – ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 – ac_cv_env_CFLAGS_value=$CFLAGS
764 – ac_env_LDFLAGS_set=${LDFLAGS+set}
765 – ac_env_LDFLAGS_value=$LDFLAGS
766 – ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 – ac_cv_env_LDFLAGS_value=$LDFLAGS
768 – ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 – ac_env_CPPFLAGS_value=$CPPFLAGS
770 – ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 – ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
# Line 801 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 4.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 4.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874 +  --enable-single         compile OOPSE in single precision
875 +  --enable-float          synonym for --enable-single
876    --enable-doxygen        enable documentation generation with doxygen (auto)
877    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
878    --enable-html-docs      enable HTML generation with doxygen (yes)
879    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877 –  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880  
881   Optional Packages:
882    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
884 +  --with-perl-shebang     override what perl thinks is the way for the kernel
885 +                          to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891 <  --with-cgal-makefile=FILE  CGAL makefile that should be used
891 >  --with-cgalmakefile=makefile
892 >                          Use the following CGAL makefile
893  
894   Some influential environment variables:
895 <  CC          C compiler command
896 <  CFLAGS      C compiler flags
895 >  CXX         C++ compiler command
896 >  CXXFLAGS    C++ compiler flags
897    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
898                nonstandard directory <lib dir>
899    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
900                headers in a nonstandard directory <include dir>
901 <  CXX         C++ compiler command
902 <  CXXFLAGS    C++ compiler flags
903 <  F90         Fortran 90 compiler command
904 <  F90FLAGS    Fortran 90 compiler flags
901 >  CC          C compiler command
902 >  CFLAGS      C compiler flags
903 >  FC          Fortran compiler command
904 >  FCFLAGS     Fortran compiler flags
905    CPP         C preprocessor
906    CXXCPP      C++ preprocessor
907  
# Line 995 | Line 1004 | if $ac_init_version; then
1004   test -n "$ac_init_help" && exit 0
1005   if $ac_init_version; then
1006    cat <<\_ACEOF
1007 < OOPSE configure 2.0
1007 > OOPSE configure 4.0
1008   generated by GNU Autoconf 2.59
1009  
1010   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1009 | Line 1018 | running configure, to aid debugging if configure makes
1018   This file contains any messages produced by compilers while
1019   running configure, to aid debugging if configure makes a mistake.
1020  
1021 < It was created by OOPSE $as_me 2.0, which was
1021 > It was created by OOPSE $as_me 4.0, which was
1022   generated by GNU Autoconf 2.59.  Invocation command line was
1023  
1024    $ $0 $@
# Line 1371 | Line 1380 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1380   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1381  
1382  
1383 < # This file is part of Autoconf.                       -*- Autoconf -*-
1375 < # Programming languages support.
1376 < # Copyright 2000, 2001
1377 < # Free Software Foundation, Inc.
1378 < #
1379 < # This program is free software; you can redistribute it and/or modify
1380 < # it under the terms of the GNU General Public License as published by
1381 < # the Free Software Foundation; either version 2, or (at your option)
1382 < # any later version.
1383 < #
1384 < # This program is distributed in the hope that it will be useful,
1385 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1386 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1387 < # GNU General Public License for more details.
1388 < #
1389 < # You should have received a copy of the GNU General Public License
1390 < # along with this program; if not, write to the Free Software
1391 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1392 < # 02111-1307, USA.
1393 < #
1394 < # As a special exception, the Free Software Foundation gives unlimited
1395 < # permission to copy, distribute and modify the configure scripts that
1396 < # are the output of Autoconf.  You need not follow the terms of the GNU
1397 < # General Public License when using or distributing such scripts, even
1398 < # though portions of the text of Autoconf appear in them.  The GNU
1399 < # General Public License (GPL) does govern all other use of the material
1400 < # that constitutes the Autoconf program.
1401 < #
1402 < # Certain portions of the Autoconf source text are designed to be copied
1403 < # (in certain cases, depending on the input) into the output of
1404 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1405 < # source text consists of comments plus executable code that decides which
1406 < # of the data portions to output in any given case.  We call these
1407 < # comments and executable code the "non-data" portions.  Autoconf never
1408 < # copies any of the non-data portions into its output.
1409 < #
1410 < # This special exception to the GPL applies to versions of Autoconf
1411 < # released by the Free Software Foundation.  When you make and
1412 < # distribute a modified version of Autoconf, you may extend this special
1413 < # exception to the GPL to apply to your modified version as well, *unless*
1414 < # your modified version has the potential to copy into its output some
1415 < # of the text that was the non-data portion of the version that you started
1416 < # with.  (In other words, unless your change moves or copies text from
1417 < # the non-data portions to the data portions.)  If your modification has
1418 < # such potential, you must delete any notice of this special exception
1419 < # to the GPL from your modified version.
1420 < #
1421 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1422 < # many others).
1383 >          ac_config_headers="$ac_config_headers src/config.h"
1384  
1385  
1425 – # Table of Contents:
1426 – #
1427 – # 1. Language selection
1428 – #    and routines to produce programs in a given language.
1429 – #  a. Fortran 77 (to be moved from aclang.m4)
1430 – #  b. Fortran 90
1431 – #  c. Fortran 95
1432 – #
1433 – # 2. Producing programs in a given language.
1434 – #  a. Fortran 77 (to be moved from aclang.m4)
1435 – #  b. Fortran 90
1436 – #  c. Fortran 95
1437 – #
1438 – # 3. Looking for a compiler
1439 – #    And possibly the associated preprocessor.
1440 – #  a. Fortran 77 (to be moved from aclang.m4)
1441 – #  b. Fortran 90
1442 – #  c. Fortran 95
1443 – #
1444 – # 4. Compilers' characteristics.
1445 – #  a. Fortran 77 (to be moved from aclang.m4)
1446 – #  b. Fortran 90
1447 – #  c. Fortran 95
1386  
1449 – # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1450 – # ---------------------------------------------------------------------------
1451 – #
1452 – # Processing the elements of a list is tedious in shell programming,
1453 – # as lists tend to be implemented as space delimited strings.
1454 – #
1455 – # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1456 – # if ELEMENT is a member of LIST, otherwise it executes
1457 – # ACTION-IF-NOT-FOUND.
1458 – # _AC_LIST_MEMBER_IF
1387  
1388  
1389  
1462 – # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1463 – # -------------------------------------------------
1464 – #
1465 – # Specifying options to the compiler (whether it be the C, C++ or
1466 – # Fortran 77 compiler) that are meant for the linker is compiler
1467 – # dependent.  This macro lets you give options to the compiler that
1468 – # are meant for the linker in a portable, compiler-independent way.
1469 – #
1470 – # This macro take two arguments, a list of linker options that the
1471 – # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1472 – # a shell variable (SHELL-VARIABLE).  The list of linker options are
1473 – # appended to the shell variable in a compiler-dependent way.
1474 – #
1475 – # For example, if the selected language is C, then this:
1476 – #
1477 – #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1478 – #
1479 – # will expand into this if the selected C compiler is gcc:
1480 – #
1481 – #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1482 – #
1483 – # otherwise, it will expand into this:
1484 – #
1485 – #   foo_LDFLAGS"-R /usr/local/lib/foo"
1486 – #
1487 – # You are encouraged to add support for compilers that this macro
1488 – # doesn't currently support.
1489 – # FIXME: Get rid of this macro.
1490 – # _AC_LINKER_OPTION
1390  
1391  
1392  
1494 – ## ----------------------- ##
1495 – ## 1. Language selection.  ##
1496 – ## ----------------------- ##
1393  
1498 – # ----------------------------- #
1499 – # 1b. The Fortran 90 language.  #
1500 – # ----------------------------- #
1394  
1502 – # AC_LANG(Fortran 90)
1503 – # -------------------
1395  
1396  
1397  
1507 – # _AC_LANG_ABBREV(Fortran 90)
1508 – # ---------------------------
1398  
1399  
1400  
1512 – # ----------------------------- #
1513 – # 1c. The Fortran 95 language.  #
1514 – # ----------------------------- #
1401  
1516 – # AC_LANG(Fortran 95)
1517 – # -------------------
1402  
1403  
1404  
1521 – # _AC_LANG_ABBREV(Fortran 95)
1522 – # ---------------------------
1405  
1406  
1407  
1526 – ## ---------------------- ##
1527 – ## 2.Producing programs.  ##
1528 – ## ---------------------- ##
1408  
1530 – # ------------------------ #
1531 – # 2b. Fortran 90 sources.  #
1532 – # ------------------------ #
1409  
1534 – # AC_LANG_SOURCE(Fortran 90)(BODY)
1535 – # --------------------------------
1410  
1411  
1412  
1539 – # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1540 – # -----------------------------------------------
1413  
1414  
1543 – # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1544 – # --------------------------------------------
1415  
1416  
1417  
1548 – # ------------------------ #
1549 – # 2c. Fortran 95 sources.  #
1550 – # ------------------------ #
1418  
1552 – # AC_LANG_SOURCE(Fortran 95)(BODY)
1553 – # --------------------------------
1419  
1420  
1556 – # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1557 – # -----------------------------------------------
1421  
1422  
1560 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1561 – # --------------------------------------------
1423  
1424  
1425  
1565 – ## -------------------------------------------- ##
1566 – ## 3. Looking for Compilers and Preprocessors.  ##
1567 – ## -------------------------------------------- ##
1426  
1569 – # ----------------------------- #
1570 – # 3b. The Fortran 90 compiler.  #
1571 – # ----------------------------- #
1427  
1428 + #
1429 + #
1430 + #
1431  
1574 – # AC_LANG_PREPROC(Fortran 90)
1575 – # ---------------------------
1576 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1432  
1433  
1434  
1580 – # AC_LANG_COMPILER(Fortran 90)
1581 – # ----------------------------
1582 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1583 – # AC_REQUIRE'able.
1435  
1436  
1437 <
1438 < # AC_PROG_F90([COMPILERS...])
1588 < # ---------------------------
1589 < # COMPILERS is a space separated list of Fortran 90 compilers to search
1590 < # for.
1437 > # AC_F90_MODULE_NAMES
1438 > # -------------------
1439   #
1440 < # Compilers are ordered by
1593 < #  1. F90, F95
1594 < #  2. Good/tested native compilers, bad/untested native compilers
1440 > # Figure out how the Fortran 90 compiler constructs module file names
1441   #
1442 < # pgf90 is the Portland Group F90 compilers.
1597 < # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1598 < # lf95 is the Lahey-Fujitsu compiler.
1599 < # epcf90 is the "Edinburgh Portable Compiler" F90.
1600 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1601 < # AC_PROG_F90
1442 > # AC_F90_MODULE_NAMES
1443  
1444  
1604 – # ----------------------------- #
1605 – # 3c. The Fortran 95 compiler.  #
1606 – # ----------------------------- #
1445  
1446  
1609 – # AC_LANG_PREPROC(Fortran 95)
1610 – # ---------------------------
1611 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1447  
1448  
1449  
1615 – # AC_LANG_COMPILER(Fortran 95)
1616 – # ----------------------------
1617 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1618 – # AC_REQUIRE'able.
1450  
1451  
1452  
1622 – # AC_PROG_F95([COMPILERS...])
1623 – # ---------------------------
1624 – # COMPILERS is a space separated list of Fortran 95 compilers to search
1625 – # for.
1626 – #
1627 – # Compilers are ordered by
1628 – #  1. Good/tested native compilers, bad/untested native compilers
1629 – #
1630 – # xlf95 is the IBM (AIX) F95 compiler.
1631 – # lf95 is the Lahey-Fujitsu compiler.
1632 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1633 – # AC_PROG_F95
1453  
1454  
1636 – ## ------------------------------- ##
1637 – ## 4. Compilers' characteristics.  ##
1638 – ## ------------------------------- ##
1455  
1456  
1641 – # ---------------------------------------- #
1642 – # 4b. Fortan 90 compiler characteristics.  #
1643 – # ---------------------------------------- #
1457  
1458  
1646 – # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1647 – # -------------------------------------------------
1648 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1649 – # (which default value, $ac_cv_prog_f90_v, is computed by
1650 – # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1651 – # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1652 – # so that any link flags that are echoed by the compiler appear as
1653 – # space-separated items.
1654 – # _AC_PROG_F90_V_OUTPUT
1459  
1460  
1657 – # _AC_PROG_F90_V
1658 – # --------------
1659 – #
1660 – # Determine the flag that causes the Fortran 90 compiler to print
1661 – # information of library and object files (normally -v)
1662 – # Needed for AC_F90_LIBRARY_FLAGS
1663 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1664 – # _AC_PROG_F90_V
1461  
1462  
1667 – # AC_F90_LIBRARY_LDFLAGS
1668 – # ----------------------
1669 – #
1670 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1671 – # intrinsic and run-time libraries that are required to successfully
1672 – # link a Fortran 90 program or shared library.  The output variable
1673 – # F90LIBS is set to these flags.
1674 – #
1675 – # This macro is intended to be used in those situations when it is
1676 – # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1677 – # program or shared library.
1678 – #
1679 – # For example, if object files from a C++ and Fortran 90 compiler must
1680 – # be linked together, then the C++ compiler/linker must be used for
1681 – # linking (since special C++-ish things need to happen at link time
1682 – # like calling global constructors, instantiating templates, enabling
1683 – # exception support, etc.).
1684 – #
1685 – # However, the Fortran 90 intrinsic and run-time libraries must be
1686 – # linked in as well, but the C++ compiler/linker doesn't know how to
1687 – # add these Fortran 90 libraries.  Hence, the macro
1688 – # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1689 – # libraries.
1690 – #
1691 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1692 – # AC_F90_LIBRARY_LDFLAGS
1463  
1464  
1695 – # _AC_F90_NAME_MANGLING
1696 – # ---------------------
1697 – # Test for the name mangling scheme used by the Fortran 90 compiler.
1698 – #
1699 – # Sets ac_cv_f90_mangling. The value contains three fields, separated
1700 – # by commas:
1701 – #
1702 – # lower case / upper case:
1703 – #    case translation of the Fortan 90 symbols
1704 – # underscore / no underscore:
1705 – #    whether the compiler appends "_" to symbol names
1706 – # extra underscore / no extra underscore:
1707 – #    whether the compiler appends an extra "_" to symbol names already
1708 – #    containing at least one underscore
1709 – #
1710 – # _AC_F90_NAME_MANGLING
1465  
1712 – # The replacement is empty.
1466  
1467  
1468  
1716 – # AC_F90_WRAPPERS
1717 – # ---------------
1718 – # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1719 – # properly mangle the names of C identifiers, and C identifiers with
1720 – # underscores, respectively, so that they match the name mangling
1721 – # scheme used by the Fortran 90 compiler.
1722 – # AC_F90_WRAPPERS
1469  
1470  
1725 – # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1726 – # ------------------------------------
1727 – # For a Fortran subroutine of given NAME, define a shell variable
1728 – # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1729 – # argument is not supplied, it defaults to NAME.
1730 – # AC_F90_FUNC
1471  
1472  
1733 – # ---------------------------------------- #
1734 – # 4c. Fortan 95 compiler characteristics.  #
1735 – # ---------------------------------------- #
1473  
1474  
1738 – # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1739 – # -------------------------------------------------
1740 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1741 – # (which default value, $ac_cv_prog_f95_v, is computed by
1742 – # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1743 – # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1744 – # so that any link flags that are echoed by the compiler appear as
1745 – # space-separated items.
1746 – # _AC_PROG_F95_V_OUTPUT
1475  
1476  
1749 – # _AC_PROG_F95_V
1750 – # --------------
1751 – #
1752 – # Determine the flag that causes the Fortran 95 compiler to print
1753 – # information of library and object files (normally -v)
1754 – # Needed for AC_F95_LIBRARY_FLAGS
1755 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1756 – # _AC_PROG_F95_V
1477  
1478  
1759 – # AC_F95_LIBRARY_LDFLAGS
1760 – # ----------------------
1761 – #
1762 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1763 – # intrinsic and run-time libraries that are required to successfully
1764 – # link a Fortran 95 program or shared library.  The output variable
1765 – # F95LIBS is set to these flags.
1766 – #
1767 – # This macro is intended to be used in those situations when it is
1768 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1769 – # program or shared library.
1770 – #
1771 – # For example, if object files from a C++ and Fortran 95 compiler must
1772 – # be linked together, then the C++ compiler/linker must be used for
1773 – # linking (since special C++-ish things need to happen at link time
1774 – # like calling global constructors, instantiating templates, enabling
1775 – # exception support, etc.).
1776 – #
1777 – # However, the Fortran 95 intrinsic and run-time libraries must be
1778 – # linked in as well, but the C++ compiler/linker doesn't know how to
1779 – # add these Fortran 95 libraries.  Hence, the macro
1780 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1781 – # libraries.
1782 – #
1783 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1784 – # AC_F95_LIBRARY_LDFLAGS
1479  
1480  
1787 – # _AC_F95_NAME_MANGLING
1788 – # ---------------------
1789 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1790 – #
1791 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1792 – # by commas:
1793 – #
1794 – # lower case / upper case:
1795 – #    case translation of the Fortan 95 symbols
1796 – # underscore / no underscore:
1797 – #    whether the compiler appends "_" to symbol names
1798 – # extra underscore / no extra underscore:
1799 – #    whether the compiler appends an extra "_" to symbol names already
1800 – #    containing at least one underscore
1801 – #
1802 – # _AC_F95_NAME_MANGLING
1481  
1804 – # The replacement is empty.
1482  
1483  
1484  
1808 – # AC_F95_WRAPPERS
1809 – # ---------------
1810 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1811 – # properly mangle the names of C identifiers, and C identifiers with
1812 – # underscores, respectively, so that they match the name mangling
1813 – # scheme used by the Fortran 95 compiler.
1814 – # AC_F95_WRAPPERS
1485  
1486  
1817 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1818 – # ------------------------------------
1819 – # For a Fortran subroutine of given NAME, define a shell variable
1820 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1821 – # argument is not supplied, it defaults to NAME.
1822 – # AC_F95_FUNC
1487  
1824 – # AC_F90_MODULE_NAMES
1825 – # -------------------
1826 – #
1827 – # Figure out how the Fortran 90 compiler constructs module file names
1828 – #
1829 – # AC_F90_MODULE_NAMES
1488  
1489  
1490  
# Line 1887 | Line 1545 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1545  
1546  
1547  
1890 – # set program name
1891 – PROGNAME="oopse"
1548  
1549  
1894 – # there are two ways to do debugging.  One with the --enable-debug flag
1895 – # and one using the DEBUG environment variable
1550  
1897 – debug=0
1898 – # Check whether --enable-debug or --disable-debug was given.
1899 – if test "${enable_debug+set}" = set; then
1900 –  enableval="$enable_debug"
1901 –  debug=1
1902 – fi;
1903 – if test "${DEBUG}"; then
1551  
1552 < cat >>confdefs.h <<\_ACEOF
1553 < #define debug 1
1554 < _ACEOF
1552 > # This is taken from http://autoqt.sourceforge.net/
1553 > # Copyright (c) 2002, Geoffrey Wossum
1554 > # All rights reserved.
1555  
1556 <  msg="$msg, debug mode"
1557 < fi
1556 > # Redistribution and use in source and binary forms, with or without
1557 > # modification, are permitted provided that the following conditions are
1558 > # met:
1559  
1560 + #  - Redistributions of source code must retain the above copyright notice,
1561 + #    this list of conditions and the following disclaimer.
1562  
1563 + #  - Redistributions in binary form must reproduce the above copyright
1564 + #    notice, this list of conditions and the following disclaimer in the
1565 + #    documentation and/or other materials provided with the distribution.
1566 +
1567 + #  - Neither the name of Geoffrey Wossum nor the names of its
1568 + #    contributors may be used to endorse or promote products derived from
1569 + #    this software without specific prior written permission.
1570 +
1571 +
1572 + # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1573 + # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
1574 + # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1575 + # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1576 + # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1577 + # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1578 + # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1579 + # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1580 + # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1581 + # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1582 + # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1583 +
1584 +
1585 + # Check for Qt compiler flags, linker flags, and binary packages
1586 +
1587 +
1588 +
1589   # who am i
1590   # Make sure we can run config.sub.
1591   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1968 | Line 1644 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1644  
1645  
1646  
1647 < ac_ext=c
1648 < ac_cpp='$CPP $CPPFLAGS'
1649 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1650 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1651 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1647 > # set program name
1648 > PROGNAME="oopse"
1649 >
1650 >
1651 >
1652 >
1653 > OBJEXT=".$OBJEXT"
1654 >
1655 > OOPSE=oopse
1656 >
1657 > if test "x${prefix}" = "xNONE"
1658 > then
1659 >  OOPSE_HOME=${ac_default_prefix}/oopse
1660 > else
1661 >  OOPSE_HOME=${prefix}/oopse
1662 > fi
1663 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1664 > if test "${enable_oopse_home+set}" = set; then
1665 >  enableval="$enable_oopse_home"
1666 >  OOPSE_HOME="${enableval}"
1667 > fi;
1668 >
1669 > # there are two ways to do debugging.  One with the --enable-debug flag
1670 > # and one using the DEBUG environment variable
1671 >
1672 > debug=0
1673 > # Check whether --enable-debug or --disable-debug was given.
1674 > if test "${enable_debug+set}" = set; then
1675 >  enableval="$enable_debug"
1676 >  debug=1
1677 > fi;
1678 > if test "${DEBUG}"; then
1679 >
1680 > cat >>confdefs.h <<\_ACEOF
1681 > #define debug 1
1682 > _ACEOF
1683 >
1684 >  msg="$msg, debug mode"
1685 > fi
1686 >
1687 >
1688 > # Check whether --enable-single or --disable-single was given.
1689 > if test "${enable_single+set}" = set; then
1690 >  enableval="$enable_single"
1691 >  ok=$enableval
1692 > else
1693 >  ok=no
1694 > fi;
1695 > # Check whether --enable-float or --disable-float was given.
1696 > if test "${enable_float+set}" = set; then
1697 >  enableval="$enable_float"
1698 >  ok=$enableval
1699 > fi;
1700 > if test "$ok" = "yes"; then
1701 >
1702 > cat >>confdefs.h <<\_ACEOF
1703 > #define SINGLE_PRECISION 1
1704 > _ACEOF
1705 >
1706 >        USE_SINGLE_PRECISION=yes
1707 >
1708 > fi
1709 >
1710 > # Checks for programs.
1711 > ac_ext=cc
1712 > ac_cpp='$CXXCPP $CPPFLAGS'
1713 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1714 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1715 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1716   if test -n "$ac_tool_prefix"; then
1717 <  for ac_prog in icc xlc gcc cc
1717 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1718    do
1719      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1720   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1721   echo "$as_me:$LINENO: checking for $ac_word" >&5
1722   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1723 < if test "${ac_cv_prog_CC+set}" = set; then
1723 > if test "${ac_cv_prog_CXX+set}" = set; then
1724    echo $ECHO_N "(cached) $ECHO_C" >&6
1725   else
1726 <  if test -n "$CC"; then
1727 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1726 >  if test -n "$CXX"; then
1727 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1728   else
1729   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1730   for as_dir in $PATH
# Line 1993 | Line 1733 | do
1733    test -z "$as_dir" && as_dir=.
1734    for ac_exec_ext in '' $ac_executable_extensions; do
1735    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1736 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1736 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1737      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1738      break 2
1739    fi
# Line 2002 | Line 1742 | fi
1742  
1743   fi
1744   fi
1745 < CC=$ac_cv_prog_CC
1746 < if test -n "$CC"; then
1747 <  echo "$as_me:$LINENO: result: $CC" >&5
1748 < echo "${ECHO_T}$CC" >&6
1745 > CXX=$ac_cv_prog_CXX
1746 > if test -n "$CXX"; then
1747 >  echo "$as_me:$LINENO: result: $CXX" >&5
1748 > echo "${ECHO_T}$CXX" >&6
1749   else
1750    echo "$as_me:$LINENO: result: no" >&5
1751   echo "${ECHO_T}no" >&6
1752   fi
1753  
1754 <    test -n "$CC" && break
1754 >    test -n "$CXX" && break
1755    done
1756   fi
1757 < if test -z "$CC"; then
1758 <  ac_ct_CC=$CC
1759 <  for ac_prog in icc xlc gcc cc
1757 > if test -z "$CXX"; then
1758 >  ac_ct_CXX=$CXX
1759 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1760   do
1761    # Extract the first word of "$ac_prog", so it can be a program name with args.
1762   set dummy $ac_prog; ac_word=$2
1763   echo "$as_me:$LINENO: checking for $ac_word" >&5
1764   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1765 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1765 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1766    echo $ECHO_N "(cached) $ECHO_C" >&6
1767   else
1768 <  if test -n "$ac_ct_CC"; then
1769 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1768 >  if test -n "$ac_ct_CXX"; then
1769 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1770   else
1771   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1772   for as_dir in $PATH
# Line 2035 | Line 1775 | do
1775    test -z "$as_dir" && as_dir=.
1776    for ac_exec_ext in '' $ac_executable_extensions; do
1777    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1778 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1778 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1779      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1780      break 2
1781    fi
# Line 2044 | Line 1784 | fi
1784  
1785   fi
1786   fi
1787 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1788 < if test -n "$ac_ct_CC"; then
1789 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1790 < echo "${ECHO_T}$ac_ct_CC" >&6
1787 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1788 > if test -n "$ac_ct_CXX"; then
1789 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1790 > echo "${ECHO_T}$ac_ct_CXX" >&6
1791   else
1792    echo "$as_me:$LINENO: result: no" >&5
1793   echo "${ECHO_T}no" >&6
1794   fi
1795  
1796 <  test -n "$ac_ct_CC" && break
1796 >  test -n "$ac_ct_CXX" && break
1797   done
1798 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1799  
1800 <  CC=$ac_ct_CC
1800 >  CXX=$ac_ct_CXX
1801   fi
1802  
1803  
2063 – test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2064 – See \`config.log' for more details." >&5
2065 – echo "$as_me: error: no acceptable C compiler found in \$PATH
2066 – See \`config.log' for more details." >&2;}
2067 –   { (exit 1); exit 1; }; }
2068 –
1804   # Provide some information about the compiler.
1805   echo "$as_me:$LINENO:" \
1806 <     "checking for C compiler version" >&5
1806 >     "checking for C++ compiler version" >&5
1807   ac_compiler=`set X $ac_compile; echo $2`
1808   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1809    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2106 | Line 1841 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1841   # Try to create an executable without -o first, disregard a.out.
1842   # It will help us diagnose broken compilers, and finding out an intuition
1843   # of exeext.
1844 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1845 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1844 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1845 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1846   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1847   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1848    (eval $ac_link_default) 2>&5
# Line 2150 | Line 1885 | sed 's/^/| /' conftest.$ac_ext >&5
1885    echo "$as_me: failed program was:" >&5
1886   sed 's/^/| /' conftest.$ac_ext >&5
1887  
1888 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1888 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1889   See \`config.log' for more details." >&5
1890 < echo "$as_me: error: C compiler cannot create executables
1890 > echo "$as_me: error: C++ compiler cannot create executables
1891   See \`config.log' for more details." >&2;}
1892     { (exit 77); exit 77; }; }
1893   fi
# Line 2163 | Line 1898 | echo "${ECHO_T}$ac_file" >&6
1898  
1899   # Check the compiler produces executables we can run.  If not, either
1900   # the compiler is broken, or we cross compile.
1901 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1902 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1901 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1902 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1903   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1904   # If not cross compiling, check that we can run a simple program.
1905   if test "$cross_compiling" != yes; then
# Line 2179 | Line 1914 | if test "$cross_compiling" != yes; then
1914      if test "$cross_compiling" = maybe; then
1915          cross_compiling=yes
1916      else
1917 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1917 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1918   If you meant to cross compile, use \`--host'.
1919   See \`config.log' for more details." >&5
1920 < echo "$as_me: error: cannot run C compiled programs.
1920 > echo "$as_me: error: cannot run C++ compiled programs.
1921   If you meant to cross compile, use \`--host'.
1922   See \`config.log' for more details." >&2;}
1923     { (exit 1); exit 1; }; }
# Line 2287 | Line 2022 | ac_objext=$OBJEXT
2022   echo "${ECHO_T}$ac_cv_objext" >&6
2023   OBJEXT=$ac_cv_objext
2024   ac_objext=$OBJEXT
2025 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2026 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2027 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
2025 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2026 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2027 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2028    echo $ECHO_N "(cached) $ECHO_C" >&6
2029   else
2030    cat >conftest.$ac_ext <<_ACEOF
# Line 2319 | Line 2054 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2054    cat conftest.err >&5
2055    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2056    (exit $ac_status); } &&
2057 <         { ac_try='test -z "$ac_c_werror_flag"
2057 >         { ac_try='test -z "$ac_cxx_werror_flag"
2058                           || test ! -s conftest.err'
2059    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2060    (eval $ac_try) 2>&5
# Line 2340 | Line 2075 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2075   ac_compiler_gnu=no
2076   fi
2077   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2078 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
2078 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2079  
2080   fi
2081 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2082 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2083 < GCC=`test $ac_compiler_gnu = yes && echo yes`
2084 < ac_test_CFLAGS=${CFLAGS+set}
2085 < ac_save_CFLAGS=$CFLAGS
2086 < CFLAGS="-g"
2087 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2088 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2089 < if test "${ac_cv_prog_cc_g+set}" = set; then
2081 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2082 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2083 > GXX=`test $ac_compiler_gnu = yes && echo yes`
2084 > ac_test_CXXFLAGS=${CXXFLAGS+set}
2085 > ac_save_CXXFLAGS=$CXXFLAGS
2086 > CXXFLAGS="-g"
2087 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2088 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2089 > if test "${ac_cv_prog_cxx_g+set}" = set; then
2090    echo $ECHO_N "(cached) $ECHO_C" >&6
2091   else
2092    cat >conftest.$ac_ext <<_ACEOF
# Line 2378 | Line 2113 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2113    cat conftest.err >&5
2114    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2115    (exit $ac_status); } &&
2116 <         { ac_try='test -z "$ac_c_werror_flag"
2116 >         { ac_try='test -z "$ac_cxx_werror_flag"
2117                           || test ! -s conftest.err'
2118    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2119    (eval $ac_try) 2>&5
# Line 2391 | Line 2126 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2126    ac_status=$?
2127    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2128    (exit $ac_status); }; }; then
2129 <  ac_cv_prog_cc_g=yes
2129 >  ac_cv_prog_cxx_g=yes
2130   else
2131    echo "$as_me: failed program was:" >&5
2132   sed 's/^/| /' conftest.$ac_ext >&5
2133  
2134 < ac_cv_prog_cc_g=no
2134 > ac_cv_prog_cxx_g=no
2135   fi
2136   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2137   fi
2138 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2139 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2140 < if test "$ac_test_CFLAGS" = set; then
2141 <  CFLAGS=$ac_save_CFLAGS
2142 < elif test $ac_cv_prog_cc_g = yes; then
2143 <  if test "$GCC" = yes; then
2144 <    CFLAGS="-g -O2"
2138 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2139 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2140 > if test "$ac_test_CXXFLAGS" = set; then
2141 >  CXXFLAGS=$ac_save_CXXFLAGS
2142 > elif test $ac_cv_prog_cxx_g = yes; then
2143 >  if test "$GXX" = yes; then
2144 >    CXXFLAGS="-g -O2"
2145    else
2146 <    CFLAGS="-g"
2146 >    CXXFLAGS="-g"
2147    fi
2148   else
2149 <  if test "$GCC" = yes; then
2150 <    CFLAGS="-O2"
2149 >  if test "$GXX" = yes; then
2150 >    CXXFLAGS="-O2"
2151    else
2152 <    CFLAGS=
2152 >    CXXFLAGS=
2153    fi
2154   fi
2155 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2421 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2422 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2423 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2424 < else
2425 <  ac_cv_prog_cc_stdc=no
2426 < ac_save_CC=$CC
2427 < cat >conftest.$ac_ext <<_ACEOF
2428 < /* confdefs.h.  */
2429 < _ACEOF
2430 < cat confdefs.h >>conftest.$ac_ext
2431 < cat >>conftest.$ac_ext <<_ACEOF
2432 < /* end confdefs.h.  */
2433 < #include <stdarg.h>
2434 < #include <stdio.h>
2435 < #include <sys/types.h>
2436 < #include <sys/stat.h>
2437 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2438 < struct buf { int x; };
2439 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2440 < static char *e (p, i)
2441 <     char **p;
2442 <     int i;
2443 < {
2444 <  return p[i];
2445 < }
2446 < static char *f (char * (*g) (char **, int), char **p, ...)
2447 < {
2448 <  char *s;
2449 <  va_list v;
2450 <  va_start (v,p);
2451 <  s = g (p, va_arg (v,int));
2452 <  va_end (v);
2453 <  return s;
2454 < }
2455 <
2456 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2457 <   function prototypes and stuff, but not '\xHH' hex character constants.
2458 <   These don't provoke an error unfortunately, instead are silently treated
2459 <   as 'x'.  The following induces an error, until -std1 is added to get
2460 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2461 <   array size at least.  It's necessary to write '\x00'==0 to get something
2462 <   that's true only with -std1.  */
2463 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2464 <
2465 < int test (int i, double x);
2466 < struct s1 {int (*f) (int a);};
2467 < struct s2 {int (*f) (double a);};
2468 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2469 < int argc;
2470 < char **argv;
2471 < int
2472 < main ()
2473 < {
2474 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2475 <  ;
2476 <  return 0;
2477 < }
2478 < _ACEOF
2479 < # Don't try gcc -ansi; that turns off useful extensions and
2480 < # breaks some systems' header files.
2481 < # AIX                   -qlanglvl=ansi
2482 < # Ultrix and OSF/1      -std1
2483 < # HP-UX 10.20 and later -Ae
2484 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2485 < # SVR4                  -Xc -D__EXTENSIONS__
2486 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2487 < do
2488 <  CC="$ac_save_CC $ac_arg"
2489 <  rm -f conftest.$ac_objext
2490 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2491 <  (eval $ac_compile) 2>conftest.er1
2492 <  ac_status=$?
2493 <  grep -v '^ *+' conftest.er1 >conftest.err
2494 <  rm -f conftest.er1
2495 <  cat conftest.err >&5
2496 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2497 <  (exit $ac_status); } &&
2498 <         { ac_try='test -z "$ac_c_werror_flag"
2499 <                         || test ! -s conftest.err'
2500 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2501 <  (eval $ac_try) 2>&5
2502 <  ac_status=$?
2503 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2504 <  (exit $ac_status); }; } &&
2505 <         { ac_try='test -s conftest.$ac_objext'
2506 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2507 <  (eval $ac_try) 2>&5
2508 <  ac_status=$?
2509 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2510 <  (exit $ac_status); }; }; then
2511 <  ac_cv_prog_cc_stdc=$ac_arg
2512 < break
2513 < else
2514 <  echo "$as_me: failed program was:" >&5
2515 < sed 's/^/| /' conftest.$ac_ext >&5
2516 <
2517 < fi
2518 < rm -f conftest.err conftest.$ac_objext
2519 < done
2520 < rm -f conftest.$ac_ext conftest.$ac_objext
2521 < CC=$ac_save_CC
2522 <
2523 < fi
2524 <
2525 < case "x$ac_cv_prog_cc_stdc" in
2526 <  x|xno)
2527 <    echo "$as_me:$LINENO: result: none needed" >&5
2528 < echo "${ECHO_T}none needed" >&6 ;;
2529 <  *)
2530 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2531 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2532 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2533 < esac
2534 <
2535 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2536 < # in C++ we need to declare it.  In case someone uses the same compiler
2537 < # for both compiling C and C++ we need to have the C++ compiler decide
2538 < # the declaration of exit, since it's the most demanding environment.
2539 < cat >conftest.$ac_ext <<_ACEOF
2540 < #ifndef __cplusplus
2541 <  choke me
2542 < #endif
2543 < _ACEOF
2544 < rm -f conftest.$ac_objext
2545 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2546 <  (eval $ac_compile) 2>conftest.er1
2547 <  ac_status=$?
2548 <  grep -v '^ *+' conftest.er1 >conftest.err
2549 <  rm -f conftest.er1
2550 <  cat conftest.err >&5
2551 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2552 <  (exit $ac_status); } &&
2553 <         { ac_try='test -z "$ac_c_werror_flag"
2554 <                         || test ! -s conftest.err'
2555 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2556 <  (eval $ac_try) 2>&5
2557 <  ac_status=$?
2558 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2559 <  (exit $ac_status); }; } &&
2560 <         { ac_try='test -s conftest.$ac_objext'
2561 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2562 <  (eval $ac_try) 2>&5
2563 <  ac_status=$?
2564 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565 <  (exit $ac_status); }; }; then
2566 <  for ac_declaration in \
2155 > for ac_declaration in \
2156     '' \
2157     'extern "C" void std::exit (int) throw (); using std::exit;' \
2158     'extern "C" void std::exit (int); using std::exit;' \
# Line 2596 | Line 2185 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2185    cat conftest.err >&5
2186    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2187    (exit $ac_status); } &&
2188 <         { ac_try='test -z "$ac_c_werror_flag"
2188 >         { ac_try='test -z "$ac_cxx_werror_flag"
2189                           || test ! -s conftest.err'
2190    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2191    (eval $ac_try) 2>&5
# Line 2641 | Line 2230 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2230    cat conftest.err >&5
2231    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2232    (exit $ac_status); } &&
2233 <         { ac_try='test -z "$ac_c_werror_flag"
2233 >         { ac_try='test -z "$ac_cxx_werror_flag"
2234                           || test ! -s conftest.err'
2235    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2236    (eval $ac_try) 2>&5
# Line 2669 | Line 2258 | fi
2258    echo '#endif'             >>confdefs.h
2259   fi
2260  
2672 – else
2673 –  echo "$as_me: failed program was:" >&5
2674 – sed 's/^/| /' conftest.$ac_ext >&5
2675 –
2676 – fi
2677 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2261   ac_ext=c
2262   ac_cpp='$CPP $CPPFLAGS'
2263   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2264   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2265   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2266  
2267 <
2268 < ac_ext=cc
2269 < ac_cpp='$CXXCPP $CPPFLAGS'
2270 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2271 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2689 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2267 > ac_ext=c
2268 > ac_cpp='$CPP $CPPFLAGS'
2269 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2270 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2271 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2272   if test -n "$ac_tool_prefix"; then
2273 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2273 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2274    do
2275      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2276   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2277   echo "$as_me:$LINENO: checking for $ac_word" >&5
2278   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2279 < if test "${ac_cv_prog_CXX+set}" = set; then
2279 > if test "${ac_cv_prog_CC+set}" = set; then
2280    echo $ECHO_N "(cached) $ECHO_C" >&6
2281   else
2282 <  if test -n "$CXX"; then
2283 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2282 >  if test -n "$CC"; then
2283 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2284   else
2285   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2286   for as_dir in $PATH
# Line 2707 | Line 2289 | do
2289    test -z "$as_dir" && as_dir=.
2290    for ac_exec_ext in '' $ac_executable_extensions; do
2291    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2292 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2292 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2293      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2294      break 2
2295    fi
# Line 2716 | Line 2298 | fi
2298  
2299   fi
2300   fi
2301 < CXX=$ac_cv_prog_CXX
2302 < if test -n "$CXX"; then
2303 <  echo "$as_me:$LINENO: result: $CXX" >&5
2304 < echo "${ECHO_T}$CXX" >&6
2301 > CC=$ac_cv_prog_CC
2302 > if test -n "$CC"; then
2303 >  echo "$as_me:$LINENO: result: $CC" >&5
2304 > echo "${ECHO_T}$CC" >&6
2305   else
2306    echo "$as_me:$LINENO: result: no" >&5
2307   echo "${ECHO_T}no" >&6
2308   fi
2309  
2310 <    test -n "$CXX" && break
2310 >    test -n "$CC" && break
2311    done
2312   fi
2313 < if test -z "$CXX"; then
2314 <  ac_ct_CXX=$CXX
2315 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2313 > if test -z "$CC"; then
2314 >  ac_ct_CC=$CC
2315 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2316   do
2317    # Extract the first word of "$ac_prog", so it can be a program name with args.
2318   set dummy $ac_prog; ac_word=$2
2319   echo "$as_me:$LINENO: checking for $ac_word" >&5
2320   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2321 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2321 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2322    echo $ECHO_N "(cached) $ECHO_C" >&6
2323   else
2324 <  if test -n "$ac_ct_CXX"; then
2325 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2324 >  if test -n "$ac_ct_CC"; then
2325 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2326   else
2327   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2328   for as_dir in $PATH
# Line 2749 | Line 2331 | do
2331    test -z "$as_dir" && as_dir=.
2332    for ac_exec_ext in '' $ac_executable_extensions; do
2333    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2334 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2334 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2335      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2336      break 2
2337    fi
# Line 2758 | Line 2340 | fi
2340  
2341   fi
2342   fi
2343 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2344 < if test -n "$ac_ct_CXX"; then
2345 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2346 < echo "${ECHO_T}$ac_ct_CXX" >&6
2343 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2344 > if test -n "$ac_ct_CC"; then
2345 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2346 > echo "${ECHO_T}$ac_ct_CC" >&6
2347   else
2348    echo "$as_me:$LINENO: result: no" >&5
2349   echo "${ECHO_T}no" >&6
2350   fi
2351  
2352 <  test -n "$ac_ct_CXX" && break
2352 >  test -n "$ac_ct_CC" && break
2353   done
2772 – test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2354  
2355 <  CXX=$ac_ct_CXX
2355 >  CC=$ac_ct_CC
2356   fi
2357  
2358  
2359 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2360 + See \`config.log' for more details." >&5
2361 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2362 + See \`config.log' for more details." >&2;}
2363 +   { (exit 1); exit 1; }; }
2364 +
2365   # Provide some information about the compiler.
2366   echo "$as_me:$LINENO:" \
2367 <     "checking for C++ compiler version" >&5
2367 >     "checking for C compiler version" >&5
2368   ac_compiler=`set X $ac_compile; echo $2`
2369   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2370    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2795 | Line 2382 | ac_compiler=`set X $ac_compile; echo $2`
2382    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2383    (exit $ac_status); }
2384  
2385 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2386 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2387 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2385 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2386 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2387 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2388    echo $ECHO_N "(cached) $ECHO_C" >&6
2389   else
2390    cat >conftest.$ac_ext <<_ACEOF
# Line 2827 | Line 2414 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2414    cat conftest.err >&5
2415    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2416    (exit $ac_status); } &&
2417 <         { ac_try='test -z "$ac_cxx_werror_flag"
2417 >         { ac_try='test -z "$ac_c_werror_flag"
2418                           || test ! -s conftest.err'
2419    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2420    (eval $ac_try) 2>&5
# Line 2848 | Line 2435 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2435   ac_compiler_gnu=no
2436   fi
2437   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2438 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2438 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2439  
2440   fi
2441 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2442 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2443 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2444 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2445 < ac_save_CXXFLAGS=$CXXFLAGS
2446 < CXXFLAGS="-g"
2447 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2448 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2449 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2441 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2442 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2443 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2444 > ac_test_CFLAGS=${CFLAGS+set}
2445 > ac_save_CFLAGS=$CFLAGS
2446 > CFLAGS="-g"
2447 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2448 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2449 > if test "${ac_cv_prog_cc_g+set}" = set; then
2450    echo $ECHO_N "(cached) $ECHO_C" >&6
2451   else
2452    cat >conftest.$ac_ext <<_ACEOF
# Line 2886 | Line 2473 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2473    cat conftest.err >&5
2474    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2475    (exit $ac_status); } &&
2476 <         { ac_try='test -z "$ac_cxx_werror_flag"
2476 >         { ac_try='test -z "$ac_c_werror_flag"
2477                           || test ! -s conftest.err'
2478    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2479    (eval $ac_try) 2>&5
# Line 2899 | Line 2486 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2486    ac_status=$?
2487    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2488    (exit $ac_status); }; }; then
2489 <  ac_cv_prog_cxx_g=yes
2489 >  ac_cv_prog_cc_g=yes
2490   else
2491    echo "$as_me: failed program was:" >&5
2492   sed 's/^/| /' conftest.$ac_ext >&5
2493  
2494 < ac_cv_prog_cxx_g=no
2494 > ac_cv_prog_cc_g=no
2495   fi
2496   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2497   fi
2498 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2499 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2500 < if test "$ac_test_CXXFLAGS" = set; then
2501 <  CXXFLAGS=$ac_save_CXXFLAGS
2502 < elif test $ac_cv_prog_cxx_g = yes; then
2503 <  if test "$GXX" = yes; then
2504 <    CXXFLAGS="-g -O2"
2498 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2499 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2500 > if test "$ac_test_CFLAGS" = set; then
2501 >  CFLAGS=$ac_save_CFLAGS
2502 > elif test $ac_cv_prog_cc_g = yes; then
2503 >  if test "$GCC" = yes; then
2504 >    CFLAGS="-g -O2"
2505    else
2506 <    CXXFLAGS="-g"
2506 >    CFLAGS="-g"
2507    fi
2508   else
2509 <  if test "$GXX" = yes; then
2510 <    CXXFLAGS="-O2"
2509 >  if test "$GCC" = yes; then
2510 >    CFLAGS="-O2"
2511    else
2512 <    CXXFLAGS=
2512 >    CFLAGS=
2513    fi
2514   fi
2515 < for ac_declaration in \
2516 <   '' \
2517 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2518 <   'extern "C" void std::exit (int); using std::exit;' \
2519 <   'extern "C" void exit (int) throw ();' \
2520 <   'extern "C" void exit (int);' \
2521 <   'void exit (int);'
2522 < do
2936 <  cat >conftest.$ac_ext <<_ACEOF
2515 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2516 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2517 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2518 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2519 > else
2520 >  ac_cv_prog_cc_stdc=no
2521 > ac_save_CC=$CC
2522 > cat >conftest.$ac_ext <<_ACEOF
2523   /* confdefs.h.  */
2524   _ACEOF
2525   cat confdefs.h >>conftest.$ac_ext
2526   cat >>conftest.$ac_ext <<_ACEOF
2527   /* end confdefs.h.  */
2528 < $ac_declaration
2529 < #include <stdlib.h>
2530 < int
2531 < main ()
2528 > #include <stdarg.h>
2529 > #include <stdio.h>
2530 > #include <sys/types.h>
2531 > #include <sys/stat.h>
2532 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2533 > struct buf { int x; };
2534 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2535 > static char *e (p, i)
2536 >     char **p;
2537 >     int i;
2538   {
2539 < exit (42);
2948 <  ;
2949 <  return 0;
2539 >  return p[i];
2540   }
2541 < _ACEOF
2542 < rm -f conftest.$ac_objext
2543 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2541 > static char *f (char * (*g) (char **, int), char **p, ...)
2542 > {
2543 >  char *s;
2544 >  va_list v;
2545 >  va_start (v,p);
2546 >  s = g (p, va_arg (v,int));
2547 >  va_end (v);
2548 >  return s;
2549 > }
2550 >
2551 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2552 >   function prototypes and stuff, but not '\xHH' hex character constants.
2553 >   These don't provoke an error unfortunately, instead are silently treated
2554 >   as 'x'.  The following induces an error, until -std1 is added to get
2555 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2556 >   array size at least.  It's necessary to write '\x00'==0 to get something
2557 >   that's true only with -std1.  */
2558 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2559 >
2560 > int test (int i, double x);
2561 > struct s1 {int (*f) (int a);};
2562 > struct s2 {int (*f) (double a);};
2563 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2564 > int argc;
2565 > char **argv;
2566 > int
2567 > main ()
2568 > {
2569 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2570 >  ;
2571 >  return 0;
2572 > }
2573 > _ACEOF
2574 > # Don't try gcc -ansi; that turns off useful extensions and
2575 > # breaks some systems' header files.
2576 > # AIX                   -qlanglvl=ansi
2577 > # Ultrix and OSF/1      -std1
2578 > # HP-UX 10.20 and later -Ae
2579 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2580 > # SVR4                  -Xc -D__EXTENSIONS__
2581 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2582 > do
2583 >  CC="$ac_save_CC $ac_arg"
2584 >  rm -f conftest.$ac_objext
2585 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2586    (eval $ac_compile) 2>conftest.er1
2587    ac_status=$?
2588    grep -v '^ *+' conftest.er1 >conftest.err
# Line 2958 | Line 2590 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2590    cat conftest.err >&5
2591    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2592    (exit $ac_status); } &&
2593 <         { ac_try='test -z "$ac_cxx_werror_flag"
2593 >         { ac_try='test -z "$ac_c_werror_flag"
2594                           || test ! -s conftest.err'
2595    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2596    (eval $ac_try) 2>&5
# Line 2971 | Line 2603 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2603    ac_status=$?
2604    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2605    (exit $ac_status); }; }; then
2606 +  ac_cv_prog_cc_stdc=$ac_arg
2607 + break
2608 + else
2609 +  echo "$as_me: failed program was:" >&5
2610 + sed 's/^/| /' conftest.$ac_ext >&5
2611 +
2612 + fi
2613 + rm -f conftest.err conftest.$ac_objext
2614 + done
2615 + rm -f conftest.$ac_ext conftest.$ac_objext
2616 + CC=$ac_save_CC
2617 +
2618 + fi
2619 +
2620 + case "x$ac_cv_prog_cc_stdc" in
2621 +  x|xno)
2622 +    echo "$as_me:$LINENO: result: none needed" >&5
2623 + echo "${ECHO_T}none needed" >&6 ;;
2624 +  *)
2625 +    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2626 + echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2627 +    CC="$CC $ac_cv_prog_cc_stdc" ;;
2628 + esac
2629 +
2630 + # Some people use a C++ compiler to compile C.  Since we use `exit',
2631 + # in C++ we need to declare it.  In case someone uses the same compiler
2632 + # for both compiling C and C++ we need to have the C++ compiler decide
2633 + # the declaration of exit, since it's the most demanding environment.
2634 + cat >conftest.$ac_ext <<_ACEOF
2635 + #ifndef __cplusplus
2636 +  choke me
2637 + #endif
2638 + _ACEOF
2639 + rm -f conftest.$ac_objext
2640 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2641 +  (eval $ac_compile) 2>conftest.er1
2642 +  ac_status=$?
2643 +  grep -v '^ *+' conftest.er1 >conftest.err
2644 +  rm -f conftest.er1
2645 +  cat conftest.err >&5
2646 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2647 +  (exit $ac_status); } &&
2648 +         { ac_try='test -z "$ac_c_werror_flag"
2649 +                         || test ! -s conftest.err'
2650 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2651 +  (eval $ac_try) 2>&5
2652 +  ac_status=$?
2653 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2654 +  (exit $ac_status); }; } &&
2655 +         { ac_try='test -s conftest.$ac_objext'
2656 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2657 +  (eval $ac_try) 2>&5
2658 +  ac_status=$?
2659 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2660 +  (exit $ac_status); }; }; then
2661 +  for ac_declaration in \
2662 +   '' \
2663 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2664 +   'extern "C" void std::exit (int); using std::exit;' \
2665 +   'extern "C" void exit (int) throw ();' \
2666 +   'extern "C" void exit (int);' \
2667 +   'void exit (int);'
2668 + do
2669 +  cat >conftest.$ac_ext <<_ACEOF
2670 + /* confdefs.h.  */
2671 + _ACEOF
2672 + cat confdefs.h >>conftest.$ac_ext
2673 + cat >>conftest.$ac_ext <<_ACEOF
2674 + /* end confdefs.h.  */
2675 + $ac_declaration
2676 + #include <stdlib.h>
2677 + int
2678 + main ()
2679 + {
2680 + exit (42);
2681 +  ;
2682 +  return 0;
2683 + }
2684 + _ACEOF
2685 + rm -f conftest.$ac_objext
2686 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2687 +  (eval $ac_compile) 2>conftest.er1
2688 +  ac_status=$?
2689 +  grep -v '^ *+' conftest.er1 >conftest.err
2690 +  rm -f conftest.er1
2691 +  cat conftest.err >&5
2692 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2693 +  (exit $ac_status); } &&
2694 +         { ac_try='test -z "$ac_c_werror_flag"
2695 +                         || test ! -s conftest.err'
2696 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2697 +  (eval $ac_try) 2>&5
2698 +  ac_status=$?
2699 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2700 +  (exit $ac_status); }; } &&
2701 +         { ac_try='test -s conftest.$ac_objext'
2702 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2703 +  (eval $ac_try) 2>&5
2704 +  ac_status=$?
2705 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2706 +  (exit $ac_status); }; }; then
2707    :
2708   else
2709    echo "$as_me: failed program was:" >&5
# Line 3003 | Line 2736 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2736    cat conftest.err >&5
2737    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2738    (exit $ac_status); } &&
2739 <         { ac_try='test -z "$ac_cxx_werror_flag"
2739 >         { ac_try='test -z "$ac_c_werror_flag"
2740                           || test ! -s conftest.err'
2741    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2742    (eval $ac_try) 2>&5
# Line 3031 | Line 2764 | fi
2764    echo '#endif'             >>confdefs.h
2765   fi
2766  
2767 + else
2768 +  echo "$as_me: failed program was:" >&5
2769 + sed 's/^/| /' conftest.$ac_ext >&5
2770 +
2771 + fi
2772 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2773   ac_ext=c
2774   ac_cpp='$CPP $CPPFLAGS'
2775   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2776   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2777   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2778  
2779 <
2780 < OOPSE_TEMPLATE_FLAGS=""
2781 < if test $ac_cv_cxx_compiler_gnu = no; then
2782 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3044 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3045 <  echo 'void f(){}' > conftest.cc
3046 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3047 <    echo "$as_me:$LINENO: result: yes" >&5
3048 < echo "${ECHO_T}yes" >&6
3049 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3050 <  else
3051 <    echo "$as_me:$LINENO: result: no" >&5
3052 < echo "${ECHO_T}no" >&6
3053 <  fi
3054 <  rm -f conftest*
3055 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3056 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3057 <  echo 'void f(){}' > conftest.cc
3058 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3059 <    echo "$as_me:$LINENO: result: yes" >&5
3060 < echo "${ECHO_T}yes" >&6
3061 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3062 <  else
3063 <    echo "$as_me:$LINENO: result: no" >&5
3064 < echo "${ECHO_T}no" >&6
3065 <  fi
3066 <  rm -f conftest*
3067 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3068 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3069 <  echo 'void f(){}' > conftest.cc
3070 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3071 <    echo "$as_me:$LINENO: result: yes" >&5
3072 < echo "${ECHO_T}yes" >&6
3073 <    OOPSE_TEMPLATE_FLAGS="-pto"
3074 <  else
3075 <    echo "$as_me:$LINENO: result: no" >&5
3076 < echo "${ECHO_T}no" >&6
3077 <  fi
3078 <  rm -f conftest*
3079 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3080 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3081 <  echo 'void f(){}' > conftest.cc
3082 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3083 <    echo "$as_me:$LINENO: result: yes" >&5
3084 < echo "${ECHO_T}yes" >&6
3085 <
3086 <
3087 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3088 <  else
3089 <    echo "$as_me:$LINENO: result: no" >&5
3090 < echo "${ECHO_T}no" >&6
3091 <  fi
3092 < fi
3093 <
3094 <
3095 <
3096 <
3097 < ac_ext=f90
3098 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3099 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3100 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2779 > ac_ext=${FC_SRCEXT-f}
2780 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2781 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2782 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2783   if test -n "$ac_tool_prefix"; then
2784 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2784 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2785    do
2786      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2787   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2788   echo "$as_me:$LINENO: checking for $ac_word" >&5
2789   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2790 < if test "${ac_cv_prog_F90+set}" = set; then
2790 > if test "${ac_cv_prog_FC+set}" = set; then
2791    echo $ECHO_N "(cached) $ECHO_C" >&6
2792   else
2793 <  if test -n "$F90"; then
2794 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2793 >  if test -n "$FC"; then
2794 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2795   else
2796   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2797   for as_dir in $PATH
# Line 3118 | Line 2800 | do
2800    test -z "$as_dir" && as_dir=.
2801    for ac_exec_ext in '' $ac_executable_extensions; do
2802    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2803 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2803 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2804      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2805      break 2
2806    fi
# Line 3127 | Line 2809 | fi
2809  
2810   fi
2811   fi
2812 < F90=$ac_cv_prog_F90
2813 < if test -n "$F90"; then
2814 <  echo "$as_me:$LINENO: result: $F90" >&5
2815 < echo "${ECHO_T}$F90" >&6
2812 > FC=$ac_cv_prog_FC
2813 > if test -n "$FC"; then
2814 >  echo "$as_me:$LINENO: result: $FC" >&5
2815 > echo "${ECHO_T}$FC" >&6
2816   else
2817    echo "$as_me:$LINENO: result: no" >&5
2818   echo "${ECHO_T}no" >&6
2819   fi
2820  
2821 <    test -n "$F90" && break
2821 >    test -n "$FC" && break
2822    done
2823   fi
2824 < if test -z "$F90"; then
2825 <  ac_ct_F90=$F90
2826 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2824 > if test -z "$FC"; then
2825 >  ac_ct_FC=$FC
2826 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2827   do
2828    # Extract the first word of "$ac_prog", so it can be a program name with args.
2829   set dummy $ac_prog; ac_word=$2
2830   echo "$as_me:$LINENO: checking for $ac_word" >&5
2831   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2832 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2832 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2833    echo $ECHO_N "(cached) $ECHO_C" >&6
2834   else
2835 <  if test -n "$ac_ct_F90"; then
2836 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2835 >  if test -n "$ac_ct_FC"; then
2836 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2837   else
2838   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2839   for as_dir in $PATH
# Line 3160 | Line 2842 | do
2842    test -z "$as_dir" && as_dir=.
2843    for ac_exec_ext in '' $ac_executable_extensions; do
2844    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2845 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2845 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2846      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2847      break 2
2848    fi
# Line 3169 | Line 2851 | fi
2851  
2852   fi
2853   fi
2854 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2855 < if test -n "$ac_ct_F90"; then
2856 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2857 < echo "${ECHO_T}$ac_ct_F90" >&6
2854 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2855 > if test -n "$ac_ct_FC"; then
2856 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2857 > echo "${ECHO_T}$ac_ct_FC" >&6
2858   else
2859    echo "$as_me:$LINENO: result: no" >&5
2860   echo "${ECHO_T}no" >&6
2861   fi
2862  
2863 <  test -n "$ac_ct_F90" && break
2863 >  test -n "$ac_ct_FC" && break
2864   done
2865  
2866 <  F90=$ac_ct_F90
2866 >  FC=$ac_ct_FC
2867   fi
2868  
2869  
2870 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2871 < # input file.
2870 > # Provide some information about the compiler.
2871 > echo "$as_me:2871:" \
2872 >     "checking for Fortran compiler version" >&5
2873 > ac_compiler=`set X $ac_compile; echo $2`
2874 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2875 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2876 >  ac_status=$?
2877 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2878 >  (exit $ac_status); }
2879 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2880 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2881 >  ac_status=$?
2882 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883 >  (exit $ac_status); }
2884 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2885 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2886 >  ac_status=$?
2887 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888 >  (exit $ac_status); }
2889 > rm -f a.out
2890 >
2891 > # If we don't use `.F' as extension, the preprocessor is not run on the
2892 > # input file.  (Note that this only needs to work for GNU compilers.)
2893   ac_save_ext=$ac_ext
2894 < ac_ext=F90
2895 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2896 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2897 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2894 > ac_ext=F
2895 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2896 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2897 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2898    echo $ECHO_N "(cached) $ECHO_C" >&6
2899   else
2900    cat >conftest.$ac_ext <<_ACEOF
2901 <
3199 < program main
3200 <
2901 >      program main
2902   #ifndef __GNUC__
2903         choke me
2904   #endif
2905  
2906 < end program main
3206 <
2906 >      end
2907   _ACEOF
2908   rm -f conftest.$ac_objext
2909   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3214 | Line 2914 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2914    cat conftest.err >&5
2915    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2916    (exit $ac_status); } &&
2917 <         { ac_try='test -z "$ac_f90_werror_flag"
2917 >         { ac_try='test -z "$ac_fc_werror_flag"
2918                           || test ! -s conftest.err'
2919    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2920    (eval $ac_try) 2>&5
# Line 3235 | Line 2935 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2935   ac_compiler_gnu=no
2936   fi
2937   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2938 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2938 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2939  
2940   fi
2941 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2942 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2941 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2942 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2943   ac_ext=$ac_save_ext
2944 < G95=`test $ac_compiler_gnu = yes && echo yes`
2945 < ac_ext=c
2946 < ac_cpp='$CPP $CPPFLAGS'
2947 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2948 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2949 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2944 > ac_test_FFLAGS=${FCFLAGS+set}
2945 > ac_save_FFLAGS=$FCFLAGS
2946 > FCFLAGS=
2947 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2948 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2949 > if test "${ac_cv_prog_fc_g+set}" = set; then
2950 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2951 > else
2952 >  FCFLAGS=-g
2953 > cat >conftest.$ac_ext <<_ACEOF
2954 >      program main
2955  
2956 <
3252 <
3253 <
3254 <
3255 < # Try to determine native compiler flags that allow us to use F90 suffix
3256 < # for preprocessed f90 source.
3257 <
3258 < if test "$ac_test_PREPFLAG" != "set"; then
3259 <  PREPFLAG=""
3260 <  case "${host_cpu}-${host_os}" in
3261 <
3262 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3263 <                    PREPFLAG="-fpp1 "
3264 <                fi;;
3265 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3266 <                    PREPFLAG="-qsuffix=cpp=F90 "
3267 <                fi;;
3268 <  *darwin*)
3269 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3270 <                PREPFLAG="-qsuffix=cpp=F90 "
3271 <        fi;;
3272 <  esac
3273 <
3274 <  if test -z "$PREPFLAG"; then
3275 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3276 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3277 <        PREPFLAG=""
3278 <  fi
3279 <
3280 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3281 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3282 <
3283 <
3284 <  ac_ext=f90
3285 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3286 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3287 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3288 <
3289 <  ac_save_ext=$ac_ext
3290 <  ac_ext=F90
3291 <  ac_save_F90FLAGS=$F90FLAGS
3292 <
3293 <  if test "$PREPFLAG"; then
3294 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3295 < fi
3296 <
3297 <    cat >conftest.$ac_ext <<_ACEOF
3298 <
3299 <
3300 < program main
3301 <
3302 <  integer :: i
3303 <  i = 1
3304 <
3305 <
3306 < end program main
3307 <
2956 >      end
2957   _ACEOF
2958   rm -f conftest.$ac_objext
2959   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3315 | Line 2964 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2964    cat conftest.err >&5
2965    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2966    (exit $ac_status); } &&
2967 <         { ac_try='test -z "$ac_f90_werror_flag"
2967 >         { ac_try='test -z "$ac_fc_werror_flag"
2968                           || test ! -s conftest.err'
2969    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2970    (eval $ac_try) 2>&5
# Line 3328 | Line 2977 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2977    ac_status=$?
2978    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2979    (exit $ac_status); }; }; then
2980 <  prepflagworks=1
2980 >  ac_cv_prog_fc_g=yes
2981   else
2982    echo "$as_me: failed program was:" >&5
2983   sed 's/^/| /' conftest.$ac_ext >&5
2984  
2985 < prepflagworks=0
2985 > ac_cv_prog_fc_g=no
2986   fi
2987   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2988  
2989 <  F90FLAGS=$ac_save_F90FLAGS
2990 <  ac_ext=$ac_save_ext
2991 <  ac_ext=c
2989 > fi
2990 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2991 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2992 > if test "$ac_test_FFLAGS" = set; then
2993 >  FCFLAGS=$ac_save_FFLAGS
2994 > elif test $ac_cv_prog_fc_g = yes; then
2995 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2996 >    FCFLAGS="-g -O2"
2997 >  else
2998 >    FCFLAGS="-g"
2999 >  fi
3000 > else
3001 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3002 >    FCFLAGS="-O2"
3003 >  else
3004 >    FCFLAGS=
3005 >  fi
3006 > fi
3007 >
3008 > ac_ext=c
3009   ac_cpp='$CPP $CPPFLAGS'
3010   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3011   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3012   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3013  
3014 + ac_ext=c
3015 + ac_cpp='$CPP $CPPFLAGS'
3016 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3017 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3018 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
3019 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
3020 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
3021 + # On Suns, sometimes $CPP names a directory.
3022 + if test -n "$CPP" && test -d "$CPP"; then
3023 +  CPP=
3024 + fi
3025 + if test -z "$CPP"; then
3026 +  if test "${ac_cv_prog_CPP+set}" = set; then
3027 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3028 + else
3029 +      # Double quotes because CPP needs to be expanded
3030 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
3031 +    do
3032 +      ac_preproc_ok=false
3033 + for ac_c_preproc_warn_flag in '' yes
3034 + do
3035 +  # Use a header file that comes with gcc, so configuring glibc
3036 +  # with a fresh cross-compiler works.
3037 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3038 +  # <limits.h> exists even on freestanding compilers.
3039 +  # On the NeXT, cc -E runs the code through the compiler's parser,
3040 +  # not just through cpp. "Syntax error" is here to catch this case.
3041 +  cat >conftest.$ac_ext <<_ACEOF
3042 + /* confdefs.h.  */
3043 + _ACEOF
3044 + cat confdefs.h >>conftest.$ac_ext
3045 + cat >>conftest.$ac_ext <<_ACEOF
3046 + /* end confdefs.h.  */
3047 + #ifdef __STDC__
3048 + # include <limits.h>
3049 + #else
3050 + # include <assert.h>
3051 + #endif
3052 +                     Syntax error
3053 + _ACEOF
3054 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3055 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3056 +  ac_status=$?
3057 +  grep -v '^ *+' conftest.er1 >conftest.err
3058 +  rm -f conftest.er1
3059 +  cat conftest.err >&5
3060 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3061 +  (exit $ac_status); } >/dev/null; then
3062 +  if test -s conftest.err; then
3063 +    ac_cpp_err=$ac_c_preproc_warn_flag
3064 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3065 +  else
3066 +    ac_cpp_err=
3067 +  fi
3068 + else
3069 +  ac_cpp_err=yes
3070 + fi
3071 + if test -z "$ac_cpp_err"; then
3072 +  :
3073 + else
3074 +  echo "$as_me: failed program was:" >&5
3075 + sed 's/^/| /' conftest.$ac_ext >&5
3076  
3077 <  if test "$prepflagworks" = 1; then
3078 <    echo "$as_me:$LINENO: result: yes" >&5
3079 < echo "${ECHO_T}yes" >&6
3077 >  # Broken: fails on valid input.
3078 > continue
3079 > fi
3080 > rm -f conftest.err conftest.$ac_ext
3081  
3082 +  # OK, works on sane cases.  Now check whether non-existent headers
3083 +  # can be detected and how.
3084 +  cat >conftest.$ac_ext <<_ACEOF
3085 + /* confdefs.h.  */
3086 + _ACEOF
3087 + cat confdefs.h >>conftest.$ac_ext
3088 + cat >>conftest.$ac_ext <<_ACEOF
3089 + /* end confdefs.h.  */
3090 + #include <ac_nonexistent.h>
3091 + _ACEOF
3092 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3093 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3094 +  ac_status=$?
3095 +  grep -v '^ *+' conftest.er1 >conftest.err
3096 +  rm -f conftest.er1
3097 +  cat conftest.err >&5
3098 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3099 +  (exit $ac_status); } >/dev/null; then
3100 +  if test -s conftest.err; then
3101 +    ac_cpp_err=$ac_c_preproc_warn_flag
3102 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3103    else
3104 <    echo "$as_me:$LINENO: result: no" >&5
3355 < echo "${ECHO_T}no" >&6
3356 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3357 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3358 <   { (exit 1); exit 1; }; }
3104 >    ac_cpp_err=
3105    fi
3106 + else
3107 +  ac_cpp_err=yes
3108   fi
3109 + if test -z "$ac_cpp_err"; then
3110 +  # Broken: success on invalid input.
3111 + continue
3112 + else
3113 +  echo "$as_me: failed program was:" >&5
3114 + sed 's/^/| /' conftest.$ac_ext >&5
3115  
3116 +  # Passes both tests.
3117 + ac_preproc_ok=:
3118 + break
3119 + fi
3120 + rm -f conftest.err conftest.$ac_ext
3121  
3122 + done
3123 + # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3124 + rm -f conftest.err conftest.$ac_ext
3125 + if $ac_preproc_ok; then
3126 +  break
3127 + fi
3128  
3129 +    done
3130 +    ac_cv_prog_CPP=$CPP
3131  
3365 –
3366 – # Try to determine native compiler flags that allow us to use F90 suffix
3367 – # for preprocessed f90 source with -D type defines
3368 –
3369 – if test "$ac_test_PREPDEFFLAG" != "set"; then
3370 –  PREPDEFFLAG=""
3371 –  case "${host_cpu}-${host_os}" in
3372 –
3373 –  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3374 –                    PREPDEFFLAG=" "
3375 –                fi;;
3376 –  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3377 –                    PREPDEFFLAG="-WF,"
3378 –                fi;;
3379 –  *darwin*)
3380 –        if test "$F90" = f90 -o "$F90" = xlf90; then
3381 –                PREPDEFFLAG="-WF,"
3382 –        fi;;
3383 –  esac
3384 –
3385 –  if test -z "$PREPDEFFLAG"; then
3386 –        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3387 – echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3388 –        PREPDEFFLAG=" "
3389 –  fi
3390 –
3391 –  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3392 – echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3393 –
3394 –
3395 –  ac_ext=f90
3396 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3397 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3398 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3399 –
3400 –  ac_save_ext=$ac_ext
3401 –  ac_ext=F90
3402 –  ac_save_F90FLAGS=$F90FLAGS
3403 –
3404 –  if test "$PREPDEFFLAG"; then
3405 –  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3132   fi
3133 <
3134 <    cat >conftest.$ac_ext <<_ACEOF
3135 <
3136 <
3137 < program main
3138 <
3139 <  integer :: i
3140 < #ifdef TEST
3141 <  i = 1
3133 >  CPP=$ac_cv_prog_CPP
3134 > else
3135 >  ac_cv_prog_CPP=$CPP
3136 > fi
3137 > echo "$as_me:$LINENO: result: $CPP" >&5
3138 > echo "${ECHO_T}$CPP" >&6
3139 > ac_preproc_ok=false
3140 > for ac_c_preproc_warn_flag in '' yes
3141 > do
3142 >  # Use a header file that comes with gcc, so configuring glibc
3143 >  # with a fresh cross-compiler works.
3144 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3145 >  # <limits.h> exists even on freestanding compilers.
3146 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3147 >  # not just through cpp. "Syntax error" is here to catch this case.
3148 >  cat >conftest.$ac_ext <<_ACEOF
3149 > /* confdefs.h.  */
3150 > _ACEOF
3151 > cat confdefs.h >>conftest.$ac_ext
3152 > cat >>conftest.$ac_ext <<_ACEOF
3153 > /* end confdefs.h.  */
3154 > #ifdef __STDC__
3155 > # include <limits.h>
3156   #else
3157 <  choke me
3157 > # include <assert.h>
3158   #endif
3159 +                     Syntax error
3160 + _ACEOF
3161 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3162 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3163 +  ac_status=$?
3164 +  grep -v '^ *+' conftest.er1 >conftest.err
3165 +  rm -f conftest.er1
3166 +  cat conftest.err >&5
3167 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3168 +  (exit $ac_status); } >/dev/null; then
3169 +  if test -s conftest.err; then
3170 +    ac_cpp_err=$ac_c_preproc_warn_flag
3171 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3172 +  else
3173 +    ac_cpp_err=
3174 +  fi
3175 + else
3176 +  ac_cpp_err=yes
3177 + fi
3178 + if test -z "$ac_cpp_err"; then
3179 +  :
3180 + else
3181 +  echo "$as_me: failed program was:" >&5
3182 + sed 's/^/| /' conftest.$ac_ext >&5
3183  
3184 +  # Broken: fails on valid input.
3185 + continue
3186 + fi
3187 + rm -f conftest.err conftest.$ac_ext
3188  
3189 < end program main
3190 <
3189 >  # OK, works on sane cases.  Now check whether non-existent headers
3190 >  # can be detected and how.
3191 >  cat >conftest.$ac_ext <<_ACEOF
3192 > /* confdefs.h.  */
3193   _ACEOF
3194 < rm -f conftest.$ac_objext
3195 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3196 <  (eval $ac_compile) 2>conftest.er1
3194 > cat confdefs.h >>conftest.$ac_ext
3195 > cat >>conftest.$ac_ext <<_ACEOF
3196 > /* end confdefs.h.  */
3197 > #include <ac_nonexistent.h>
3198 > _ACEOF
3199 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3200 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3201    ac_status=$?
3202    grep -v '^ *+' conftest.er1 >conftest.err
3203    rm -f conftest.er1
3204    cat conftest.err >&5
3205    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3206 <  (exit $ac_status); } &&
3207 <         { ac_try='test -z "$ac_f90_werror_flag"
3208 <                         || test ! -s conftest.err'
3209 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3210 <  (eval $ac_try) 2>&5
3211 <  ac_status=$?
3212 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3439 <  (exit $ac_status); }; } &&
3440 <         { ac_try='test -s conftest.$ac_objext'
3441 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3442 <  (eval $ac_try) 2>&5
3443 <  ac_status=$?
3444 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3445 <  (exit $ac_status); }; }; then
3446 <  prepdefflagworks=1
3206 >  (exit $ac_status); } >/dev/null; then
3207 >  if test -s conftest.err; then
3208 >    ac_cpp_err=$ac_c_preproc_warn_flag
3209 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3210 >  else
3211 >    ac_cpp_err=
3212 >  fi
3213   else
3214 +  ac_cpp_err=yes
3215 + fi
3216 + if test -z "$ac_cpp_err"; then
3217 +  # Broken: success on invalid input.
3218 + continue
3219 + else
3220    echo "$as_me: failed program was:" >&5
3221   sed 's/^/| /' conftest.$ac_ext >&5
3222  
3223 < prepdefflagworks=0
3223 >  # Passes both tests.
3224 > ac_preproc_ok=:
3225 > break
3226   fi
3227 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3227 > rm -f conftest.err conftest.$ac_ext
3228  
3229 <  F90FLAGS=$ac_save_F90FLAGS
3230 <  ac_ext=$ac_save_ext
3231 <  ac_ext=c
3229 > done
3230 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3231 > rm -f conftest.err conftest.$ac_ext
3232 > if $ac_preproc_ok; then
3233 >  :
3234 > else
3235 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3236 > See \`config.log' for more details." >&5
3237 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3238 > See \`config.log' for more details." >&2;}
3239 >   { (exit 1); exit 1; }; }
3240 > fi
3241 >
3242 > ac_ext=c
3243   ac_cpp='$CPP $CPPFLAGS'
3244   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3245   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3246   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3247  
3248 + echo "$as_me:$LINENO: checking for egrep" >&5
3249 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3250 + if test "${ac_cv_prog_egrep+set}" = set; then
3251 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3252 + else
3253 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3254 +    then ac_cv_prog_egrep='grep -E'
3255 +    else ac_cv_prog_egrep='egrep'
3256 +    fi
3257 + fi
3258 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3259 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3260 + EGREP=$ac_cv_prog_egrep
3261  
3262  
3263 <  if test "$prepdefflagworks" = 1; then
3264 <    echo "$as_me:$LINENO: result: yes" >&5
3263 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3264 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3265 > LN_S=$as_ln_s
3266 > if test "$LN_S" = "ln -s"; then
3267 >  echo "$as_me:$LINENO: result: yes" >&5
3268   echo "${ECHO_T}yes" >&6
3269 + else
3270 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3271 + echo "${ECHO_T}no, using $LN_S" >&6
3272 + fi
3273  
3274 <  else
3275 <    echo "$as_me:$LINENO: result: no" >&5
3274 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3275 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3276 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3277 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3278 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3279 > else
3280 >  cat >conftest.make <<\_ACEOF
3281 > all:
3282 >        @echo 'ac_maketemp="$(MAKE)"'
3283 > _ACEOF
3284 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3285 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3286 > if test -n "$ac_maketemp"; then
3287 >  eval ac_cv_prog_make_${ac_make}_set=yes
3288 > else
3289 >  eval ac_cv_prog_make_${ac_make}_set=no
3290 > fi
3291 > rm -f conftest.make
3292 > fi
3293 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3294 >  echo "$as_me:$LINENO: result: yes" >&5
3295 > echo "${ECHO_T}yes" >&6
3296 >  SET_MAKE=
3297 > else
3298 >  echo "$as_me:$LINENO: result: no" >&5
3299   echo "${ECHO_T}no" >&6
3300 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3473 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3474 <   { (exit 1); exit 1; }; }
3475 <  fi
3300 >  SET_MAKE="MAKE=${MAKE-make}"
3301   fi
3302  
3303 < ac_ext=f90
3304 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3305 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3306 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3307 <
3308 <
3309 <
3310 < ac_ext=f90
3311 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3312 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3313 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3314 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3315 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3316 < if test "${ac_cv_prog_f90_v+set}" = set; then
3317 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3303 > if test -n "$ac_tool_prefix"; then
3304 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3305 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3306 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3307 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3308 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3309 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3310 > else
3311 >  if test -n "$RANLIB"; then
3312 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3313 > else
3314 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3315 > for as_dir in $PATH
3316 > do
3317 >  IFS=$as_save_IFS
3318 >  test -z "$as_dir" && as_dir=.
3319 >  for ac_exec_ext in '' $ac_executable_extensions; do
3320 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3321 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3322 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3323 >    break 2
3324 >  fi
3325 > done
3326 > done
3327 >
3328 > fi
3329 > fi
3330 > RANLIB=$ac_cv_prog_RANLIB
3331 > if test -n "$RANLIB"; then
3332 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3333 > echo "${ECHO_T}$RANLIB" >&6
3334   else
3335 <
3336 < cat >conftest.$ac_ext <<_ACEOF
3496 <
3497 < program main
3498 <
3499 <
3500 < end program main
3501 <
3502 < _ACEOF
3503 < rm -f conftest.$ac_objext
3504 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3505 <  (eval $ac_compile) 2>conftest.er1
3506 <  ac_status=$?
3507 <  grep -v '^ *+' conftest.er1 >conftest.err
3508 <  rm -f conftest.er1
3509 <  cat conftest.err >&5
3510 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3511 <  (exit $ac_status); } &&
3512 <         { ac_try='test -z "$ac_f90_werror_flag"
3513 <                         || test ! -s conftest.err'
3514 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3515 <  (eval $ac_try) 2>&5
3516 <  ac_status=$?
3517 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3518 <  (exit $ac_status); }; } &&
3519 <         { ac_try='test -s conftest.$ac_objext'
3520 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3521 <  (eval $ac_try) 2>&5
3522 <  ac_status=$?
3523 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3524 <  (exit $ac_status); }; }; then
3525 <  ac_cv_prog_f90_v=
3526 < # Try some options frequently used verbose output
3527 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3528 <  ac_ext=f90
3529 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3530 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3531 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3532 <
3533 < cat >conftest.$ac_ext <<_ACEOF
3534 <
3535 < program main
3536 <
3537 <
3538 < end program main
3539 <
3540 < _ACEOF
3541 <
3542 < # Compile and link our simple test program by passing a flag (argument
3543 < # 1 to this macro) to the Fortran 90 compiler in order to get
3544 < # "verbose" output that we can then parse for the Fortran 90 linker
3545 < # flags.
3546 < ac_save_F90FLAGS=$F90FLAGS
3547 < F90FLAGS="$F90FLAGS $ac_verb"
3548 <
3549 < (eval echo $as_me:3549: \"$ac_link\") >&5
3550 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3551 < echo "$ac_f90_v_output" >&5
3552 < F90FLAGS=$ac_save_F90FLAGS
3553 <
3554 < rm -f conftest.*
3555 < ac_ext=f90
3556 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3557 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3558 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3559 <
3560 < # If we are using xlf then replace all the commas with spaces.
3561 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3562 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3335 >  echo "$as_me:$LINENO: result: no" >&5
3336 > echo "${ECHO_T}no" >&6
3337   fi
3338  
3565 – # If we are using Cray Fortran then delete quotes.
3566 – # Use "\"" instead of '"' for font-lock-mode.
3567 – # FIXME: a more general fix for quoted arguments with spaces?
3568 – if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3569 –  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3339   fi
3340 <  # look for -l* and *.a constructs in the output
3341 <  for ac_arg in $ac_f90_v_output; do
3342 <     case $ac_arg in
3343 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3344 <          ac_cv_prog_f90_v=$ac_verb
3345 <          break 2 ;;
3346 <     esac
3347 <  done
3340 > if test -z "$ac_cv_prog_RANLIB"; then
3341 >  ac_ct_RANLIB=$RANLIB
3342 >  # Extract the first word of "ranlib", so it can be a program name with args.
3343 > set dummy ranlib; ac_word=$2
3344 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3345 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3346 > if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3347 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3348 > else
3349 >  if test -n "$ac_ct_RANLIB"; then
3350 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3351 > else
3352 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3353 > for as_dir in $PATH
3354 > do
3355 >  IFS=$as_save_IFS
3356 >  test -z "$as_dir" && as_dir=.
3357 >  for ac_exec_ext in '' $ac_executable_extensions; do
3358 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3359 >    ac_cv_prog_ac_ct_RANLIB="ranlib"
3360 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3361 >    break 2
3362 >  fi
3363   done
3364 < if test -z "$ac_cv_prog_f90_v"; then
3365 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3366 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3364 > done
3365 >
3366 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3367   fi
3368 + fi
3369 + ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3370 + if test -n "$ac_ct_RANLIB"; then
3371 +  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3372 + echo "${ECHO_T}$ac_ct_RANLIB" >&6
3373   else
3374 <  echo "$as_me: failed program was:" >&5
3375 < sed 's/^/| /' conftest.$ac_ext >&5
3587 <
3588 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3589 < echo "$as_me: WARNING: compilation failed" >&2;}
3374 >  echo "$as_me:$LINENO: result: no" >&5
3375 > echo "${ECHO_T}no" >&6
3376   fi
3591 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3377  
3378 +  RANLIB=$ac_ct_RANLIB
3379 + else
3380 +  RANLIB="$ac_cv_prog_RANLIB"
3381   fi
3382 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3383 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3384 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3385 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3386 < if test "${ac_cv_flibs+set}" = set; then
3382 >
3383 >
3384 >   # Extract the first word of "perl", so it can be a program name with args.
3385 > set dummy perl; ac_word=$2
3386 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3387 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3388 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3389    echo $ECHO_N "(cached) $ECHO_C" >&6
3390   else
3391 <  if test "x$F90LIBS" != "x"; then
3392 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3393 < else
3391 >  case $PERLINTERP in
3392 >  [\\/]* | ?:[\\/]*)
3393 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3394 >  ;;
3395 >  *)
3396 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3397 > for as_dir in $PATH
3398 > do
3399 >  IFS=$as_save_IFS
3400 >  test -z "$as_dir" && as_dir=.
3401 >  for ac_exec_ext in '' $ac_executable_extensions; do
3402 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3403 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3404 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3405 >    break 2
3406 >  fi
3407 > done
3408 > done
3409  
3410 < ac_ext=f90
3411 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3412 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3608 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3609 <
3610 < cat >conftest.$ac_ext <<_ACEOF
3611 <
3612 < program main
3613 <
3614 <
3615 < end program main
3616 <
3617 < _ACEOF
3618 <
3619 < # Compile and link our simple test program by passing a flag (argument
3620 < # 1 to this macro) to the Fortran 90 compiler in order to get
3621 < # "verbose" output that we can then parse for the Fortran 90 linker
3622 < # flags.
3623 < ac_save_F90FLAGS=$F90FLAGS
3624 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3625 <
3626 < (eval echo $as_me:3626: \"$ac_link\") >&5
3627 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3628 < echo "$ac_f90_v_output" >&5
3629 < F90FLAGS=$ac_save_F90FLAGS
3630 <
3631 < rm -f conftest.*
3632 < ac_ext=f90
3633 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3634 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3635 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3636 <
3637 < # If we are using xlf then replace all the commas with spaces.
3638 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3639 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3410 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3411 >  ;;
3412 > esac
3413   fi
3414 + PERLINTERP=$ac_cv_path_PERLINTERP
3415  
3416 < # If we are using Cray Fortran then delete quotes.
3417 < # Use "\"" instead of '"' for font-lock-mode.
3418 < # FIXME: a more general fix for quoted arguments with spaces?
3419 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3420 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3416 > if test -n "$PERLINTERP"; then
3417 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3418 > echo "${ECHO_T}$PERLINTERP" >&6
3419 > else
3420 >  echo "$as_me:$LINENO: result: no" >&5
3421 > echo "${ECHO_T}no" >&6
3422   fi
3423  
3424 < ac_cv_f90libs=
3424 >   ac_cv_path_perlinterp="$PERLINTERP"
3425 >   _sHpB='#!'
3426  
3651 – # Save positional arguments (if any)
3652 – ac_save_positional="$@"
3427  
3428 < set X $ac_f90_v_output
3429 < while test $# != 1; do
3430 <  shift
3431 <  ac_arg=$1
3432 <  case $ac_arg in
3433 <        [\\/]*.a | ?:[\\/]*.a)
3434 <            ac_exists=false
3435 <  for ac_i in $ac_cv_f90libs; do
3436 <    if test x"$ac_arg" = x"$ac_i"; then
3437 <      ac_exists=true
3428 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3429 > if test "${with_perl_shebang+set}" = set; then
3430 >  withval="$with_perl_shebang"
3431 >  opt_perl_shebang="$withval"
3432 > else
3433 >                opt_perl_shebang="not_set"
3434 > fi;
3435 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3436 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3437 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3438 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3439 > else
3440 >   case "$opt_perl_shebang" in
3441 >                      not_set  ) ax_cv_opt_perl_shebang=''
3442 >                               ;;
3443 >                         *     )
3444 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3445 >                    esac
3446 >
3447 > fi
3448 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3449 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3450 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3451 >     then
3452 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3453 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3454 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3455 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3456 >
3457 > # Automatic detection of sharpbang formula starts here
3458 >     else
3459 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3460 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3461 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3462 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3463 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3464 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3465 > else
3466 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3467 >        if test "x$_somian_kspb_perl" == x
3468 >          then _somian_ksbp_warn_empty='durnit'
3469 >          else
3470 >          case "A$_somian_kspb_perl" in
3471 >                 A#!*perl* )
3472 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3473 >                        ;;
3474 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3475 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3476 >          esac
3477 >        fi
3478 >
3479 > fi
3480 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3481 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3482 > # The above prints Checking ... result message to user.
3483 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3484 >
3485 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3486 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3487 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3488 >    fi
3489 > # Inform user after printing result value
3490 >    if test A${_somian_ksbp_warn_defau+set} == Aset
3491 >      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3492 > echo "$as_me: Maybe Not good -" >&6;}
3493 >           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3494 > echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3495 >      else { echo "$as_me:$LINENO: OK Good result - " >&5
3496 > echo "$as_me: OK Good result - " >&6;}
3497 >           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3498 > echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3499 >    fi
3500 >  fi
3501 >
3502 > # Find a good install program.  We prefer a C program (faster),
3503 > # so one script is as good as another.  But avoid the broken or
3504 > # incompatible versions:
3505 > # SysV /etc/install, /usr/sbin/install
3506 > # SunOS /usr/etc/install
3507 > # IRIX /sbin/install
3508 > # AIX /bin/install
3509 > # AmigaOS /C/install, which installs bootblocks on floppy discs
3510 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3511 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3512 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3513 > # OS/2's system install, which has a completely different semantic
3514 > # ./install, which can be erroneously created by make from ./install.sh.
3515 > echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3516 > echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3517 > if test -z "$INSTALL"; then
3518 > if test "${ac_cv_path_install+set}" = set; then
3519 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3520 > else
3521 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3522 > for as_dir in $PATH
3523 > do
3524 >  IFS=$as_save_IFS
3525 >  test -z "$as_dir" && as_dir=.
3526 >  # Account for people who put trailing slashes in PATH elements.
3527 > case $as_dir/ in
3528 >  ./ | .// | /cC/* | \
3529 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3530 >  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3531 >  /usr/ucb/* ) ;;
3532 >  *)
3533 >    # OSF1 and SCO ODT 3.0 have their own names for install.
3534 >    # Don't use installbsd from OSF since it installs stuff as root
3535 >    # by default.
3536 >    for ac_prog in ginstall scoinst install; do
3537 >      for ac_exec_ext in '' $ac_executable_extensions; do
3538 >        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3539 >          if test $ac_prog = install &&
3540 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3541 >            # AIX install.  It has an incompatible calling convention.
3542 >            :
3543 >          elif test $ac_prog = install &&
3544 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3545 >            # program-specific install script used by HP pwplus--don't use.
3546 >            :
3547 >          else
3548 >            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3549 >            break 3
3550 >          fi
3551 >        fi
3552 >      done
3553 >    done
3554 >    ;;
3555 > esac
3556 > done
3557 >
3558 >
3559 > fi
3560 >  if test "${ac_cv_path_install+set}" = set; then
3561 >    INSTALL=$ac_cv_path_install
3562 >  else
3563 >    # As a last resort, use the slow shell script.  We don't cache a
3564 >    # path for INSTALL within a source directory, because that will
3565 >    # break other packages using the cache if that directory is
3566 >    # removed, or if the path is relative.
3567 >    INSTALL=$ac_install_sh
3568 >  fi
3569 > fi
3570 > echo "$as_me:$LINENO: result: $INSTALL" >&5
3571 > echo "${ECHO_T}$INSTALL" >&6
3572 >
3573 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3574 > # It thinks the first close brace ends the variable substitution.
3575 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3576 >
3577 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3578 >
3579 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3580 >
3581 > case "x$INSTALL" in
3582 >   x/*) ;;
3583 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3584 > esac
3585 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3586 > # Extract the first word of "ar", so it can be a program name with args.
3587 > set dummy ar; ac_word=$2
3588 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3589 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3590 > if test "${ac_cv_prog_AR+set}" = set; then
3591 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3592 > else
3593 >  if test -n "$AR"; then
3594 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3595 > else
3596 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3597 > for as_dir in $PATH
3598 > do
3599 >  IFS=$as_save_IFS
3600 >  test -z "$as_dir" && as_dir=.
3601 >  for ac_exec_ext in '' $ac_executable_extensions; do
3602 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3603 >    ac_cv_prog_AR="ar"
3604 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3605 >    break 2
3606 >  fi
3607 > done
3608 > done
3609 >
3610 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3611 > fi
3612 > fi
3613 > AR=$ac_cv_prog_AR
3614 > if test -n "$AR"; then
3615 >  echo "$as_me:$LINENO: result: $AR" >&5
3616 > echo "${ECHO_T}$AR" >&6
3617 > else
3618 >  echo "$as_me:$LINENO: result: no" >&5
3619 > echo "${ECHO_T}no" >&6
3620 > fi
3621 >
3622 > if test "$AR" = "NONE"; then
3623 >  cat >confcache <<\_ACEOF
3624 > # This file is a shell script that caches the results of configure
3625 > # tests run on this system so they can be shared between configure
3626 > # scripts and configure runs, see configure's option --config-cache.
3627 > # It is not useful on other systems.  If it contains results you don't
3628 > # want to keep, you may remove or edit it.
3629 > #
3630 > # config.status only pays attention to the cache file if you give it
3631 > # the --recheck option to rerun configure.
3632 > #
3633 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3634 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3635 > # following values.
3636 >
3637 > _ACEOF
3638 >
3639 > # The following way of writing the cache mishandles newlines in values,
3640 > # but we know of no workaround that is simple, portable, and efficient.
3641 > # So, don't put newlines in cache variables' values.
3642 > # Ultrix sh set writes to stderr and can't be redirected directly,
3643 > # and sets the high bit in the cache file unless we assign to the vars.
3644 > {
3645 >  (set) 2>&1 |
3646 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3647 >    *ac_space=\ *)
3648 >      # `set' does not quote correctly, so add quotes (double-quote
3649 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3650 >      sed -n \
3651 >        "s/'/'\\\\''/g;
3652 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3653 >      ;;
3654 >    *)
3655 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3656 >      sed -n \
3657 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3658 >      ;;
3659 >    esac;
3660 > } |
3661 >  sed '
3662 >     t clear
3663 >     : clear
3664 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3665 >     t end
3666 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3667 >     : end' >>confcache
3668 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3669 >  if test -w $cache_file; then
3670 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3671 >    cat confcache >$cache_file
3672 >  else
3673 >    echo "not updating unwritable cache $cache_file"
3674 >  fi
3675 > fi
3676 > rm -f confcache
3677 >  exit 1
3678 > fi
3679 > # Extract the first word of "ps", so it can be a program name with args.
3680 > set dummy ps; ac_word=$2
3681 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3682 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3683 > if test "${ac_cv_path_PS+set}" = set; then
3684 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3685 > else
3686 >  case $PS in
3687 >  [\\/]* | ?:[\\/]*)
3688 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3689 >  ;;
3690 >  *)
3691 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3692 > for as_dir in $PATH
3693 > do
3694 >  IFS=$as_save_IFS
3695 >  test -z "$as_dir" && as_dir=.
3696 >  for ac_exec_ext in '' $ac_executable_extensions; do
3697 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3698 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3699 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3700 >    break 2
3701 >  fi
3702 > done
3703 > done
3704 >
3705 >  ;;
3706 > esac
3707 > fi
3708 > PS=$ac_cv_path_PS
3709 >
3710 > if test -n "$PS"; then
3711 >  echo "$as_me:$LINENO: result: $PS" >&5
3712 > echo "${ECHO_T}$PS" >&6
3713 > else
3714 >  echo "$as_me:$LINENO: result: no" >&5
3715 > echo "${ECHO_T}no" >&6
3716 > fi
3717 >
3718 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3719 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3720 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3721 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3722 > else
3723 >
3724 >        if $PS ax -o rss > /dev/null 2>&1; then
3725 >                ac_cv_prog_ps_ax=yes
3726 >        else
3727 >                ac_cv_prog_ps_ax=no
3728 >        fi
3729 >        if $PS -ef -o rss > /dev/null 2>&1; then
3730 >                ac_cv_prog_ps_ef=yes
3731 >        else
3732 >                ac_cv_prog_ps_ef=no
3733 >        fi
3734 >        if test "$ac_cv_prog_ps_ax" = yes; then
3735 >                ac_cv_prog_ps_syntax=BSD
3736 >        else
3737 >                if test "$ac_cv_prog_ps_ef" = yes; then
3738 >                        ac_cv_prog_ps_syntax=POSIX
3739 >                else
3740 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3741 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3742 >   { (exit 1); exit 1; }; }
3743 >                fi
3744 >        fi
3745 >
3746 > fi
3747 > echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3748 > echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3749 >
3750 > cat >>confdefs.h <<_ACEOF
3751 > #define PSCOMMAND $PS
3752 > _ACEOF
3753 >
3754 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3755 >
3756 > cat >>confdefs.h <<\_ACEOF
3757 > #define PSTYPE_IS_BSD 1
3758 > _ACEOF
3759 >
3760 > else
3761 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3762 >
3763 > cat >>confdefs.h <<\_ACEOF
3764 > #define PSTYPE_IS_POSIX 1
3765 > _ACEOF
3766 >
3767 >   else
3768 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3769 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3770 >   { (exit 1); exit 1; }; }
3771 >   fi
3772 > fi
3773 >
3774 > ac_ext=${FC_SRCEXT-f}
3775 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3776 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3777 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3778 >
3779 >
3780 > echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3781 > echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3782 > if test "${ac_cv_fc_srcext_F90+set}" = set; then
3783 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3784 > else
3785 >  ac_ext=F90
3786 > ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3787 > FCFLAGS_SRCEXT=""
3788 > ac_cv_fc_srcext_F90=unknown
3789 > for ac_flag in none -qsuffix=f=F90 -Tf; do
3790 >  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3791 >  cat >conftest.$ac_ext <<_ACEOF
3792 >      program main
3793 >
3794 >      end
3795 > _ACEOF
3796 > rm -f conftest.$ac_objext
3797 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3798 >  (eval $ac_compile) 2>conftest.er1
3799 >  ac_status=$?
3800 >  grep -v '^ *+' conftest.er1 >conftest.err
3801 >  rm -f conftest.er1
3802 >  cat conftest.err >&5
3803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804 >  (exit $ac_status); } &&
3805 >         { ac_try='test -z "$ac_fc_werror_flag"
3806 >                         || test ! -s conftest.err'
3807 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3808 >  (eval $ac_try) 2>&5
3809 >  ac_status=$?
3810 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3811 >  (exit $ac_status); }; } &&
3812 >         { ac_try='test -s conftest.$ac_objext'
3813 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814 >  (eval $ac_try) 2>&5
3815 >  ac_status=$?
3816 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817 >  (exit $ac_status); }; }; then
3818 >  ac_cv_fc_srcext_F90=$ac_flag; break
3819 > else
3820 >  echo "$as_me: failed program was:" >&5
3821 > sed 's/^/| /' conftest.$ac_ext >&5
3822 >
3823 > fi
3824 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3825 > done
3826 > rm -f conftest.$ac_objext conftest.F90
3827 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3828 >
3829 > fi
3830 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3831 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3832 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3833 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3834 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3835 >   { (exit 1); exit 1; }; }
3836 > else
3837 >  FC_SRCEXT=F90
3838 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3839 >    FCFLAGS_SRCEXT=""
3840 >    FCFLAGS_F90=""
3841 >  else
3842 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3843 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3844 >  fi
3845 >
3846 >
3847 > fi
3848 >
3849 >
3850 >
3851 >
3852 >
3853 > # Try to determine native compiler flags that allow us to use F90 suffix
3854 > # for preprocessed f90 source.
3855 >
3856 > if test "$ac_test_PREPFLAG" != "set"; then
3857 >  PREPFLAG=""
3858 >  case "${host_cpu}-${host_os}" in
3859 >
3860 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3861 >                    PREPFLAG="-fpp1 "
3862 >                fi;;
3863 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3864 >                    PREPFLAG="-qsuffix=cpp=F90 "
3865 >                fi;;
3866 >  *darwin*)
3867 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3868 >                PREPFLAG="-qsuffix=cpp=F90 "
3869 >        fi;;
3870 >  esac
3871 >
3872 >  if test -z "$PREPFLAG"; then
3873 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3874 > echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3875 >        PREPFLAG=""
3876 >  fi
3877 >
3878 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3879 > echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3880 >
3881 >
3882 >  ac_ext=${FC_SRCEXT-f}
3883 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3884 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3885 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3886 >
3887 >  ac_save_ext=$ac_ext
3888 >  ac_ext=F90
3889 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3890 >
3891 >  if test "$PREPFLAG"; then
3892 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3893 > fi
3894 >
3895 >    cat >conftest.$ac_ext <<_ACEOF
3896 >
3897 >
3898 > program conftest
3899 >  integer :: i
3900 >  i = 1
3901 > end program conftest
3902 >
3903 > _ACEOF
3904 > rm -f conftest.$ac_objext
3905 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3906 >  (eval $ac_compile) 2>conftest.er1
3907 >  ac_status=$?
3908 >  grep -v '^ *+' conftest.er1 >conftest.err
3909 >  rm -f conftest.er1
3910 >  cat conftest.err >&5
3911 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912 >  (exit $ac_status); } &&
3913 >         { ac_try='test -z "$ac_fc_werror_flag"
3914 >                         || test ! -s conftest.err'
3915 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3916 >  (eval $ac_try) 2>&5
3917 >  ac_status=$?
3918 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3919 >  (exit $ac_status); }; } &&
3920 >         { ac_try='test -s conftest.$ac_objext'
3921 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3922 >  (eval $ac_try) 2>&5
3923 >  ac_status=$?
3924 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3925 >  (exit $ac_status); }; }; then
3926 >  prepflagworks=1
3927 > else
3928 >  echo "$as_me: failed program was:" >&5
3929 > sed 's/^/| /' conftest.$ac_ext >&5
3930 >
3931 > prepflagworks=0
3932 > fi
3933 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3934 >
3935 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3936 >  ac_ext=$ac_save_ext
3937 >  ac_ext=${FC_SRCEXT-f}
3938 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3939 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3940 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3941 >
3942 >
3943 >  if test "$prepflagworks" = 1; then
3944 >    echo "$as_me:$LINENO: result: yes" >&5
3945 > echo "${ECHO_T}yes" >&6
3946 >    FCFLAGS_SRCEXT="${PREPFLAG}"
3947 >
3948 >  else
3949 >    echo "$as_me:$LINENO: result: no" >&5
3950 > echo "${ECHO_T}no" >&6
3951 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3952 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3953 >   { (exit 1); exit 1; }; }
3954 >  fi
3955 > fi
3956 >
3957 >
3958 >
3959 >
3960 >
3961 > # Try to determine native compiler flags that allow us to use F90 suffix
3962 > # for preprocessed f90 source with -D type defines
3963 >
3964 > if test "$ac_test_PREPDEFFLAG" != "set"; then
3965 >  PREPDEFFLAG=""
3966 >  case "${host_cpu}-${host_os}" in
3967 >
3968 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3969 >                    PREPDEFFLAG=" "
3970 >                fi;;
3971 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3972 >                    PREPDEFFLAG="-WF,"
3973 >                fi;;
3974 >  *darwin*)
3975 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3976 >                PREPDEFFLAG="-WF,"
3977 >        fi;;
3978 >  esac
3979 >
3980 >  if test -z "$PREPDEFFLAG"; then
3981 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3982 > echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3983 >        PREPDEFFLAG=" "
3984 >  fi
3985 >
3986 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3987 > echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3988 >
3989 >
3990 >  ac_ext=${FC_SRCEXT-f}
3991 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3992 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3993 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3994 >
3995 >  ac_save_ext=$ac_ext
3996 >  ac_ext=F90
3997 >  ac_save_FCFLAGS=$FCFLAGS
3998 >
3999 >  if test "$PREPDEFFLAG"; then
4000 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
4001 > fi
4002 >
4003 >    cat >conftest.$ac_ext <<_ACEOF
4004 >
4005 >
4006 > program conftest
4007 >  integer :: i
4008 > #ifdef TEST
4009 >  i = 1
4010 > #else
4011 >  choke me
4012 > #endif
4013 > end program conftest
4014 >
4015 > _ACEOF
4016 > rm -f conftest.$ac_objext
4017 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018 >  (eval $ac_compile) 2>conftest.er1
4019 >  ac_status=$?
4020 >  grep -v '^ *+' conftest.er1 >conftest.err
4021 >  rm -f conftest.er1
4022 >  cat conftest.err >&5
4023 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4024 >  (exit $ac_status); } &&
4025 >         { ac_try='test -z "$ac_fc_werror_flag"
4026 >                         || test ! -s conftest.err'
4027 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4028 >  (eval $ac_try) 2>&5
4029 >  ac_status=$?
4030 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031 >  (exit $ac_status); }; } &&
4032 >         { ac_try='test -s conftest.$ac_objext'
4033 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4034 >  (eval $ac_try) 2>&5
4035 >  ac_status=$?
4036 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4037 >  (exit $ac_status); }; }; then
4038 >  prepdefflagworks=1
4039 > else
4040 >  echo "$as_me: failed program was:" >&5
4041 > sed 's/^/| /' conftest.$ac_ext >&5
4042 >
4043 > prepdefflagworks=0
4044 > fi
4045 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4046 >
4047 >  FCFLAGS=$ac_save_FCFLAGS
4048 >  ac_ext=$ac_save_ext
4049 >  ac_ext=${FC_SRCEXT-f}
4050 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4051 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4052 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4053 >
4054 >
4055 >  if test "$prepdefflagworks" = 1; then
4056 >    echo "$as_me:$LINENO: result: yes" >&5
4057 > echo "${ECHO_T}yes" >&6
4058 >
4059 >  else
4060 >    echo "$as_me:$LINENO: result: no" >&5
4061 > echo "${ECHO_T}no" >&6
4062 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4063 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4064 >   { (exit 1); exit 1; }; }
4065 >  fi
4066 > fi
4067 >
4068 > ac_ext=${FC_SRCEXT-f}
4069 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4070 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4071 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4072 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4073 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4074 > if test "${ac_cv_prog_fc_v+set}" = set; then
4075 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4076 > else
4077 >  cat >conftest.$ac_ext <<_ACEOF
4078 >      program main
4079 >
4080 >      end
4081 > _ACEOF
4082 > rm -f conftest.$ac_objext
4083 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4084 >  (eval $ac_compile) 2>conftest.er1
4085 >  ac_status=$?
4086 >  grep -v '^ *+' conftest.er1 >conftest.err
4087 >  rm -f conftest.er1
4088 >  cat conftest.err >&5
4089 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090 >  (exit $ac_status); } &&
4091 >         { ac_try='test -z "$ac_fc_werror_flag"
4092 >                         || test ! -s conftest.err'
4093 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094 >  (eval $ac_try) 2>&5
4095 >  ac_status=$?
4096 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097 >  (exit $ac_status); }; } &&
4098 >         { ac_try='test -s conftest.$ac_objext'
4099 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4100 >  (eval $ac_try) 2>&5
4101 >  ac_status=$?
4102 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103 >  (exit $ac_status); }; }; then
4104 >  ac_cv_prog_fc_v=
4105 > # Try some options frequently used verbose output
4106 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4107 >  cat >conftest.$ac_ext <<_ACEOF
4108 >      program main
4109 >
4110 >      end
4111 > _ACEOF
4112 >
4113 > # Compile and link our simple test program by passing a flag (argument
4114 > # 1 to this macro) to the Fortran compiler in order to get
4115 > # "verbose" output that we can then parse for the Fortran linker
4116 > # flags.
4117 > ac_save_FFLAGS=$FCFLAGS
4118 > FCFLAGS="$FCFLAGS $ac_verb"
4119 > (eval echo $as_me:4119: \"$ac_link\") >&5
4120 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4121 > echo "$ac_fc_v_output" >&5
4122 > FCFLAGS=$ac_save_FFLAGS
4123 >
4124 > rm -f conftest*
4125 >
4126 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4127 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4128 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4129 > ac_fc_v_output="`echo $ac_fc_v_output |
4130 >        grep 'LPATH is:' |
4131 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4132 >
4133 > case $ac_fc_v_output in
4134 >  # If we are using xlf then replace all the commas with spaces.
4135 >  *xlfentry*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4137 >
4138 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4139 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4140 >  *mGLOB_options_string*)
4141 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4142 >
4143 >  # If we are using Cray Fortran then delete quotes.
4144 >  # Use "\"" instead of '"' for font-lock-mode.
4145 >  # FIXME: a more general fix for quoted arguments with spaces?
4146 >  *cft90*)
4147 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4148 > esac
4149 >
4150 >
4151 >  # look for -l* and *.a constructs in the output
4152 >  for ac_arg in $ac_fc_v_output; do
4153 >     case $ac_arg in
4154 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4155 >          ac_cv_prog_fc_v=$ac_verb
4156 >          break 2 ;;
4157 >     esac
4158 >  done
4159 > done
4160 > if test -z "$ac_cv_prog_fc_v"; then
4161 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4162 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4163 > fi
4164 > else
4165 >  echo "$as_me: failed program was:" >&5
4166 > sed 's/^/| /' conftest.$ac_ext >&5
4167 >
4168 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4169 > echo "$as_me: WARNING: compilation failed" >&2;}
4170 > fi
4171 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4172 >
4173 > fi
4174 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4175 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4176 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4177 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4178 > if test "${ac_cv_fc_libs+set}" = set; then
4179 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4180 > else
4181 >  if test "x$FCLIBS" != "x"; then
4182 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4183 > else
4184 >
4185 > cat >conftest.$ac_ext <<_ACEOF
4186 >      program main
4187 >
4188 >      end
4189 > _ACEOF
4190 >
4191 > # Compile and link our simple test program by passing a flag (argument
4192 > # 1 to this macro) to the Fortran compiler in order to get
4193 > # "verbose" output that we can then parse for the Fortran linker
4194 > # flags.
4195 > ac_save_FFLAGS=$FCFLAGS
4196 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4197 > (eval echo $as_me:4197: \"$ac_link\") >&5
4198 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4199 > echo "$ac_fc_v_output" >&5
4200 > FCFLAGS=$ac_save_FFLAGS
4201 >
4202 > rm -f conftest*
4203 >
4204 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4205 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4206 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4207 > ac_fc_v_output="`echo $ac_fc_v_output |
4208 >        grep 'LPATH is:' |
4209 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4210 >
4211 > case $ac_fc_v_output in
4212 >  # If we are using xlf then replace all the commas with spaces.
4213 >  *xlfentry*)
4214 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4215 >
4216 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4217 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4218 >  *mGLOB_options_string*)
4219 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4220 >
4221 >  # If we are using Cray Fortran then delete quotes.
4222 >  # Use "\"" instead of '"' for font-lock-mode.
4223 >  # FIXME: a more general fix for quoted arguments with spaces?
4224 >  *cft90*)
4225 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4226 > esac
4227 >
4228 >
4229 >
4230 > ac_cv_fc_libs=
4231 >
4232 > # Save positional arguments (if any)
4233 > ac_save_positional="$@"
4234 >
4235 > set X $ac_fc_v_output
4236 > while test $# != 1; do
4237 >  shift
4238 >  ac_arg=$1
4239 >  case $ac_arg in
4240 >        [\\/]*.a | ?:[\\/]*.a)
4241 >            ac_exists=false
4242 >  for ac_i in $ac_cv_fc_libs; do
4243 >    if test x"$ac_arg" = x"$ac_i"; then
4244 >      ac_exists=true
4245        break
4246      fi
4247    done
# Line 3668 | Line 4249 | else
4249    if test x"$ac_exists" = xtrue; then
4250    :
4251   else
4252 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4252 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4253   fi
4254  
4255            ;;
4256          -bI:*)
4257              ac_exists=false
4258 <  for ac_i in $ac_cv_f90libs; do
4258 >  for ac_i in $ac_cv_fc_libs; do
4259      if test x"$ac_arg" = x"$ac_i"; then
4260        ac_exists=true
4261        break
# Line 3686 | Line 4267 | else
4267   else
4268    if test "$ac_compiler_gnu" = yes; then
4269    for ac_link_opt in $ac_arg; do
4270 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4270 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4271    done
4272   else
4273 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4273 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4274   fi
4275   fi
4276  
4277            ;;
4278            # Ignore these flags.
4279 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4279 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4280            ;;
4281          -lkernel32)
4282 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4282 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4283            ;;
4284          -[LRuY])
4285            # These flags, when seen by themselves, take an argument.
4286            # We remove the space between option and argument and re-iterate
4287            # unless we find an empty arg or a new option (starting with -)
4288            case $2 in
4289 <             "" | -*);;
4290 <             *)
4289 >             "" | -*);;
4290 >             *)
4291                  ac_arg="$ac_arg$2"
3711 –
4292                  shift; shift
4293                  set X $ac_arg "$@"
4294                  ;;
# Line 3717 | Line 4297 | fi
4297          -YP,*)
4298            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4299                ac_exists=false
4300 <  for ac_i in $ac_cv_f90libs; do
4300 >  for ac_i in $ac_cv_fc_libs; do
4301      if test x"$ac_j" = x"$ac_i"; then
4302        ac_exists=true
4303        break
# Line 3728 | Line 4308 | else
4308    :
4309   else
4310    ac_arg="$ac_arg $ac_j"
4311 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4311 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4312   fi
4313  
4314            done
4315            ;;
4316          -[lLR]*)
4317              ac_exists=false
4318 <  for ac_i in $ac_cv_f90libs; do
4318 >  for ac_i in $ac_cv_fc_libs; do
4319      if test x"$ac_arg" = x"$ac_i"; then
4320        ac_exists=true
4321        break
# Line 3745 | Line 4325 | else
4325    if test x"$ac_exists" = xtrue; then
4326    :
4327   else
4328 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4328 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4329   fi
4330  
4331            ;;
# Line 3760 | Line 4340 | case `(uname -sr) 2>/dev/null` in
4340   # must begin with a "/").
4341   case `(uname -sr) 2>/dev/null` in
4342     "SunOS 5"*)
4343 <      ac_ld_run_path=`echo $ac_f90_v_output |
4343 >      ac_ld_run_path=`echo $ac_fc_v_output |
4344                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4345        test "x$ac_ld_run_path" != x &&
3766 –
4346          if test "$ac_compiler_gnu" = yes; then
4347    for ac_link_opt in $ac_ld_run_path; do
4348 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4348 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4349    done
4350   else
4351 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4351 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4352   fi
4353        ;;
4354   esac
4355 < fi # test "x$F90LIBS" = "x"
4355 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4356  
4357   fi
4358 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4359 < echo "${ECHO_T}$ac_cv_flibs" >&6
4360 < F90LIBS="$ac_cv_f90libs"
4358 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4359 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4360 > FCLIBS="$ac_cv_fc_libs"
4361  
3783 – ac_ext=f90
3784 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3785 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3786 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4362  
4363 + ac_ext=${FC_SRCEXT-f}
4364 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4365 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4366 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4367  
4368 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4369 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4370 < if test "${ac_cv_f90_mangling+set}" = set; then
4368 >
4369 > ac_ext=${FC_SRCEXT-f}
4370 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4371 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4372 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4373 >
4374 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4375 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4376 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4377    echo $ECHO_N "(cached) $ECHO_C" >&6
4378   else
4379 <  ac_ext=f90
4380 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4381 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4382 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3798 < cat >conftest.$ac_ext <<_ACEOF
3799 < subroutine foobar()
3800 < return
3801 < end
3802 < subroutine foo_bar()
3803 < return
3804 < end
3805 < _ACEOF
3806 < rm -f conftest.$ac_objext
3807 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3808 <  (eval $ac_compile) 2>conftest.er1
3809 <  ac_status=$?
3810 <  grep -v '^ *+' conftest.er1 >conftest.err
3811 <  rm -f conftest.er1
3812 <  cat conftest.err >&5
3813 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814 <  (exit $ac_status); } &&
3815 <         { ac_try='test -z "$ac_f90_werror_flag"
3816 <                         || test ! -s conftest.err'
3817 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3818 <  (eval $ac_try) 2>&5
3819 <  ac_status=$?
3820 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821 <  (exit $ac_status); }; } &&
3822 <         { ac_try='test -s conftest.$ac_objext'
3823 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3824 <  (eval $ac_try) 2>&5
3825 <  ac_status=$?
3826 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3827 <  (exit $ac_status); }; }; then
3828 <  mv conftest.$ac_objext cf90_test.$ac_objext
3829 <
3830 <  ac_ext=c
4379 >  ac_fc_dm_save_LIBS=$LIBS
4380 > LIBS="$LIBS $FCLIBS"
4381 > ac_fortran_dm_var=FC_DUMMY_MAIN
4382 > ac_ext=c
4383   ac_cpp='$CPP $CPPFLAGS'
4384   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4385   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4386   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4387  
4388 <  ac_save_LIBS=$LIBS
4389 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3838 <
3839 <  ac_success=no
3840 <  for ac_foobar in foobar FOOBAR; do
3841 <    for ac_underscore in "" "_"; do
3842 <      ac_func="$ac_foobar$ac_underscore"
3843 <      cat >conftest.$ac_ext <<_ACEOF
4388 > # First, try linking without a dummy main:
4389 > cat >conftest.$ac_ext <<_ACEOF
4390   /* confdefs.h.  */
4391   _ACEOF
4392   cat confdefs.h >>conftest.$ac_ext
4393   cat >>conftest.$ac_ext <<_ACEOF
4394   /* end confdefs.h.  */
4395  
4396 < /* Override any gcc2 internal prototype to avoid an error.  */
4397 < #ifdef __cplusplus
4398 < extern "C"
4396 > #ifdef FC_DUMMY_MAIN
4397 > #ifndef FC_DUMMY_MAIN_EQ_F77
4398 > #  ifdef __cplusplus
4399 >     extern "C"
4400 > #  endif
4401 >   int FC_DUMMY_MAIN() { return 1; }
4402   #endif
4403 < /* We use char because int might match the return type of a gcc2
3855 <   builtin and then its argument prototype would still apply.  */
3856 < char $ac_func ();
4403 > #endif
4404   int
4405   main ()
4406   {
4407 < $ac_func ();
4407 >
4408    ;
4409    return 0;
4410   }
# Line 3884 | Line 4431 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4431    ac_status=$?
4432    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4433    (exit $ac_status); }; }; then
4434 <  ac_success=yes; break 2
4434 >  ac_cv_fortran_dummy_main=none
4435   else
4436    echo "$as_me: failed program was:" >&5
4437   sed 's/^/| /' conftest.$ac_ext >&5
4438  
4439 + ac_cv_fortran_dummy_main=unknown
4440   fi
4441   rm -f conftest.err conftest.$ac_objext \
4442        conftest$ac_exeext conftest.$ac_ext
3895 –    done
3896 –  done
4443  
4444 <  if test "$ac_success" = "yes"; then
4445 <     case $ac_foobar in
4446 <        foobar)
3901 <           ac_case=lower
3902 <           ac_foo_bar=foo_bar
3903 <           ;;
3904 <        FOOBAR)
3905 <           ac_case=upper
3906 <           ac_foo_bar=FOO_BAR
3907 <           ;;
3908 <     esac
3909 <
3910 <     ac_success_extra=no
3911 <     for ac_extra in "" "_"; do
3912 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3913 <
3914 <        cat >conftest.$ac_ext <<_ACEOF
4444 > if test $ac_cv_fortran_dummy_main = unknown; then
4445 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4446 >     cat >conftest.$ac_ext <<_ACEOF
4447   /* confdefs.h.  */
4448   _ACEOF
4449   cat confdefs.h >>conftest.$ac_ext
4450   cat >>conftest.$ac_ext <<_ACEOF
4451   /* end confdefs.h.  */
4452 <
4453 < /* Override any gcc2 internal prototype to avoid an error.  */
4454 < #ifdef __cplusplus
4455 < extern "C"
4452 > #define $ac_fortran_dm_var $ac_func
4453 > #ifdef FC_DUMMY_MAIN
4454 > #ifndef FC_DUMMY_MAIN_EQ_F77
4455 > #  ifdef __cplusplus
4456 >     extern "C"
4457 > #  endif
4458 >   int FC_DUMMY_MAIN() { return 1; }
4459   #endif
4460 < /* We use char because int might match the return type of a gcc2
3926 <   builtin and then its argument prototype would still apply.  */
3927 < char $ac_func ();
4460 > #endif
4461   int
4462   main ()
4463   {
4464 < $ac_func ();
4464 >
4465    ;
4466    return 0;
4467   }
# Line 3955 | Line 4488 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4488    ac_status=$?
4489    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4490    (exit $ac_status); }; }; then
4491 <  ac_success_extra=yes; break
4491 >  ac_cv_fortran_dummy_main=$ac_func; break
4492   else
4493    echo "$as_me: failed program was:" >&5
4494   sed 's/^/| /' conftest.$ac_ext >&5
# Line 3963 | Line 4496 | rm -f conftest.err conftest.$ac_objext \
4496   fi
4497   rm -f conftest.err conftest.$ac_objext \
4498        conftest$ac_exeext conftest.$ac_ext
4499 <     done
4499 >   done
4500 > fi
4501 > ac_ext=${FC_SRCEXT-f}
4502 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4503 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4504 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4505 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4506 > rm -f conftest*
4507 > LIBS=$ac_fc_dm_save_LIBS
4508  
4509 <     if test "$ac_success_extra" = "yes"; then
4510 <        ac_cv_f90_mangling="$ac_case case"
4511 <        if test -z "$ac_underscore"; then
4512 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4513 <        else
4514 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4509 > fi
4510 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4511 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4512 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4513 > if test "$FC_DUMMY_MAIN" != unknown; then
4514 >  if test $FC_DUMMY_MAIN != none; then
4515  
4516 <        fi
4517 <        if test -z "$ac_extra"; then
4518 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3978 <        else
3979 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3980 <        fi
3981 <      else
3982 <        ac_cv_f90_mangling="unknown"
3983 <      fi
3984 <  else
3985 <     ac_cv_f90_mangling="unknown"
4516 > cat >>confdefs.h <<_ACEOF
4517 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4518 > _ACEOF
4519  
4520 <  fi
4520 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4521  
4522 + cat >>confdefs.h <<\_ACEOF
4523 + #define FC_DUMMY_MAIN_EQ_F77 1
4524 + _ACEOF
4525 +
4526 +  fi
4527 + fi
4528 + else
4529 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4530 + See \`config.log' for more details." >&5
4531 + echo "$as_me: error: linking to Fortran libraries from C fails
4532 + See \`config.log' for more details." >&2;}
4533 +   { (exit 1); exit 1; }; }
4534 + fi
4535 +
4536 +
4537 + ac_ext=${FC_SRCEXT-f}
4538 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4539 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4540 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4541 +
4542 + ac_ext=${FC_SRCEXT-f}
4543 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4544 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4545 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4546 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4547 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4548 + if test "${ac_cv_fc_mangling+set}" = set; then
4549 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4550 + else
4551 +  cat >conftest.$ac_ext <<_ACEOF
4552 +      subroutine foobar()
4553 +      return
4554 +      end
4555 +      subroutine foo_bar()
4556 +      return
4557 +      end
4558 + _ACEOF
4559 + rm -f conftest.$ac_objext
4560 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4561 +  (eval $ac_compile) 2>conftest.er1
4562 +  ac_status=$?
4563 +  grep -v '^ *+' conftest.er1 >conftest.err
4564 +  rm -f conftest.er1
4565 +  cat conftest.err >&5
4566 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4567 +  (exit $ac_status); } &&
4568 +         { ac_try='test -z "$ac_fc_werror_flag"
4569 +                         || test ! -s conftest.err'
4570 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4571 +  (eval $ac_try) 2>&5
4572 +  ac_status=$?
4573 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4574 +  (exit $ac_status); }; } &&
4575 +         { ac_try='test -s conftest.$ac_objext'
4576 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4577 +  (eval $ac_try) 2>&5
4578 +  ac_status=$?
4579 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4580 +  (exit $ac_status); }; }; then
4581 +  mv conftest.$ac_objext cfortran_test.$ac_objext
4582 +
4583 +  ac_save_LIBS=$LIBS
4584 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4585 +
4586 +  ac_ext=c
4587 + ac_cpp='$CPP $CPPFLAGS'
4588 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4589 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4590 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4591 +  ac_success=no
4592 +  for ac_foobar in foobar FOOBAR; do
4593 +    for ac_underscore in "" "_"; do
4594 +      ac_func="$ac_foobar$ac_underscore"
4595 +      cat >conftest.$ac_ext <<_ACEOF
4596 + /* confdefs.h.  */
4597 + _ACEOF
4598 + cat confdefs.h >>conftest.$ac_ext
4599 + cat >>conftest.$ac_ext <<_ACEOF
4600 + /* end confdefs.h.  */
4601 +
4602 + /* Override any gcc2 internal prototype to avoid an error.  */
4603 + #ifdef __cplusplus
4604 + extern "C"
4605 + #endif
4606 + /* We use char because int might match the return type of a gcc2
4607 +   builtin and then its argument prototype would still apply.  */
4608 + char $ac_func ();
4609 + #ifdef FC_DUMMY_MAIN
4610 + #ifndef FC_DUMMY_MAIN_EQ_F77
4611 + #  ifdef __cplusplus
4612 +     extern "C"
4613 + #  endif
4614 +   int FC_DUMMY_MAIN() { return 1; }
4615 + #endif
4616 + #endif
4617 + int
4618 + main ()
4619 + {
4620 + $ac_func ();
4621 +  ;
4622 +  return 0;
4623 + }
4624 + _ACEOF
4625 + rm -f conftest.$ac_objext conftest$ac_exeext
4626 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4627 +  (eval $ac_link) 2>conftest.er1
4628 +  ac_status=$?
4629 +  grep -v '^ *+' conftest.er1 >conftest.err
4630 +  rm -f conftest.er1
4631 +  cat conftest.err >&5
4632 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4633 +  (exit $ac_status); } &&
4634 +         { ac_try='test -z "$ac_c_werror_flag"
4635 +                         || test ! -s conftest.err'
4636 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4637 +  (eval $ac_try) 2>&5
4638 +  ac_status=$?
4639 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4640 +  (exit $ac_status); }; } &&
4641 +         { ac_try='test -s conftest$ac_exeext'
4642 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4643 +  (eval $ac_try) 2>&5
4644 +  ac_status=$?
4645 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4646 +  (exit $ac_status); }; }; then
4647 +  ac_success=yes; break 2
4648 + else
4649 +  echo "$as_me: failed program was:" >&5
4650 + sed 's/^/| /' conftest.$ac_ext >&5
4651 +
4652 + fi
4653 + rm -f conftest.err conftest.$ac_objext \
4654 +      conftest$ac_exeext conftest.$ac_ext
4655 +    done
4656 +  done
4657 +  ac_ext=${FC_SRCEXT-f}
4658 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4659 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4660 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4661 +
4662 +  if test "$ac_success" = "yes"; then
4663 +     case $ac_foobar in
4664 +        foobar)
4665 +           ac_case=lower
4666 +           ac_foo_bar=foo_bar
4667 +           ;;
4668 +        FOOBAR)
4669 +           ac_case=upper
4670 +           ac_foo_bar=FOO_BAR
4671 +           ;;
4672 +     esac
4673 +
4674 +     ac_ext=c
4675 + ac_cpp='$CPP $CPPFLAGS'
4676 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4677 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4678 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4679 +     ac_success_extra=no
4680 +     for ac_extra in "" "_"; do
4681 +        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4682 +        cat >conftest.$ac_ext <<_ACEOF
4683 + /* confdefs.h.  */
4684 + _ACEOF
4685 + cat confdefs.h >>conftest.$ac_ext
4686 + cat >>conftest.$ac_ext <<_ACEOF
4687 + /* end confdefs.h.  */
4688 +
4689 + /* Override any gcc2 internal prototype to avoid an error.  */
4690 + #ifdef __cplusplus
4691 + extern "C"
4692 + #endif
4693 + /* We use char because int might match the return type of a gcc2
4694 +   builtin and then its argument prototype would still apply.  */
4695 + char $ac_func ();
4696 + #ifdef FC_DUMMY_MAIN
4697 + #ifndef FC_DUMMY_MAIN_EQ_F77
4698 + #  ifdef __cplusplus
4699 +     extern "C"
4700 + #  endif
4701 +   int FC_DUMMY_MAIN() { return 1; }
4702 + #endif
4703 + #endif
4704 + int
4705 + main ()
4706 + {
4707 + $ac_func ();
4708 +  ;
4709 +  return 0;
4710 + }
4711 + _ACEOF
4712 + rm -f conftest.$ac_objext conftest$ac_exeext
4713 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4714 +  (eval $ac_link) 2>conftest.er1
4715 +  ac_status=$?
4716 +  grep -v '^ *+' conftest.er1 >conftest.err
4717 +  rm -f conftest.er1
4718 +  cat conftest.err >&5
4719 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4720 +  (exit $ac_status); } &&
4721 +         { ac_try='test -z "$ac_c_werror_flag"
4722 +                         || test ! -s conftest.err'
4723 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4724 +  (eval $ac_try) 2>&5
4725 +  ac_status=$?
4726 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4727 +  (exit $ac_status); }; } &&
4728 +         { ac_try='test -s conftest$ac_exeext'
4729 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4730 +  (eval $ac_try) 2>&5
4731 +  ac_status=$?
4732 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4733 +  (exit $ac_status); }; }; then
4734 +  ac_success_extra=yes; break
4735 + else
4736 +  echo "$as_me: failed program was:" >&5
4737 + sed 's/^/| /' conftest.$ac_ext >&5
4738 +
4739 + fi
4740 + rm -f conftest.err conftest.$ac_objext \
4741 +      conftest$ac_exeext conftest.$ac_ext
4742 +     done
4743 +     ac_ext=${FC_SRCEXT-f}
4744 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4745 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4746 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4747 +
4748 +     if test "$ac_success_extra" = "yes"; then
4749 +        ac_cv_fc_mangling="$ac_case case"
4750 +        if test -z "$ac_underscore"; then
4751 +           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4752 +        else
4753 +           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4754 +        fi
4755 +        if test -z "$ac_extra"; then
4756 +           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4757 +        else
4758 +           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4759 +        fi
4760 +      else
4761 +        ac_cv_fc_mangling="unknown"
4762 +      fi
4763 +  else
4764 +     ac_cv_fc_mangling="unknown"
4765 +  fi
4766 +
4767    LIBS=$ac_save_LIBS
4768 <  ac_ext=f90
3991 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3992 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3993 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3994 <  rm -f cf90_test* conftest*
4768 >  rm -f cfortran_test* conftest*
4769   else
4770    echo "$as_me: failed program was:" >&5
4771   sed 's/^/| /' conftest.$ac_ext >&5
4772  
4773 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4774 + See \`config.log' for more details." >&5
4775 + echo "$as_me: error: cannot compile a simple Fortran program
4776 + See \`config.log' for more details." >&2;}
4777 +   { (exit 1); exit 1; }; }
4778   fi
4779   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4001 – ac_ext=f90
4002 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4003 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4004 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4780  
4781   fi
4782 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4783 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4782 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4783 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4784  
4785 + ac_ext=${FC_SRCEXT-f}
4786 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4787 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4788 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4789  
4790 + ac_ext=${FC_SRCEXT-f}
4791 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4792 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4793 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4794  
4795 < case $ac_cv_f90_mangling in
4795 >
4796 > case $ac_cv_fc_mangling in
4797    "lower case, no underscore, no extra underscore")
4798            cat >>confdefs.h <<\_ACEOF
4799 < #define F90_FUNC(name,NAME) name
4799 > #define FC_FUNC(name,NAME) name
4800   _ACEOF
4801  
4802            cat >>confdefs.h <<\_ACEOF
4803 < #define F90_FUNC_(name,NAME) name
4803 > #define FC_FUNC_(name,NAME) name
4804   _ACEOF
4805   ;;
4806    "lower case, no underscore, extra underscore")
4807            cat >>confdefs.h <<\_ACEOF
4808 < #define F90_FUNC(name,NAME) name
4808 > #define FC_FUNC(name,NAME) name
4809   _ACEOF
4810  
4811            cat >>confdefs.h <<\_ACEOF
4812 < #define F90_FUNC_(name,NAME) name ## _
4812 > #define FC_FUNC_(name,NAME) name ## _
4813   _ACEOF
4814   ;;
4815    "lower case, underscore, no extra underscore")
4816            cat >>confdefs.h <<\_ACEOF
4817 < #define F90_FUNC(name,NAME) name ## _
4817 > #define FC_FUNC(name,NAME) name ## _
4818   _ACEOF
4819  
4820            cat >>confdefs.h <<\_ACEOF
4821 < #define F90_FUNC_(name,NAME) name ## _
4821 > #define FC_FUNC_(name,NAME) name ## _
4822   _ACEOF
4823   ;;
4824    "lower case, underscore, extra underscore")
4825            cat >>confdefs.h <<\_ACEOF
4826 < #define F90_FUNC(name,NAME) name ## _
4826 > #define FC_FUNC(name,NAME) name ## _
4827   _ACEOF
4828  
4829            cat >>confdefs.h <<\_ACEOF
4830 < #define F90_FUNC_(name,NAME) name ## __
4830 > #define FC_FUNC_(name,NAME) name ## __
4831   _ACEOF
4832   ;;
4833    "upper case, no underscore, no extra underscore")
4834            cat >>confdefs.h <<\_ACEOF
4835 < #define F90_FUNC(name,NAME) NAME
4835 > #define FC_FUNC(name,NAME) NAME
4836   _ACEOF
4837  
4838            cat >>confdefs.h <<\_ACEOF
4839 < #define F90_FUNC_(name,NAME) NAME
4839 > #define FC_FUNC_(name,NAME) NAME
4840   _ACEOF
4841   ;;
4842    "upper case, no underscore, extra underscore")
4843            cat >>confdefs.h <<\_ACEOF
4844 < #define F90_FUNC(name,NAME) NAME
4844 > #define FC_FUNC(name,NAME) NAME
4845   _ACEOF
4846  
4847            cat >>confdefs.h <<\_ACEOF
4848 < #define F90_FUNC_(name,NAME) NAME ## _
4848 > #define FC_FUNC_(name,NAME) NAME ## _
4849   _ACEOF
4850   ;;
4851    "upper case, underscore, no extra underscore")
4852            cat >>confdefs.h <<\_ACEOF
4853 < #define F90_FUNC(name,NAME) NAME ## _
4853 > #define FC_FUNC(name,NAME) NAME ## _
4854   _ACEOF
4855  
4856            cat >>confdefs.h <<\_ACEOF
4857 < #define F90_FUNC_(name,NAME) NAME ## _
4857 > #define FC_FUNC_(name,NAME) NAME ## _
4858   _ACEOF
4859   ;;
4860    "upper case, underscore, extra underscore")
4861            cat >>confdefs.h <<\_ACEOF
4862 < #define F90_FUNC(name,NAME) NAME ## _
4862 > #define FC_FUNC(name,NAME) NAME ## _
4863   _ACEOF
4864  
4865            cat >>confdefs.h <<\_ACEOF
4866 < #define F90_FUNC_(name,NAME) NAME ## __
4866 > #define FC_FUNC_(name,NAME) NAME ## __
4867   _ACEOF
4868   ;;
4869    *)
4870 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4871 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4870 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4871 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4872            ;;
4873   esac
4874  
4875 + ac_ext=${FC_SRCEXT-f}
4876 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4877 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4878 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4879  
4880  
4881  
4882 + ac_ext=${FC_SRCEXT-f}
4883 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4884 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4885 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4886 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4887 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4888 + if test "${ac_cv_prog_fc_v+set}" = set; then
4889 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4890 + else
4891 +  cat >conftest.$ac_ext <<_ACEOF
4892 +      program main
4893  
4894 +      end
4895 + _ACEOF
4896 + rm -f conftest.$ac_objext
4897 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4898 +  (eval $ac_compile) 2>conftest.er1
4899 +  ac_status=$?
4900 +  grep -v '^ *+' conftest.er1 >conftest.err
4901 +  rm -f conftest.er1
4902 +  cat conftest.err >&5
4903 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4904 +  (exit $ac_status); } &&
4905 +         { ac_try='test -z "$ac_fc_werror_flag"
4906 +                         || test ! -s conftest.err'
4907 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4908 +  (eval $ac_try) 2>&5
4909 +  ac_status=$?
4910 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4911 +  (exit $ac_status); }; } &&
4912 +         { ac_try='test -s conftest.$ac_objext'
4913 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4914 +  (eval $ac_try) 2>&5
4915 +  ac_status=$?
4916 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4917 +  (exit $ac_status); }; }; then
4918 +  ac_cv_prog_fc_v=
4919 + # Try some options frequently used verbose output
4920 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4921 +  cat >conftest.$ac_ext <<_ACEOF
4922 +      program main
4923 +
4924 +      end
4925 + _ACEOF
4926 +
4927 + # Compile and link our simple test program by passing a flag (argument
4928 + # 1 to this macro) to the Fortran compiler in order to get
4929 + # "verbose" output that we can then parse for the Fortran linker
4930 + # flags.
4931 + ac_save_FFLAGS=$FCFLAGS
4932 + FCFLAGS="$FCFLAGS $ac_verb"
4933 + (eval echo $as_me:4933: \"$ac_link\") >&5
4934 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4935 + echo "$ac_fc_v_output" >&5
4936 + FCFLAGS=$ac_save_FFLAGS
4937 +
4938 + rm -f conftest*
4939 +
4940 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4941 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4942 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4943 + ac_fc_v_output="`echo $ac_fc_v_output |
4944 +        grep 'LPATH is:' |
4945 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4946 +
4947 + case $ac_fc_v_output in
4948 +  # If we are using xlf then replace all the commas with spaces.
4949 +  *xlfentry*)
4950 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4951 +
4952 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4953 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4954 +  *mGLOB_options_string*)
4955 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4956 +
4957 +  # If we are using Cray Fortran then delete quotes.
4958 +  # Use "\"" instead of '"' for font-lock-mode.
4959 +  # FIXME: a more general fix for quoted arguments with spaces?
4960 +  *cft90*)
4961 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4962 + esac
4963 +
4964 +
4965 +  # look for -l* and *.a constructs in the output
4966 +  for ac_arg in $ac_fc_v_output; do
4967 +     case $ac_arg in
4968 +        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4969 +          ac_cv_prog_fc_v=$ac_verb
4970 +          break 2 ;;
4971 +     esac
4972 +  done
4973 + done
4974 + if test -z "$ac_cv_prog_fc_v"; then
4975 +   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4976 + echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4977 + fi
4978 + else
4979 +  echo "$as_me: failed program was:" >&5
4980 + sed 's/^/| /' conftest.$ac_ext >&5
4981 +
4982 + { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4983 + echo "$as_me: WARNING: compilation failed" >&2;}
4984 + fi
4985 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4986 +
4987 + fi
4988 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4989 + echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4990 + echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4991 + echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4992 + if test "${ac_cv_fc_libs+set}" = set; then
4993 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4994 + else
4995 +  if test "x$FCLIBS" != "x"; then
4996 +  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4997 + else
4998 +
4999 + cat >conftest.$ac_ext <<_ACEOF
5000 +      program main
5001 +
5002 +      end
5003 + _ACEOF
5004 +
5005 + # Compile and link our simple test program by passing a flag (argument
5006 + # 1 to this macro) to the Fortran compiler in order to get
5007 + # "verbose" output that we can then parse for the Fortran linker
5008 + # flags.
5009 + ac_save_FFLAGS=$FCFLAGS
5010 + FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5011 + (eval echo $as_me:5011: \"$ac_link\") >&5
5012 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5013 + echo "$ac_fc_v_output" >&5
5014 + FCFLAGS=$ac_save_FFLAGS
5015 +
5016 + rm -f conftest*
5017 +
5018 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5019 + # /foo, /bar, and /baz are search directories for the Fortran linker.
5020 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5021 + ac_fc_v_output="`echo $ac_fc_v_output |
5022 +        grep 'LPATH is:' |
5023 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5024 +
5025 + case $ac_fc_v_output in
5026 +  # If we are using xlf then replace all the commas with spaces.
5027 +  *xlfentry*)
5028 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5029 +
5030 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5031 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
5032 +  *mGLOB_options_string*)
5033 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
5034 +
5035 +  # If we are using Cray Fortran then delete quotes.
5036 +  # Use "\"" instead of '"' for font-lock-mode.
5037 +  # FIXME: a more general fix for quoted arguments with spaces?
5038 +  *cft90*)
5039 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
5040 + esac
5041 +
5042 +
5043 +
5044 + ac_cv_fc_libs=
5045 +
5046 + # Save positional arguments (if any)
5047 + ac_save_positional="$@"
5048 +
5049 + set X $ac_fc_v_output
5050 + while test $# != 1; do
5051 +  shift
5052 +  ac_arg=$1
5053 +  case $ac_arg in
5054 +        [\\/]*.a | ?:[\\/]*.a)
5055 +            ac_exists=false
5056 +  for ac_i in $ac_cv_fc_libs; do
5057 +    if test x"$ac_arg" = x"$ac_i"; then
5058 +      ac_exists=true
5059 +      break
5060 +    fi
5061 +  done
5062 +
5063 +  if test x"$ac_exists" = xtrue; then
5064 +  :
5065 + else
5066 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5067 + fi
5068 +
5069 +          ;;
5070 +        -bI:*)
5071 +            ac_exists=false
5072 +  for ac_i in $ac_cv_fc_libs; do
5073 +    if test x"$ac_arg" = x"$ac_i"; then
5074 +      ac_exists=true
5075 +      break
5076 +    fi
5077 +  done
5078 +
5079 +  if test x"$ac_exists" = xtrue; then
5080 +  :
5081 + else
5082 +  if test "$ac_compiler_gnu" = yes; then
5083 +  for ac_link_opt in $ac_arg; do
5084 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5085 +  done
5086 + else
5087 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5088 + fi
5089 + fi
5090 +
5091 +          ;;
5092 +          # Ignore these flags.
5093 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5094 +          ;;
5095 +        -lkernel32)
5096 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5097 +          ;;
5098 +        -[LRuY])
5099 +          # These flags, when seen by themselves, take an argument.
5100 +          # We remove the space between option and argument and re-iterate
5101 +          # unless we find an empty arg or a new option (starting with -)
5102 +          case $2 in
5103 +             "" | -*);;
5104 +             *)
5105 +                ac_arg="$ac_arg$2"
5106 +                shift; shift
5107 +                set X $ac_arg "$@"
5108 +                ;;
5109 +          esac
5110 +          ;;
5111 +        -YP,*)
5112 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5113 +              ac_exists=false
5114 +  for ac_i in $ac_cv_fc_libs; do
5115 +    if test x"$ac_j" = x"$ac_i"; then
5116 +      ac_exists=true
5117 +      break
5118 +    fi
5119 +  done
5120 +
5121 +  if test x"$ac_exists" = xtrue; then
5122 +  :
5123 + else
5124 +  ac_arg="$ac_arg $ac_j"
5125 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5126 + fi
5127 +
5128 +          done
5129 +          ;;
5130 +        -[lLR]*)
5131 +            ac_exists=false
5132 +  for ac_i in $ac_cv_fc_libs; do
5133 +    if test x"$ac_arg" = x"$ac_i"; then
5134 +      ac_exists=true
5135 +      break
5136 +    fi
5137 +  done
5138 +
5139 +  if test x"$ac_exists" = xtrue; then
5140 +  :
5141 + else
5142 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5143 + fi
5144 +
5145 +          ;;
5146 +          # Ignore everything else.
5147 +  esac
5148 + done
5149 + # restore positional arguments
5150 + set X $ac_save_positional; shift
5151 +
5152 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5153 + # then we insist that the "run path" must be an absolute path (i.e. it
5154 + # must begin with a "/").
5155 + case `(uname -sr) 2>/dev/null` in
5156 +   "SunOS 5"*)
5157 +      ac_ld_run_path=`echo $ac_fc_v_output |
5158 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5159 +      test "x$ac_ld_run_path" != x &&
5160 +        if test "$ac_compiler_gnu" = yes; then
5161 +  for ac_link_opt in $ac_ld_run_path; do
5162 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5163 +  done
5164 + else
5165 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5166 + fi
5167 +      ;;
5168 + esac
5169 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5170 +
5171 + fi
5172 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5173 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5174 + FCLIBS="$ac_cv_fc_libs"
5175 +
5176 +
5177 + ac_ext=${FC_SRCEXT-f}
5178 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5179 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5180 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5181 +
5182 +
5183 +
5184   echo "$as_me:$LINENO: checking for module suffix" >&5
5185   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5186   rm -f conftest*
5187   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5188   rm -f work*
5189 < cat >conftest.f90 <<EOF
5189 > cat >conftest.$ac_ext <<EOF
5190          module conftest
5191          integer n
5192          parameter (n=1)
# Line 4106 | Line 5195 | modcase="lower"
5195   # SGI and absoft compilers generates module name in upper case!
5196   testname="conftest"
5197   modcase="lower"
5198 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5199 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5198 > if (eval $ac_compile) 2>/dev/null ; then
5199 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5200      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5201      if test -z "$MOD" ; then
5202          MOD=`ls CONFTEST* 2>/dev/null \
5203 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5203 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5204          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5205          if test -n "$MOD" ; then
5206              testname="CONFTEST"
# Line 4151 | Line 5240 | rm -f work*
5240   rm -f conftest*
5241   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5242   rm -f work*
5243 < cat >conftest.f90 <<EOF
5243 > cat >conftest.$ac_ext <<EOF
5244          module conftest
5245          integer n
5246          parameter (n=1)
# Line 4159 | Line 5248 | testname="conftest"
5248   EOF
5249   # SGI and absoft compilers generates module name in upper case!
5250   testname="conftest"
5251 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5252 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5251 > if (eval $ac_compile) 2>/dev/null ; then
5252 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5253     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5254     if test -n "$mod" ; then
5255        testname="CONFTEST"
# Line 4169 | Line 5258 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5258     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5259     cp $testname.$MOD conf
5260     rm -f conftest* CONFTEST*
5261 <   cat >conftest1.f90 <<EOF
5261 >   cat >conftest1.$ac_ext <<EOF
5262          program main
5263          use conftest
5264          print *, n
# Line 4177 | Line 5266 | EOF
5266   EOF
5267     F90_WORK_FILES_ARG=""
5268     F90MODINCSPEC=""
5269 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5269 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5270         MODDIRFLAG="-I"
5271         F90MODINCSPEC="-I<dir>"
5272         echo "$as_me:$LINENO: result: -I" >&5
5273   echo "${ECHO_T}-I" >&6
5274 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5274 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5275         MODDIRFLAG="-M"
5276         F90MODINCSPEC="-M<dir>"
5277         echo "$as_me:$LINENO: result: -M" >&5
5278   echo "${ECHO_T}-M" >&6
5279 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5279 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5280         MODDIRFLAG="-p"
5281         F90MODINCSPEC="-p<dir>"
5282         echo "$as_me:$LINENO: result: -p" >&5
# Line 4196 | Line 5285 | echo "${ECHO_T}-p" >&6
5285          cp work.pc conf/mpimod.pc
5286          echo "mpimod.pc" > conf/mpimod.pcl
5287          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5288 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5288 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5289              MODDIRFLAG='-cl,mpimod.pcl'
5290              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5291   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4226 | Line 5315 | else
5315   if test "${ac_cv_f90_module_names+set}" = set; then
5316    echo $ECHO_N "(cached) $ECHO_C" >&6
5317   else
5318 <  ac_ext=f90
5319 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5320 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5321 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5318 >  ac_ext=${FC_SRCEXT-f}
5319 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5320 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5321 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5322  
5323   # carry out the test in a new directory, so that we don't miss anything
5324   mkdir conftest
# Line 4247 | Line 5336 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5336    cat conftest.err >&5
5337    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5338    (exit $ac_status); } &&
5339 <         { ac_try='test -z "$ac_f90_werror_flag"
5339 >         { ac_try='test -z "$ac_fc_werror_flag"
5340                           || test ! -s conftest.err'
5341    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5342    (eval $ac_try) 2>&5
# Line 4363 | Line 5452 | rm -rf conftest
5452   cd ..
5453   # cleanup
5454   rm -rf conftest
5455 < ac_ext=f90
5456 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5457 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5458 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5455 > ac_ext=${FC_SRCEXT-f}
5456 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5457 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5458 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5459  
5460   fi
5461   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4461 | Line 5550 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5550   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5551   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5552  
5553 < ac_ext=c
5554 < ac_cpp='$CPP $CPPFLAGS'
5555 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5556 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5557 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4469 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4470 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4471 < # On Suns, sometimes $CPP names a directory.
4472 < if test -n "$CPP" && test -d "$CPP"; then
4473 <  CPP=
4474 < fi
4475 < if test -z "$CPP"; then
4476 <  if test "${ac_cv_prog_CPP+set}" = set; then
5553 >
5554 >
5555 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5556 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5557 > if test "${ac_cv_lib_m_asin+set}" = set; then
5558    echo $ECHO_N "(cached) $ECHO_C" >&6
5559   else
5560 <      # Double quotes because CPP needs to be expanded
5561 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5562 <    do
4482 <      ac_preproc_ok=false
4483 < for ac_c_preproc_warn_flag in '' yes
4484 < do
4485 <  # Use a header file that comes with gcc, so configuring glibc
4486 <  # with a fresh cross-compiler works.
4487 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4488 <  # <limits.h> exists even on freestanding compilers.
4489 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4490 <  # not just through cpp. "Syntax error" is here to catch this case.
4491 <  cat >conftest.$ac_ext <<_ACEOF
5560 >  ac_check_lib_save_LIBS=$LIBS
5561 > LIBS="-lm  $LIBS"
5562 > cat >conftest.$ac_ext <<_ACEOF
5563   /* confdefs.h.  */
5564   _ACEOF
5565   cat confdefs.h >>conftest.$ac_ext
5566   cat >>conftest.$ac_ext <<_ACEOF
5567   /* end confdefs.h.  */
5568 < #ifdef __STDC__
5569 < # include <limits.h>
5570 < #else
5571 < # include <assert.h>
5568 >
5569 > /* Override any gcc2 internal prototype to avoid an error.  */
5570 > #ifdef __cplusplus
5571 > extern "C"
5572   #endif
5573 <                     Syntax error
5573 > /* We use char because int might match the return type of a gcc2
5574 >   builtin and then its argument prototype would still apply.  */
5575 > char asin ();
5576 > #ifdef FC_DUMMY_MAIN
5577 > #ifndef FC_DUMMY_MAIN_EQ_F77
5578 > #  ifdef __cplusplus
5579 >     extern "C"
5580 > #  endif
5581 >   int FC_DUMMY_MAIN() { return 1; }
5582 > #endif
5583 > #endif
5584 > int
5585 > main ()
5586 > {
5587 > asin ();
5588 >  ;
5589 >  return 0;
5590 > }
5591   _ACEOF
5592 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5593 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5592 > rm -f conftest.$ac_objext conftest$ac_exeext
5593 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5594 >  (eval $ac_link) 2>conftest.er1
5595    ac_status=$?
5596    grep -v '^ *+' conftest.er1 >conftest.err
5597    rm -f conftest.er1
5598    cat conftest.err >&5
5599    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5600 <  (exit $ac_status); } >/dev/null; then
5601 <  if test -s conftest.err; then
5602 <    ac_cpp_err=$ac_c_preproc_warn_flag
5603 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5604 <  else
4516 <    ac_cpp_err=
4517 <  fi
4518 < else
4519 <  ac_cpp_err=yes
4520 < fi
4521 < if test -z "$ac_cpp_err"; then
4522 <  :
4523 < else
4524 <  echo "$as_me: failed program was:" >&5
4525 < sed 's/^/| /' conftest.$ac_ext >&5
4526 <
4527 <  # Broken: fails on valid input.
4528 < continue
4529 < fi
4530 < rm -f conftest.err conftest.$ac_ext
4531 <
4532 <  # OK, works on sane cases.  Now check whether non-existent headers
4533 <  # can be detected and how.
4534 <  cat >conftest.$ac_ext <<_ACEOF
4535 < /* confdefs.h.  */
4536 < _ACEOF
4537 < cat confdefs.h >>conftest.$ac_ext
4538 < cat >>conftest.$ac_ext <<_ACEOF
4539 < /* end confdefs.h.  */
4540 < #include <ac_nonexistent.h>
4541 < _ACEOF
4542 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4543 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5600 >  (exit $ac_status); } &&
5601 >         { ac_try='test -z "$ac_c_werror_flag"
5602 >                         || test ! -s conftest.err'
5603 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5604 >  (eval $ac_try) 2>&5
5605    ac_status=$?
4545 –  grep -v '^ *+' conftest.er1 >conftest.err
4546 –  rm -f conftest.er1
4547 –  cat conftest.err >&5
5606    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5607 <  (exit $ac_status); } >/dev/null; then
5608 <  if test -s conftest.err; then
5609 <    ac_cpp_err=$ac_c_preproc_warn_flag
5610 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5611 <  else
5612 <    ac_cpp_err=
5613 <  fi
5614 < else
4557 <  ac_cpp_err=yes
4558 < fi
4559 < if test -z "$ac_cpp_err"; then
4560 <  # Broken: success on invalid input.
4561 < continue
5607 >  (exit $ac_status); }; } &&
5608 >         { ac_try='test -s conftest$ac_exeext'
5609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5610 >  (eval $ac_try) 2>&5
5611 >  ac_status=$?
5612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5613 >  (exit $ac_status); }; }; then
5614 >  ac_cv_lib_m_asin=yes
5615   else
5616    echo "$as_me: failed program was:" >&5
5617   sed 's/^/| /' conftest.$ac_ext >&5
5618  
5619 <  # Passes both tests.
4567 < ac_preproc_ok=:
4568 < break
5619 > ac_cv_lib_m_asin=no
5620   fi
5621 < rm -f conftest.err conftest.$ac_ext
5622 <
5623 < done
4573 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4574 < rm -f conftest.err conftest.$ac_ext
4575 < if $ac_preproc_ok; then
4576 <  break
5621 > rm -f conftest.err conftest.$ac_objext \
5622 >      conftest$ac_exeext conftest.$ac_ext
5623 > LIBS=$ac_check_lib_save_LIBS
5624   fi
5625 <
5626 <    done
5627 <    ac_cv_prog_CPP=$CPP
5628 <
5629 < fi
4583 <  CPP=$ac_cv_prog_CPP
4584 < else
4585 <  ac_cv_prog_CPP=$CPP
4586 < fi
4587 < echo "$as_me:$LINENO: result: $CPP" >&5
4588 < echo "${ECHO_T}$CPP" >&6
4589 < ac_preproc_ok=false
4590 < for ac_c_preproc_warn_flag in '' yes
4591 < do
4592 <  # Use a header file that comes with gcc, so configuring glibc
4593 <  # with a fresh cross-compiler works.
4594 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4595 <  # <limits.h> exists even on freestanding compilers.
4596 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4597 <  # not just through cpp. "Syntax error" is here to catch this case.
4598 <  cat >conftest.$ac_ext <<_ACEOF
4599 < /* confdefs.h.  */
5625 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5626 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5627 > if test $ac_cv_lib_m_asin = yes; then
5628 >  cat >>confdefs.h <<_ACEOF
5629 > #define HAVE_LIBM 1
5630   _ACEOF
4601 – cat confdefs.h >>conftest.$ac_ext
4602 – cat >>conftest.$ac_ext <<_ACEOF
4603 – /* end confdefs.h.  */
4604 – #ifdef __STDC__
4605 – # include <limits.h>
4606 – #else
4607 – # include <assert.h>
4608 – #endif
4609 –                     Syntax error
4610 – _ACEOF
4611 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4612 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4613 –  ac_status=$?
4614 –  grep -v '^ *+' conftest.er1 >conftest.err
4615 –  rm -f conftest.er1
4616 –  cat conftest.err >&5
4617 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4618 –  (exit $ac_status); } >/dev/null; then
4619 –  if test -s conftest.err; then
4620 –    ac_cpp_err=$ac_c_preproc_warn_flag
4621 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4622 –  else
4623 –    ac_cpp_err=
4624 –  fi
4625 – else
4626 –  ac_cpp_err=yes
4627 – fi
4628 – if test -z "$ac_cpp_err"; then
4629 –  :
4630 – else
4631 –  echo "$as_me: failed program was:" >&5
4632 – sed 's/^/| /' conftest.$ac_ext >&5
5631  
5632 <  # Broken: fails on valid input.
4635 < continue
4636 < fi
4637 < rm -f conftest.err conftest.$ac_ext
5632 >  LIBS="-lm $LIBS"
5633  
4639 –  # OK, works on sane cases.  Now check whether non-existent headers
4640 –  # can be detected and how.
4641 –  cat >conftest.$ac_ext <<_ACEOF
4642 – /* confdefs.h.  */
4643 – _ACEOF
4644 – cat confdefs.h >>conftest.$ac_ext
4645 – cat >>conftest.$ac_ext <<_ACEOF
4646 – /* end confdefs.h.  */
4647 – #include <ac_nonexistent.h>
4648 – _ACEOF
4649 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4650 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4651 –  ac_status=$?
4652 –  grep -v '^ *+' conftest.er1 >conftest.err
4653 –  rm -f conftest.er1
4654 –  cat conftest.err >&5
4655 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4656 –  (exit $ac_status); } >/dev/null; then
4657 –  if test -s conftest.err; then
4658 –    ac_cpp_err=$ac_c_preproc_warn_flag
4659 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4660 –  else
4661 –    ac_cpp_err=
4662 –  fi
5634   else
5635 <  ac_cpp_err=yes
4665 < fi
4666 < if test -z "$ac_cpp_err"; then
4667 <  # Broken: success on invalid input.
4668 < continue
4669 < else
4670 <  echo "$as_me: failed program was:" >&5
4671 < sed 's/^/| /' conftest.$ac_ext >&5
4672 <
4673 <  # Passes both tests.
4674 < ac_preproc_ok=:
4675 < break
4676 < fi
4677 < rm -f conftest.err conftest.$ac_ext
4678 <
4679 < done
4680 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4681 < rm -f conftest.err conftest.$ac_ext
4682 < if $ac_preproc_ok; then
4683 <  :
4684 < else
4685 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4686 < See \`config.log' for more details." >&5
4687 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4688 < See \`config.log' for more details." >&2;}
4689 <   { (exit 1); exit 1; }; }
5635 >  exit
5636   fi
5637  
4692 – ac_ext=c
4693 – ac_cpp='$CPP $CPPFLAGS'
4694 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4695 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4696 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
5638  
4698 –
4699 – echo "$as_me:$LINENO: checking for egrep" >&5
4700 – echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4701 – if test "${ac_cv_prog_egrep+set}" = set; then
4702 –  echo $ECHO_N "(cached) $ECHO_C" >&6
4703 – else
4704 –  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4705 –    then ac_cv_prog_egrep='grep -E'
4706 –    else ac_cv_prog_egrep='egrep'
4707 –    fi
4708 – fi
4709 – echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4710 – echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4711 – EGREP=$ac_cv_prog_egrep
4712 –
4713 –
5639   echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5640   echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5641   if test "${ac_cv_header_stdc+set}" = set; then
# Line 4727 | Line 5652 | cat >>conftest.$ac_ext <<_ACEOF
5652   #include <string.h>
5653   #include <float.h>
5654  
5655 + #ifdef FC_DUMMY_MAIN
5656 + #ifndef FC_DUMMY_MAIN_EQ_F77
5657 + #  ifdef __cplusplus
5658 +     extern "C"
5659 + #  endif
5660 +   int FC_DUMMY_MAIN() { return 1; }
5661 + #endif
5662 + #endif
5663   int
5664   main ()
5665   {
# Line 4949 | Line 5882 | done
5882   done
5883  
5884  
5885 + #
5886 + # Handle user hints
5887 + #
5888  
5889 + # Check whether --with-zlib or --without-zlib was given.
5890 + if test "${with_zlib+set}" = set; then
5891 +  withval="$with_zlib"
5892 +  zlib_dir="$withval"
5893 + else
5894 +                zlib_dir="not_set"
5895 + fi;
5896 + if test "$zlib_dir" != "no"; then
5897  
5898 + if test "$zlib_dir" != "not_set" ; then
5899 +  if test -d "$zlib_dir"
5900 +  then
5901 +    ZLIB_HOME="$zlib_dir"
5902 +  else
5903 +    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5904 + echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5905 +  fi
5906 + fi
5907  
5908 <
5909 <
5908 > ZLIB_HOME=/usr/local
5909 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5910 > then
5911 >        ZLIB_HOME=/usr
5912 > fi
5913  
5914 + #
5915 + # Locate zlib, if wanted
5916 + #
5917 + if test -n "${ZLIB_HOME}"
5918 + then
5919 +        ZLIB_OLD_LDFLAGS=$LDFLAGS
5920 +        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5921 +        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5922 +        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5923  
5924  
5925 +        ac_ext=c
5926 + ac_cpp='$CPP $CPPFLAGS'
5927 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5928 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5929 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
5930  
5931 < 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
5932 < do
5933 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4964 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
4965 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
4966 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4967 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5931 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5932 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5933 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5934    echo $ECHO_N "(cached) $ECHO_C" >&6
4969 – fi
4970 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
4971 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5935   else
5936 <  # Is the header compilable?
5937 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
4975 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5936 >  ac_check_lib_save_LIBS=$LIBS
5937 > LIBS="-lz  $LIBS"
5938   cat >conftest.$ac_ext <<_ACEOF
5939   /* confdefs.h.  */
5940   _ACEOF
5941   cat confdefs.h >>conftest.$ac_ext
5942   cat >>conftest.$ac_ext <<_ACEOF
5943   /* end confdefs.h.  */
5944 < $ac_includes_default
5945 < #include <$ac_header>
5946 < _ACEOF
5947 < rm -f conftest.$ac_objext
5948 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5949 <  (eval $ac_compile) 2>conftest.er1
5950 <  ac_status=$?
5951 <  grep -v '^ *+' conftest.er1 >conftest.err
5952 <  rm -f conftest.er1
5953 <  cat conftest.err >&5
5954 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5955 <  (exit $ac_status); } &&
5956 <         { ac_try='test -z "$ac_c_werror_flag"
5957 <                         || test ! -s conftest.err'
5958 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5959 <  (eval $ac_try) 2>&5
5960 <  ac_status=$?
5961 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5962 <  (exit $ac_status); }; } &&
5963 <         { ac_try='test -s conftest.$ac_objext'
5964 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5965 <  (eval $ac_try) 2>&5
5966 <  ac_status=$?
5967 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5944 >
5945 > /* Override any gcc2 internal prototype to avoid an error.  */
5946 > #ifdef __cplusplus
5947 > extern "C"
5948 > #endif
5949 > /* We use char because int might match the return type of a gcc2
5950 >   builtin and then its argument prototype would still apply.  */
5951 > char inflateEnd ();
5952 > #ifdef FC_DUMMY_MAIN
5953 > #ifndef FC_DUMMY_MAIN_EQ_F77
5954 > #  ifdef __cplusplus
5955 >     extern "C"
5956 > #  endif
5957 >   int FC_DUMMY_MAIN() { return 1; }
5958 > #endif
5959 > #endif
5960 > int
5961 > main ()
5962 > {
5963 > inflateEnd ();
5964 >  ;
5965 >  return 0;
5966 > }
5967 > _ACEOF
5968 > rm -f conftest.$ac_objext conftest$ac_exeext
5969 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5970 >  (eval $ac_link) 2>conftest.er1
5971 >  ac_status=$?
5972 >  grep -v '^ *+' conftest.er1 >conftest.err
5973 >  rm -f conftest.er1
5974 >  cat conftest.err >&5
5975 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5976 >  (exit $ac_status); } &&
5977 >         { ac_try='test -z "$ac_c_werror_flag"
5978 >                         || test ! -s conftest.err'
5979 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5980 >  (eval $ac_try) 2>&5
5981 >  ac_status=$?
5982 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5983 >  (exit $ac_status); }; } &&
5984 >         { ac_try='test -s conftest$ac_exeext'
5985 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5986 >  (eval $ac_try) 2>&5
5987 >  ac_status=$?
5988 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5989    (exit $ac_status); }; }; then
5990 +  ac_cv_lib_z_inflateEnd=yes
5991 + else
5992 +  echo "$as_me: failed program was:" >&5
5993 + sed 's/^/| /' conftest.$ac_ext >&5
5994 +
5995 + ac_cv_lib_z_inflateEnd=no
5996 + fi
5997 + rm -f conftest.err conftest.$ac_objext \
5998 +      conftest$ac_exeext conftest.$ac_ext
5999 + LIBS=$ac_check_lib_save_LIBS
6000 + fi
6001 + echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6002 + echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6003 + if test $ac_cv_lib_z_inflateEnd = yes; then
6004 +  zlib_cv_libz=yes
6005 + else
6006 +  zlib_cv_libz=no
6007 + fi
6008 +
6009 +        if test "${ac_cv_header_zlib_h+set}" = set; then
6010 +  echo "$as_me:$LINENO: checking for zlib.h" >&5
6011 + echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6012 + if test "${ac_cv_header_zlib_h+set}" = set; then
6013 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6014 + fi
6015 + echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6016 + echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6017 + else
6018 +  # Is the header compilable?
6019 + echo "$as_me:$LINENO: checking zlib.h usability" >&5
6020 + echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
6021 + cat >conftest.$ac_ext <<_ACEOF
6022 + /* confdefs.h.  */
6023 + _ACEOF
6024 + cat confdefs.h >>conftest.$ac_ext
6025 + cat >>conftest.$ac_ext <<_ACEOF
6026 + /* end confdefs.h.  */
6027 + $ac_includes_default
6028 + #include <zlib.h>
6029 + _ACEOF
6030 + rm -f conftest.$ac_objext
6031 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6032 +  (eval $ac_compile) 2>conftest.er1
6033 +  ac_status=$?
6034 +  grep -v '^ *+' conftest.er1 >conftest.err
6035 +  rm -f conftest.er1
6036 +  cat conftest.err >&5
6037 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6038 +  (exit $ac_status); } &&
6039 +         { ac_try='test -z "$ac_c_werror_flag"
6040 +                         || test ! -s conftest.err'
6041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6042 +  (eval $ac_try) 2>&5
6043 +  ac_status=$?
6044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6045 +  (exit $ac_status); }; } &&
6046 +         { ac_try='test -s conftest.$ac_objext'
6047 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6048 +  (eval $ac_try) 2>&5
6049 +  ac_status=$?
6050 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6051 +  (exit $ac_status); }; }; then
6052    ac_header_compiler=yes
6053   else
6054    echo "$as_me: failed program was:" >&5
# Line 5016 | Line 6061 | echo "${ECHO_T}$ac_header_compiler" >&6
6061   echo "${ECHO_T}$ac_header_compiler" >&6
6062  
6063   # Is the header present?
6064 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6065 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6064 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
6065 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6066   cat >conftest.$ac_ext <<_ACEOF
6067   /* confdefs.h.  */
6068   _ACEOF
6069   cat confdefs.h >>conftest.$ac_ext
6070   cat >>conftest.$ac_ext <<_ACEOF
6071   /* end confdefs.h.  */
6072 < #include <$ac_header>
6072 > #include <zlib.h>
6073   _ACEOF
6074   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6075    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5058 | Line 6103 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
6103   # So?  What about this header?
6104   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6105    yes:no: )
6106 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6107 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6108 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6109 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6106 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6107 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6108 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6109 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6110      ac_header_preproc=yes
6111      ;;
6112    no:yes:* )
6113 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6114 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6115 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6116 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6117 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6118 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6119 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6120 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6121 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6122 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6123 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6124 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6113 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6114 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6115 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6116 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6117 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6118 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6119 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6120 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6121 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6122 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6123 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6124 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6125      (
6126        cat <<\_ASBOX
6127   ## ------------------------------ ##
# Line 5087 | Line 6132 | esac
6132        sed "s/^/$as_me: WARNING:     /" >&2
6133      ;;
6134   esac
6135 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6136 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6137 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6135 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6136 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6137 > if test "${ac_cv_header_zlib_h+set}" = set; then
6138    echo $ECHO_N "(cached) $ECHO_C" >&6
6139   else
6140 <  eval "$as_ac_Header=\$ac_header_preproc"
6140 >  ac_cv_header_zlib_h=$ac_header_preproc
6141   fi
6142 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6143 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6142 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6143 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6144  
6145   fi
6146 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6147 <  cat >>confdefs.h <<_ACEOF
6148 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6146 > if test $ac_cv_header_zlib_h = yes; then
6147 >  zlib_cv_zlib_h=yes
6148 > else
6149 >  zlib_cv_zlib_h=no
6150 > fi
6151 >
6152 >
6153 >        ac_ext=c
6154 > ac_cpp='$CPP $CPPFLAGS'
6155 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6156 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6157 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6158 >
6159 >
6160 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6161 >
6162 > cat >>confdefs.h <<\_ACEOF
6163 > #define HAVE_ZLIB_H 1
6164   _ACEOF
6165  
5106 – fi
6166  
6167 < done
6167 > cat >>confdefs.h <<\_ACEOF
6168 > #define HAVE_LIBZ 1
6169 > _ACEOF
6170  
6171 +                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6172 +                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6173 +                ZLIB="-lz"
6174 +        else
6175 +                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6176 + echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6177 +                ZLIB_INC_DIR=
6178 +                ZLIB_LIB_DIR=
6179 +                ZLIB=
6180 +                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6181 +                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6182 +                echo "$as_me:$LINENO: result: failed" >&5
6183 + echo "${ECHO_T}failed" >&6
6184 +                echo ""
6185 +                echo "*********************************************************"
6186 +                echo "* WARNING: Could not find a working zlib installation   *"
6187 +                echo "* If you need OOPSE to be able to deal with compressed  *"
6188 +                echo "* trajectory dump files be sure to specify a valid zlib *"
6189 +                echo "* installation with --with-zlib=DIR                     *"
6190 +                echo "*                                                       *"
6191 +                echo "* OOPSE will still work without zlib installed.         *"
6192 +                echo "*********************************************************"
6193 +                echo ""
6194 +        fi
6195  
6196  
6197  
6198 + fi
6199 + fi
6200  
6201 + #
6202 + # Handle user hints
6203 + #
6204  
6205 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6206 < do
6207 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6208 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6209 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6210 < if eval "test \"\${$as_ac_var+set}\" = set"; then
6205 > # Check whether --with-fftw or --without-fftw was given.
6206 > if test "${with_fftw+set}" = set; then
6207 >  withval="$with_fftw"
6208 >  fftw_dir="$withval"
6209 > else
6210 >             fftw_dir="not_set"
6211 > fi;
6212 > if test "$fftw_dir" != "no"; then
6213 >  if test "$fftw_dir" != "not_set" ; then
6214 >    if test -d "$fftw_dir"; then
6215 >      FFTW_HOME="$fftw_dir"
6216 >    else
6217 >      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6218 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6219 >      FFTW_HOME=/usr/local
6220 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6221 >        FFTW_HOME=/usr
6222 >      fi
6223 >    fi
6224 >    #
6225 >    # Locate fftw, if wanted
6226 >    #
6227 >    if test -n "${FFTW_HOME}"; then
6228 >      FFTW_OLD_LDFLAGS=$LDFLAGS
6229 >      FFTW_OLD_CPPFLAGS=$LDFLAGS
6230 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6231 >      CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6232 >
6233 >
6234 >      ac_ext=c
6235 > ac_cpp='$CPP $CPPFLAGS'
6236 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6237 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6238 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6239 >
6240 >      echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6241 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6242 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6243    echo $ECHO_N "(cached) $ECHO_C" >&6
6244   else
6245 <  cat >conftest.$ac_ext <<_ACEOF
6245 >  ac_check_lib_save_LIBS=$LIBS
6246 > LIBS="-lfftw3  $LIBS"
6247 > cat >conftest.$ac_ext <<_ACEOF
6248   /* confdefs.h.  */
6249   _ACEOF
6250   cat confdefs.h >>conftest.$ac_ext
6251   cat >>conftest.$ac_ext <<_ACEOF
6252   /* end confdefs.h.  */
5129 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5130 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5131 – #define $ac_func innocuous_$ac_func
5132 –
5133 – /* System header to define __stub macros and hopefully few prototypes,
5134 –    which can conflict with char $ac_func (); below.
5135 –    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5136 –    <limits.h> exists even on freestanding compilers.  */
6253  
5138 – #ifdef __STDC__
5139 – # include <limits.h>
5140 – #else
5141 – # include <assert.h>
5142 – #endif
5143 –
5144 – #undef $ac_func
5145 –
6254   /* Override any gcc2 internal prototype to avoid an error.  */
6255   #ifdef __cplusplus
6256   extern "C"
5149 – {
6257   #endif
6258   /* We use char because int might match the return type of a gcc2
6259     builtin and then its argument prototype would still apply.  */
6260 < char $ac_func ();
6261 < /* The GNU C library defines this for functions which it implements
6262 <    to always fail with ENOSYS.  Some functions are actually named
6263 <    something starting with __ and the normal name is an alias.  */
6264 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6265 < choke me
6266 < #else
5160 < char (*f) () = $ac_func;
6260 > char fftw_execute ();
6261 > #ifdef FC_DUMMY_MAIN
6262 > #ifndef FC_DUMMY_MAIN_EQ_F77
6263 > #  ifdef __cplusplus
6264 >     extern "C"
6265 > #  endif
6266 >   int FC_DUMMY_MAIN() { return 1; }
6267   #endif
5162 – #ifdef __cplusplus
5163 – }
6268   #endif
5165 –
6269   int
6270   main ()
6271   {
6272 < return f != $ac_func;
6272 > fftw_execute ();
6273    ;
6274    return 0;
6275   }
# Line 5193 | Line 6296 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6296    ac_status=$?
6297    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6298    (exit $ac_status); }; }; then
6299 <  eval "$as_ac_var=yes"
6299 >  ac_cv_lib_fftw3_fftw_execute=yes
6300   else
6301    echo "$as_me: failed program was:" >&5
6302   sed 's/^/| /' conftest.$ac_ext >&5
6303  
6304 < eval "$as_ac_var=no"
6304 > ac_cv_lib_fftw3_fftw_execute=no
6305   fi
6306   rm -f conftest.err conftest.$ac_objext \
6307        conftest$ac_exeext conftest.$ac_ext
6308 + LIBS=$ac_check_lib_save_LIBS
6309   fi
6310 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6311 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6312 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6313 <  cat >>confdefs.h <<_ACEOF
6314 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6310 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6311 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6312 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6313 >  fftw_cv_libfftw3=yes
6314 > else
6315 >  fftw_cv_libfftw3=no
6316 > fi
6317 >
6318 >      if test "${ac_cv_header_fftw3_h+set}" = set; then
6319 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6320 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6321 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6322 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6323 > fi
6324 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6325 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6326 > else
6327 >  # Is the header compilable?
6328 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6329 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6330 > cat >conftest.$ac_ext <<_ACEOF
6331 > /* confdefs.h.  */
6332   _ACEOF
6333 + cat confdefs.h >>conftest.$ac_ext
6334 + cat >>conftest.$ac_ext <<_ACEOF
6335 + /* end confdefs.h.  */
6336 + $ac_includes_default
6337 + #include <fftw3.h>
6338 + _ACEOF
6339 + rm -f conftest.$ac_objext
6340 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6341 +  (eval $ac_compile) 2>conftest.er1
6342 +  ac_status=$?
6343 +  grep -v '^ *+' conftest.er1 >conftest.err
6344 +  rm -f conftest.er1
6345 +  cat conftest.err >&5
6346 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6347 +  (exit $ac_status); } &&
6348 +         { ac_try='test -z "$ac_c_werror_flag"
6349 +                         || test ! -s conftest.err'
6350 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6351 +  (eval $ac_try) 2>&5
6352 +  ac_status=$?
6353 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6354 +  (exit $ac_status); }; } &&
6355 +         { ac_try='test -s conftest.$ac_objext'
6356 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6357 +  (eval $ac_try) 2>&5
6358 +  ac_status=$?
6359 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6360 +  (exit $ac_status); }; }; then
6361 +  ac_header_compiler=yes
6362 + else
6363 +  echo "$as_me: failed program was:" >&5
6364 + sed 's/^/| /' conftest.$ac_ext >&5
6365  
6366 + ac_header_compiler=no
6367   fi
6368 < done
6368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6369 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6370 > echo "${ECHO_T}$ac_header_compiler" >&6
6371  
6372 < # special check for _system_configuration because AIX <4.3.2 do not
6373 < # contain the `physmem' member.
6374 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
5219 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6372 > # Is the header present?
6373 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6374 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6375   cat >conftest.$ac_ext <<_ACEOF
6376   /* confdefs.h.  */
6377   _ACEOF
6378   cat confdefs.h >>conftest.$ac_ext
6379   cat >>conftest.$ac_ext <<_ACEOF
6380   /* end confdefs.h.  */
6381 < #include <sys/systemcfg.h>
6381 > #include <fftw3.h>
6382 > _ACEOF
6383 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6384 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6385 >  ac_status=$?
6386 >  grep -v '^ *+' conftest.er1 >conftest.err
6387 >  rm -f conftest.er1
6388 >  cat conftest.err >&5
6389 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6390 >  (exit $ac_status); } >/dev/null; then
6391 >  if test -s conftest.err; then
6392 >    ac_cpp_err=$ac_c_preproc_warn_flag
6393 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6394 >  else
6395 >    ac_cpp_err=
6396 >  fi
6397 > else
6398 >  ac_cpp_err=yes
6399 > fi
6400 > if test -z "$ac_cpp_err"; then
6401 >  ac_header_preproc=yes
6402 > else
6403 >  echo "$as_me: failed program was:" >&5
6404 > sed 's/^/| /' conftest.$ac_ext >&5
6405 >
6406 >  ac_header_preproc=no
6407 > fi
6408 > rm -f conftest.err conftest.$ac_ext
6409 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6410 > echo "${ECHO_T}$ac_header_preproc" >&6
6411 >
6412 > # So?  What about this header?
6413 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6414 >  yes:no: )
6415 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6416 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6417 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6418 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6419 >    ac_header_preproc=yes
6420 >    ;;
6421 >  no:yes:* )
6422 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6423 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6424 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6425 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6426 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6427 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6428 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6429 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6430 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6431 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6432 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6433 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6434 >    (
6435 >      cat <<\_ASBOX
6436 > ## ------------------------------ ##
6437 > ## Report this to gezelter@nd.edu ##
6438 > ## ------------------------------ ##
6439 > _ASBOX
6440 >    ) |
6441 >      sed "s/^/$as_me: WARNING:     /" >&2
6442 >    ;;
6443 > esac
6444 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6445 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6446 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6447 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6448 > else
6449 >  ac_cv_header_fftw3_h=$ac_header_preproc
6450 > fi
6451 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6452 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6453 >
6454 > fi
6455 > if test $ac_cv_header_fftw3_h = yes; then
6456 >  fftw_cv_fftw3_h=yes
6457 > else
6458 >  fftw_cv_fftw3_h=no
6459 > fi
6460 >
6461 >
6462 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6463 >        echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6464 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6465 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6466 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6467 > else
6468 >  ac_check_lib_save_LIBS=$LIBS
6469 > LIBS="-lfftw  $LIBS"
6470 > cat >conftest.$ac_ext <<_ACEOF
6471 > /* confdefs.h.  */
6472 > _ACEOF
6473 > cat confdefs.h >>conftest.$ac_ext
6474 > cat >>conftest.$ac_ext <<_ACEOF
6475 > /* end confdefs.h.  */
6476 >
6477 > /* Override any gcc2 internal prototype to avoid an error.  */
6478 > #ifdef __cplusplus
6479 > extern "C"
6480 > #endif
6481 > /* We use char because int might match the return type of a gcc2
6482 >   builtin and then its argument prototype would still apply.  */
6483 > char fftwnd_one ();
6484 > #ifdef FC_DUMMY_MAIN
6485 > #ifndef FC_DUMMY_MAIN_EQ_F77
6486 > #  ifdef __cplusplus
6487 >     extern "C"
6488 > #  endif
6489 >   int FC_DUMMY_MAIN() { return 1; }
6490 > #endif
6491 > #endif
6492   int
6493   main ()
6494   {
6495 < double x = _system_configuration.physmem;
6495 > fftwnd_one ();
6496    ;
6497    return 0;
6498   }
6499   _ACEOF
6500 < rm -f conftest.$ac_objext
6501 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6502 <  (eval $ac_compile) 2>conftest.er1
6500 > rm -f conftest.$ac_objext conftest$ac_exeext
6501 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6502 >  (eval $ac_link) 2>conftest.er1
6503    ac_status=$?
6504    grep -v '^ *+' conftest.er1 >conftest.err
6505    rm -f conftest.er1
# Line 5248 | Line 6513 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6513    ac_status=$?
6514    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6515    (exit $ac_status); }; } &&
6516 <         { ac_try='test -s conftest.$ac_objext'
6516 >         { ac_try='test -s conftest$ac_exeext'
6517    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6518    (eval $ac_try) 2>&5
6519    ac_status=$?
6520    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6521    (exit $ac_status); }; }; then
6522 <  echo "$as_me:$LINENO: result: yes" >&5
5258 < echo "${ECHO_T}yes" >&6
5259 <
5260 < cat >>confdefs.h <<\_ACEOF
5261 < #define HAVE__SYSTEM_CONFIGURATION 1
5262 < _ACEOF
5263 <
6522 >  ac_cv_lib_fftw_fftwnd_one=yes
6523   else
6524    echo "$as_me: failed program was:" >&5
6525   sed 's/^/| /' conftest.$ac_ext >&5
6526  
6527 < echo "$as_me:$LINENO: result: no" >&5
5269 < echo "${ECHO_T}no" >&6
6527 > ac_cv_lib_fftw_fftwnd_one=no
6528   fi
6529 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6529 > rm -f conftest.err conftest.$ac_objext \
6530 >      conftest$ac_exeext conftest.$ac_ext
6531 > LIBS=$ac_check_lib_save_LIBS
6532 > fi
6533 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6534 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6535 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6536 >  fftw_cv_libfftw=yes
6537 > else
6538 >  fftw_cv_libfftw=no
6539 > fi
6540  
6541 <  # clean out junk possibly left behind by a previous configuration
6542 <  rm -f src/getopt.h
6543 <  # Check for getopt_long support
6544 <
5277 < for ac_header in getopt.h
5278 < do
5279 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5280 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5281 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5282 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5283 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6541 >        if test "${ac_cv_header_fftw_h+set}" = set; then
6542 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6543 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6544 > if test "${ac_cv_header_fftw_h+set}" = set; then
6545    echo $ECHO_N "(cached) $ECHO_C" >&6
6546   fi
6547 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6548 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6547 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6548 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6549   else
6550    # Is the header compilable?
6551 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
6552 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6551 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6552 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6553   cat >conftest.$ac_ext <<_ACEOF
6554   /* confdefs.h.  */
6555   _ACEOF
# Line 5296 | Line 6557 | $ac_includes_default
6557   cat >>conftest.$ac_ext <<_ACEOF
6558   /* end confdefs.h.  */
6559   $ac_includes_default
6560 < #include <$ac_header>
6560 > #include <fftw.h>
6561   _ACEOF
6562   rm -f conftest.$ac_objext
6563   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5332 | Line 6593 | echo "${ECHO_T}$ac_header_compiler" >&6
6593   echo "${ECHO_T}$ac_header_compiler" >&6
6594  
6595   # Is the header present?
6596 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6597 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6596 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6597 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6598   cat >conftest.$ac_ext <<_ACEOF
6599   /* confdefs.h.  */
6600   _ACEOF
6601   cat confdefs.h >>conftest.$ac_ext
6602   cat >>conftest.$ac_ext <<_ACEOF
6603   /* end confdefs.h.  */
6604 < #include <$ac_header>
6604 > #include <fftw.h>
6605   _ACEOF
6606   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6607    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 5374 | Line 6635 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
6635   # So?  What about this header?
6636   case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6637    yes:no: )
6638 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6639 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6640 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6641 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6638 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6639 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6640 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6641 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6642      ac_header_preproc=yes
6643      ;;
6644    no:yes:* )
6645 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6646 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6647 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6648 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6649 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6650 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6651 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6652 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6653 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6654 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6655 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6656 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6645 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6646 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6647 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6648 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6649 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6650 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6651 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6652 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6653 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6654 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6655 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6656 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6657      (
6658        cat <<\_ASBOX
6659   ## ------------------------------ ##
# Line 5403 | Line 6664 | esac
6664        sed "s/^/$as_me: WARNING:     /" >&2
6665      ;;
6666   esac
6667 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6668 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6669 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6667 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6668 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6669 > if test "${ac_cv_header_fftw_h+set}" = set; then
6670    echo $ECHO_N "(cached) $ECHO_C" >&6
6671   else
6672 <  eval "$as_ac_Header=\$ac_header_preproc"
6672 >  ac_cv_header_fftw_h=$ac_header_preproc
6673   fi
6674 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6675 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6674 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6675 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6676  
6677   fi
6678 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6679 <  cat >>confdefs.h <<_ACEOF
6680 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6681 < _ACEOF
5421 <
6678 > if test $ac_cv_header_fftw_h = yes; then
6679 >  fftw_cv_fftw_h=yes
6680 > else
6681 >  fftw_cv_fftw_h=no
6682   fi
6683  
5424 – done
6684  
6685 <
6686 < for ac_func in getopt_long
6687 < do
6688 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5430 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5431 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5432 < if eval "test \"\${$as_ac_var+set}\" = set"; then
6685 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6686 >          echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6687 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6688 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6689    echo $ECHO_N "(cached) $ECHO_C" >&6
6690   else
6691 <  cat >conftest.$ac_ext <<_ACEOF
6691 >  ac_check_lib_save_LIBS=$LIBS
6692 > LIBS="-ldfftw  $LIBS"
6693 > cat >conftest.$ac_ext <<_ACEOF
6694   /* confdefs.h.  */
6695   _ACEOF
6696   cat confdefs.h >>conftest.$ac_ext
6697   cat >>conftest.$ac_ext <<_ACEOF
6698   /* end confdefs.h.  */
5441 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5442 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5443 – #define $ac_func innocuous_$ac_func
6699  
5445 – /* System header to define __stub macros and hopefully few prototypes,
5446 –    which can conflict with char $ac_func (); below.
5447 –    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5448 –    <limits.h> exists even on freestanding compilers.  */
5449 –
5450 – #ifdef __STDC__
5451 – # include <limits.h>
5452 – #else
5453 – # include <assert.h>
5454 – #endif
5455 –
5456 – #undef $ac_func
5457 –
6700   /* Override any gcc2 internal prototype to avoid an error.  */
6701   #ifdef __cplusplus
6702   extern "C"
5461 – {
6703   #endif
6704   /* We use char because int might match the return type of a gcc2
6705     builtin and then its argument prototype would still apply.  */
6706 < char $ac_func ();
6707 < /* The GNU C library defines this for functions which it implements
6708 <    to always fail with ENOSYS.  Some functions are actually named
6709 <    something starting with __ and the normal name is an alias.  */
6710 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6711 < choke me
6712 < #else
5472 < char (*f) () = $ac_func;
6706 > char fftwnd_one ();
6707 > #ifdef FC_DUMMY_MAIN
6708 > #ifndef FC_DUMMY_MAIN_EQ_F77
6709 > #  ifdef __cplusplus
6710 >     extern "C"
6711 > #  endif
6712 >   int FC_DUMMY_MAIN() { return 1; }
6713   #endif
5474 – #ifdef __cplusplus
5475 – }
6714   #endif
5477 –
6715   int
6716   main ()
6717   {
6718 < return f != $ac_func;
6718 > fftwnd_one ();
6719    ;
6720    return 0;
6721   }
# Line 5505 | Line 6742 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6742    ac_status=$?
6743    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6744    (exit $ac_status); }; }; then
6745 <  eval "$as_ac_var=yes"
6745 >  ac_cv_lib_dfftw_fftwnd_one=yes
6746   else
6747    echo "$as_me: failed program was:" >&5
6748   sed 's/^/| /' conftest.$ac_ext >&5
6749  
6750 < eval "$as_ac_var=no"
6750 > ac_cv_lib_dfftw_fftwnd_one=no
6751   fi
6752   rm -f conftest.err conftest.$ac_objext \
6753        conftest$ac_exeext conftest.$ac_ext
6754 + LIBS=$ac_check_lib_save_LIBS
6755   fi
6756 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6757 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6758 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6759 <  cat >>confdefs.h <<_ACEOF
5522 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5523 < _ACEOF
5524 <
6756 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6757 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6758 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6759 >  fftw_cv_libdfftw=yes
6760   else
6761 <  # FreeBSD has a gnugetopt library for this
6762 <    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
6763 < echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
6764 < if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
6761 >  fftw_cv_libdfftw=no
6762 > fi
6763 >
6764 >          if test "${ac_cv_header_dfftw_h+set}" = set; then
6765 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6766 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6767 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6768    echo $ECHO_N "(cached) $ECHO_C" >&6
6769 + fi
6770 + echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6771 + echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6772   else
6773 <  ac_check_lib_save_LIBS=$LIBS
6774 < LIBS="-lgnugetopt  $LIBS"
6773 >  # Is the header compilable?
6774 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6775 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6776   cat >conftest.$ac_ext <<_ACEOF
6777   /* confdefs.h.  */
6778   _ACEOF
6779   cat confdefs.h >>conftest.$ac_ext
6780   cat >>conftest.$ac_ext <<_ACEOF
6781   /* end confdefs.h.  */
6782 <
6783 < /* Override any gcc2 internal prototype to avoid an error.  */
5542 < #ifdef __cplusplus
5543 < extern "C"
5544 < #endif
5545 < /* We use char because int might match the return type of a gcc2
5546 <   builtin and then its argument prototype would still apply.  */
5547 < char getopt_long ();
5548 < int
5549 < main ()
5550 < {
5551 < getopt_long ();
5552 <  ;
5553 <  return 0;
5554 < }
6782 > $ac_includes_default
6783 > #include <dfftw.h>
6784   _ACEOF
6785 < rm -f conftest.$ac_objext conftest$ac_exeext
6786 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6787 <  (eval $ac_link) 2>conftest.er1
6785 > rm -f conftest.$ac_objext
6786 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6787 >  (eval $ac_compile) 2>conftest.er1
6788    ac_status=$?
6789    grep -v '^ *+' conftest.er1 >conftest.err
6790    rm -f conftest.er1
# Line 5569 | Line 6798 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6798    ac_status=$?
6799    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800    (exit $ac_status); }; } &&
6801 <         { ac_try='test -s conftest$ac_exeext'
6801 >         { ac_try='test -s conftest.$ac_objext'
6802    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6803    (eval $ac_try) 2>&5
6804    ac_status=$?
6805    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6806    (exit $ac_status); }; }; then
6807 <  ac_cv_lib_gnugetopt_getopt_long=yes
6807 >  ac_header_compiler=yes
6808   else
6809    echo "$as_me: failed program was:" >&5
6810   sed 's/^/| /' conftest.$ac_ext >&5
6811  
6812 < ac_cv_lib_gnugetopt_getopt_long=no
6812 > ac_header_compiler=no
6813   fi
6814 < rm -f conftest.err conftest.$ac_objext \
6815 <      conftest$ac_exeext conftest.$ac_ext
6816 < LIBS=$ac_check_lib_save_LIBS
5588 < fi
5589 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
5590 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
5591 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
5592 <  cat >>confdefs.h <<\_ACEOF
5593 < #define HAVE_GETOPT_LONG 1
5594 < _ACEOF
6814 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6815 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6816 > echo "${ECHO_T}$ac_header_compiler" >&6
6817  
6818 + # Is the header present?
6819 + echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6820 + echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6821 + cat >conftest.$ac_ext <<_ACEOF
6822 + /* confdefs.h.  */
6823 + _ACEOF
6824 + cat confdefs.h >>conftest.$ac_ext
6825 + cat >>conftest.$ac_ext <<_ACEOF
6826 + /* end confdefs.h.  */
6827 + #include <dfftw.h>
6828 + _ACEOF
6829 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6830 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6831 +  ac_status=$?
6832 +  grep -v '^ *+' conftest.er1 >conftest.err
6833 +  rm -f conftest.er1
6834 +  cat conftest.err >&5
6835 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6836 +  (exit $ac_status); } >/dev/null; then
6837 +  if test -s conftest.err; then
6838 +    ac_cpp_err=$ac_c_preproc_warn_flag
6839 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6840 +  else
6841 +    ac_cpp_err=
6842 +  fi
6843   else
6844 <  # use the GNU replacement
5598 <      case $LIBOBJS in
5599 <    "getopt.$ac_objext"   | \
5600 <  *" getopt.$ac_objext"   | \
5601 <    "getopt.$ac_objext "* | \
5602 <  *" getopt.$ac_objext "* ) ;;
5603 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5604 < esac
5605 <
5606 <      case $LIBOBJS in
5607 <    "getopt1.$ac_objext"   | \
5608 <  *" getopt1.$ac_objext"   | \
5609 <    "getopt1.$ac_objext "* | \
5610 <  *" getopt1.$ac_objext "* ) ;;
5611 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5612 < esac
5613 <
5614 <                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5615 <
6844 >  ac_cpp_err=yes
6845   fi
6846 + if test -z "$ac_cpp_err"; then
6847 +  ac_header_preproc=yes
6848 + else
6849 +  echo "$as_me: failed program was:" >&5
6850 + sed 's/^/| /' conftest.$ac_ext >&5
6851  
6852 < fi
6853 < done
6852 >  ac_header_preproc=no
6853 > fi
6854 > rm -f conftest.err conftest.$ac_ext
6855 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6856 > echo "${ECHO_T}$ac_header_preproc" >&6
6857  
6858 + # So?  What about this header?
6859 + case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6860 +  yes:no: )
6861 +    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6862 + echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6863 +    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6864 + echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6865 +    ac_header_preproc=yes
6866 +    ;;
6867 +  no:yes:* )
6868 +    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6869 + echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6870 +    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6871 + echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6872 +    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6873 + echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6874 +    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6875 + echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6876 +    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6877 + echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6878 +    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6879 + echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6880 +    (
6881 +      cat <<\_ASBOX
6882 + ## ------------------------------ ##
6883 + ## Report this to gezelter@nd.edu ##
6884 + ## ------------------------------ ##
6885 + _ASBOX
6886 +    ) |
6887 +      sed "s/^/$as_me: WARNING:     /" >&2
6888 +    ;;
6889 + esac
6890 + echo "$as_me:$LINENO: checking for dfftw.h" >&5
6891 + echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6892 + if test "${ac_cv_header_dfftw_h+set}" = set; then
6893 +  echo $ECHO_N "(cached) $ECHO_C" >&6
6894 + else
6895 +  ac_cv_header_dfftw_h=$ac_header_preproc
6896 + fi
6897 + echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6898 + echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6899  
6900 + fi
6901 + if test $ac_cv_header_dfftw_h = yes; then
6902 +  fftw_cv_dfftw_h=yes
6903 + else
6904 +  fftw_cv_dfftw_h=no
6905 + fi
6906  
5623 – case $debug in
5624 –  1)
5625 –     ;;
5626 –  *)
6907  
6908 +        fi
6909 +      fi
6910 +      ac_ext=c
6911 + ac_cpp='$CPP $CPPFLAGS'
6912 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6913 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6914 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
6915  
6916 +      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6917  
6918 + cat >>confdefs.h <<\_ACEOF
6919 + #define HAVE_FFTW3_H 1
6920 + _ACEOF
6921  
6922 +        FFTW_INC_DIR="${FFTW_HOME}/include"
6923 +        FFTW_LIB_DIR="${FFTW_HOME}/lib"
6924 +        FFTW_LIBS="-lfftw3"
6925 +      else
6926 +        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6927  
6928 + cat >>confdefs.h <<\_ACEOF
6929 + #define HAVE_FFTW_H 1
6930 + _ACEOF
6931  
6932 < echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
6933 < echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
6934 < if test "${ac_cv_prog_really_gcc+set}" = set; then
6932 >          FFTW_INC_DIR="${FFTW_HOME}/include"
6933 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
6934 >          FFTW_LIBS="-lfftw"
6935 >        else
6936 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6937 >
6938 > cat >>confdefs.h <<\_ACEOF
6939 > #define HAVE_DFFTW_H 1
6940 > _ACEOF
6941 >
6942 >            FFTW_INC_DIR="${FFTW_HOME}/include"
6943 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
6944 >            FFTW_LIBS="-ldfftw"
6945 >          else
6946 >            echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6947 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6948 >            FFTW_INC_DIR=
6949 >            FFTW_LIB_DIR=
6950 >            FFTW_LIBS=
6951 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
6952 >            CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6953 >            echo "$as_me:$LINENO: result: failed" >&5
6954 > echo "${ECHO_T}failed" >&6
6955 >            echo ""
6956 >            echo "*********************************************************"
6957 >            echo "* WARNING: Could not find a working FFTW installation   *"
6958 >            echo "* If you need the staticProps program to be able to     *"
6959 >            echo "* compute undulation spectra, be sure to specify a      *"
6960 >            echo "* valid fftw installation with --with-fftw=DIR          *"
6961 >            echo "*                                                       *"
6962 >            echo "* OOPSE will still work without fftw installed.         *"
6963 >            echo "*********************************************************"
6964 >            echo ""
6965 >          fi
6966 >        fi
6967 >      fi
6968 >
6969 >
6970 >
6971 >    fi
6972 >  fi
6973 > fi
6974 >
6975 >
6976 >
6977 > # Checks for header files.
6978 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6979 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6980 > if test "${ac_cv_header_stdc+set}" = set; then
6981    echo $ECHO_N "(cached) $ECHO_C" >&6
6982   else
6983 +  cat >conftest.$ac_ext <<_ACEOF
6984 + /* confdefs.h.  */
6985 + _ACEOF
6986 + cat confdefs.h >>conftest.$ac_ext
6987 + cat >>conftest.$ac_ext <<_ACEOF
6988 + /* end confdefs.h.  */
6989 + #include <stdlib.h>
6990 + #include <stdarg.h>
6991 + #include <string.h>
6992 + #include <float.h>
6993  
6994 < cat > conftest.c <<EOF
6995 < #ifdef __GNUC__
6996 <  #ifndef __INTEL_COMPILER
6997 <     yes;
6998 <  #endif
6994 > #ifdef FC_DUMMY_MAIN
6995 > #ifndef FC_DUMMY_MAIN_EQ_F77
6996 > #  ifdef __cplusplus
6997 >     extern "C"
6998 > #  endif
6999 >   int FC_DUMMY_MAIN() { return 1; }
7000   #endif
7001 < EOF
7002 < if { ac_try='${CC-cc} -E conftest.c'
7001 > #endif
7002 > int
7003 > main ()
7004 > {
7005 >
7006 >  ;
7007 >  return 0;
7008 > }
7009 > _ACEOF
7010 > rm -f conftest.$ac_objext
7011 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7012 >  (eval $ac_compile) 2>conftest.er1
7013 >  ac_status=$?
7014 >  grep -v '^ *+' conftest.er1 >conftest.err
7015 >  rm -f conftest.er1
7016 >  cat conftest.err >&5
7017 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7018 >  (exit $ac_status); } &&
7019 >         { ac_try='test -z "$ac_c_werror_flag"
7020 >                         || test ! -s conftest.err'
7021    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7022    (eval $ac_try) 2>&5
7023    ac_status=$?
7024    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7025 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
7026 <  ac_cv_prog_really_gcc=yes
7025 >  (exit $ac_status); }; } &&
7026 >         { ac_try='test -s conftest.$ac_objext'
7027 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7028 >  (eval $ac_try) 2>&5
7029 >  ac_status=$?
7030 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7031 >  (exit $ac_status); }; }; then
7032 >  ac_cv_header_stdc=yes
7033   else
7034 <  ac_cv_prog_really_gcc=no
7035 < fi
7034 >  echo "$as_me: failed program was:" >&5
7035 > sed 's/^/| /' conftest.$ac_ext >&5
7036  
7037 + ac_cv_header_stdc=no
7038   fi
7039 < echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
5659 < echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6
5660 < if test "$ac_cv_prog_really_gcc" = yes; then
5661 <        :
7039 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7040  
7041 + if test $ac_cv_header_stdc = yes; then
7042 +  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7043 +  cat >conftest.$ac_ext <<_ACEOF
7044 + /* confdefs.h.  */
7045 + _ACEOF
7046 + cat confdefs.h >>conftest.$ac_ext
7047 + cat >>conftest.$ac_ext <<_ACEOF
7048 + /* end confdefs.h.  */
7049 + #include <string.h>
7050 +
7051 + _ACEOF
7052 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7053 +  $EGREP "memchr" >/dev/null 2>&1; then
7054 +  :
7055   else
7056 <        :
7056 >  ac_cv_header_stdc=no
7057 > fi
7058 > rm -f conftest*
7059  
7060   fi
7061  
7062 + if test $ac_cv_header_stdc = yes; then
7063 +  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7064 +  cat >conftest.$ac_ext <<_ACEOF
7065 + /* confdefs.h.  */
7066 + _ACEOF
7067 + cat confdefs.h >>conftest.$ac_ext
7068 + cat >>conftest.$ac_ext <<_ACEOF
7069 + /* end confdefs.h.  */
7070 + #include <stdlib.h>
7071  
7072 < # Try to determine "good" native compiler flags if none specified on command
7073 < # line
7074 < if test "$ac_test_CFLAGS" != "set"; then
7075 <  CFLAGS=""
7076 <  case "${host_cpu}-${host_os}" in
7072 > _ACEOF
7073 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7074 >  $EGREP "free" >/dev/null 2>&1; then
7075 >  :
7076 > else
7077 >  ac_cv_header_stdc=no
7078 > fi
7079 > rm -f conftest*
7080  
7081 <  *linux*) if test "$CC" = icc; then
5676 <                    CFLAGS="-O"
5677 <                fi;;
5678 <  sparc-solaris2*) if test "$CC" = cc; then
5679 <                    CFLAGS="-native -fast -xO5 -dalign"
5680 <                 fi;;
7081 > fi
7082  
7083 <  alpha*-osf*)  if test "$CC" = cc; then
7084 <                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
7085 <                fi;;
7086 <
7087 <  hppa*-hpux*)  if test "$CC" = cc; then
7088 <                    CFLAGS="-Ae +O3 +Oall"
7089 <                fi;;
7090 <
7091 <   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
7092 <                    CFLAGS="-O3 -qtune=auto -qansialias -w"
7093 <                fi;;
7094 <   powerpc*-aix*)
7095 <        if test "$CC" = cc -o "$CC" = xlc; then
7096 <                CFLAGS="-O3 -qtune=auto -qansialias -w"
7097 <                echo "*******************************************************"
7098 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
7099 <                echo "*  recommended that you use                           *"
7100 <                echo "*                                                     *"
7101 <                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
7102 <                echo "*                                 ^^^                 *"
7103 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
7104 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
7105 <                echo "*******************************************************"
7106 <        fi;;
7107 <   *darwin*)
7108 <        if test "$CC" = xlc -o "$CC" = cc; then
7109 <                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
7110 <        fi;;
7111 <  esac
7112 <
7113 <  # use default flags for gcc on all systems
7114 <  if test $ac_cv_prog_really_gcc = yes; then
7115 <     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
7116 <  fi
7117 <
7118 <  # test for gcc-specific flags:
7119 <  if test $ac_cv_prog_really_gcc = yes; then
7120 <    # -malign-double for x86 systems
7121 <
7122 <
7123 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
7124 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
7125 < if test "${ac_align_double+set}" = set; then
7126 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7127 < else
7128 <  echo 'void f(){}' > conftest.c
7129 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
7130 <        ac_align_double=yes
7131 < else
7132 <        ac_align_double=no
7133 < fi
7134 < rm -f conftest*
7135 <
7136 < fi
7137 < echo "$as_me:$LINENO: result: $ac_align_double" >&5
7138 < echo "${ECHO_T}$ac_align_double" >&6
7139 < if test "$ac_align_double" = yes; then
7140 <        :
7141 <        CFLAGS="$CFLAGS -malign-double"
7142 < else
7143 <        :
7144 <
7145 < fi
7146 <
7147 <    # -fstrict-aliasing for gcc-2.95+
7148 <
7149 <
7150 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
7151 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
7152 < if test "${ac_fstrict_aliasing+set}" = set; then
7153 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7154 < else
7155 <  echo 'void f(){}' > conftest.c
7156 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
7157 <        ac_fstrict_aliasing=yes
7158 < else
7159 <        ac_fstrict_aliasing=no
7160 < fi
7161 < rm -f conftest*
7162 <
7163 < fi
7164 < echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
7165 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6
7166 < if test "$ac_fstrict_aliasing" = yes; then
7167 <        :
7168 <        CFLAGS="$CFLAGS -fstrict-aliasing"
7169 < else
7170 <        :
7171 <
7172 < fi
7173 <
7174 <  fi
7175 <
7176 <  CPU_FLAGS=""
7177 <  if test $ac_cv_prog_really_gcc = yes; then
7178 <                  case "${host_cpu}" in
7179 <          i586*)
7180 <
7181 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
7182 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
7183 < if test "${ac_cpu_pentium+set}" = set; then
7184 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7185 < else
7186 <  echo 'void f(){}' > conftest.c
7187 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
7188 <        ac_cpu_pentium=yes
7189 < else
7190 <        ac_cpu_pentium=no
7191 < fi
7192 < rm -f conftest*
7193 <
7194 < fi
7195 < echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
7196 < echo "${ECHO_T}$ac_cpu_pentium" >&6
7197 < if test "$ac_cpu_pentium" = yes; then
7198 <        :
7199 <        CPU_FLAGS=-mcpu=pentium
7200 < else
7201 <        :
7202 <
7203 <
7204 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
7205 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
7206 < if test "${ac_pentium+set}" = set; then
7207 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7208 < else
7209 <  echo 'void f(){}' > conftest.c
7210 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
7211 <        ac_pentium=yes
7212 < else
7213 <        ac_pentium=no
7214 < fi
7215 < rm -f conftest*
7216 <
7217 < fi
7218 < echo "$as_me:$LINENO: result: $ac_pentium" >&5
7219 < echo "${ECHO_T}$ac_pentium" >&6
7220 < if test "$ac_pentium" = yes; then
7221 <        :
7222 <        CPU_FLAGS=-mpentium
7223 < else
7224 <        :
7225 <
7226 < fi
7227 <
7228 < fi
7229 <
7230 <                  ;;
7231 <          i686*)
7232 <
7233 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
7234 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
7235 < if test "${ac_cpu_pentiumpro+set}" = set; then
7236 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7237 < else
7238 <  echo 'void f(){}' > conftest.c
7239 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
7240 <        ac_cpu_pentiumpro=yes
7241 < else
7242 <        ac_cpu_pentiumpro=no
7243 < fi
7244 < rm -f conftest*
7245 <
7246 < fi
7247 < echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
7248 < echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
7249 < if test "$ac_cpu_pentiumpro" = yes; then
7250 <        :
7251 <        CPU_FLAGS=-mcpu=pentiumpro
7252 < else
7253 <        :
7254 <
7255 <
7256 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
7257 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
7258 < if test "${ac_pentiumpro+set}" = set; then
7259 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7260 < else
7261 <  echo 'void f(){}' > conftest.c
7262 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
7263 <        ac_pentiumpro=yes
7264 < else
7265 <        ac_pentiumpro=no
7266 < fi
7267 < rm -f conftest*
7268 <
7269 < fi
7270 < echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
7271 < echo "${ECHO_T}$ac_pentiumpro" >&6
7272 < if test "$ac_pentiumpro" = yes; then
7273 <        :
7274 <        CPU_FLAGS=-mpentiumpro
7275 < else
7276 <        :
7277 <
7278 < fi
7279 <
7280 < fi
7281 <
7282 <                  ;;
7283 <          powerpc*)
7284 <                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
7285 <                is60x=`echo $cputype | egrep "^600-9e?$"`
7286 <                if test -n "$is60x"; then
7287 <
7288 <
7289 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
7290 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
7291 < if test "${ac_m_cpu_60x+set}" = set; then
7292 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7293 < else
7294 <  echo 'void f(){}' > conftest.c
7295 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
7296 <        ac_m_cpu_60x=yes
7297 < else
7298 <        ac_m_cpu_60x=no
7299 < fi
7300 < rm -f conftest*
7301 <
7302 < fi
7303 < echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
7304 < echo "${ECHO_T}$ac_m_cpu_60x" >&6
7305 < if test "$ac_m_cpu_60x" = yes; then
7306 <        :
7307 <        CPU_FLAGS=-mcpu=$cputype
7308 < else
7309 <        :
7310 <
7311 < fi
7312 <
7313 <                elif test "$cputype" = 750; then
7314 <
7315 <
7316 < echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
7317 < echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6
7318 < if test "${ac_cv_prog_gcc_2_95+set}" = set; then
7319 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7320 < else
7321 <
7322 < cat > conftest.c <<EOF
7323 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
7324 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
7325 <     yes;
7326 < #  endif
7327 < #endif
7328 < EOF
7329 < if { ac_try='${CC-cc} -E conftest.c'
7330 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7331 <  (eval $ac_try) 2>&5
7332 <  ac_status=$?
7333 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7334 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
7335 <  ac_cv_prog_gcc_2_95=yes
7336 < else
7337 <  ac_cv_prog_gcc_2_95=no
7338 < fi
7339 <
7340 < fi
7341 < echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
7342 < echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6
7343 < if test "$ac_cv_prog_gcc_2_95" = yes; then
7344 <        :
7345 <
7346 <
7347 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
7348 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
7349 < if test "${ac_m_cpu_750+set}" = set; then
7350 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7351 < else
7352 <  echo 'void f(){}' > conftest.c
7353 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
7354 <        ac_m_cpu_750=yes
7355 < else
7356 <        ac_m_cpu_750=no
7357 < fi
7358 < rm -f conftest*
7359 <
7360 < fi
7361 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
7362 < echo "${ECHO_T}$ac_m_cpu_750" >&6
7363 < if test "$ac_m_cpu_750" = yes; then
7364 <        :
7365 <        CPU_FLAGS=-mcpu=750
7366 < else
7367 <        :
7368 <
7369 < fi
7370 <
7371 < else
7372 <        :
7373 <
7374 < fi
7375 <
7376 <                fi
7377 <                if test -z "$CPU_FLAGS"; then
7378 <
7379 <
7380 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
7381 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
7382 < if test "${ac_m_cpu_powerpc+set}" = set; then
7383 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7384 < else
7385 <  echo 'void f(){}' > conftest.c
7386 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
7387 <        ac_m_cpu_powerpc=yes
7388 < else
7389 <        ac_m_cpu_powerpc=no
7390 < fi
7391 < rm -f conftest*
7392 <
7393 < fi
7394 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
7395 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
7396 < if test "$ac_m_cpu_powerpc" = yes; then
7397 <        :
7398 <        CPU_FLAGS=-mcpu=powerpc
7399 < else
7400 <        :
7401 <
7402 < fi
7403 <
7404 <                fi
7405 <                if test -z "$CPU_FLAGS"; then
7406 <
7407 <
7408 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
7409 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
7410 < if test "${ac_m_powerpc+set}" = set; then
7411 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7412 < else
7413 <  echo 'void f(){}' > conftest.c
7414 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
7415 <        ac_m_powerpc=yes
7416 < else
7417 <        ac_m_powerpc=no
7418 < fi
7419 < rm -f conftest*
7420 <
7421 < fi
7422 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
7423 < echo "${ECHO_T}$ac_m_powerpc" >&6
7424 < if test "$ac_m_powerpc" = yes; then
7425 <        :
7426 <        CPU_FLAGS=-mpowerpc
7427 < else
7428 <        :
7429 <
7430 < fi
7431 <
7432 <                fi
7433 <          esac
7434 <  fi
7435 <
7436 <  if test -n "$CPU_FLAGS"; then
7437 <        CFLAGS="$CFLAGS $CPU_FLAGS"
7438 <  fi
7439 <
7440 <  if test -z "$CFLAGS"; then
7441 <        echo ""
7442 <        echo "********************************************************"
7443 <        echo "* WARNING: Don't know the best CFLAGS for this system  *"
7444 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
7445 <        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
7446 <        echo "********************************************************"
7447 <        echo ""
7448 <        CFLAGS="-O3"
7449 <  fi
7450 <
7451 <
7452 <
7453 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
7454 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
7455 < if test "${ac_guessed_cflags+set}" = set; then
7456 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7457 < else
7458 <  echo 'void f(){}' > conftest.c
7459 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
7460 <        ac_guessed_cflags=yes
7461 < else
7462 <        ac_guessed_cflags=no
7463 < fi
7464 < rm -f conftest*
7465 <
7466 < fi
7467 < echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
7468 < echo "${ECHO_T}$ac_guessed_cflags" >&6
7469 < if test "$ac_guessed_cflags" = yes; then
7470 <        :
7471 <
7472 < else
7473 <        :
7474 <
7475 <        echo ""
7476 <        echo "********************************************************"
7477 <        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
7478 <        echo "* your compiler.                                       *"
7479 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
7480 <        echo "********************************************************"
7481 <        echo ""
7482 <        CFLAGS=""
7483 <
7484 < fi
7485 <
7486 <
7487 < fi
7488 <
7489 <
7490 <
7491 <
7492 <
7493 <
7494 <
7495 < echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
7496 < echo $ECHO_N "checking whether we are *really* using GNU c++... $ECHO_C" >&6
7497 < if test "${ac_cv_prog_really_gxx+set}" = set; then
7498 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7499 < else
7500 <
7501 < cat > conftest.cpp <<EOF
7502 < #ifdef __GNUC__
7503 <  #ifndef __INTEL_COMPILER
7504 <     yes;
7505 <  #endif
7506 < #endif
7507 < EOF
7508 < if { ac_try='${CXX-c++} -E conftest.cpp'
7509 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7510 <  (eval $ac_try) 2>&5
7511 <  ac_status=$?
7512 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7513 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
7514 <  ac_cv_prog_really_gxx=yes
7515 < else
7516 <  ac_cv_prog_really_gxx=no
7517 < fi
7518 <
7519 < fi
7520 < echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
7521 < echo "${ECHO_T}$ac_cv_prog_really_gxx" >&6
7522 < if test "$ac_cv_prog_really_gxx" = yes; then
7523 <        :
7524 <
7525 < else
7526 <        :
7527 <
7528 < fi
7529 <
7530 <
7531 < # Try to determine "good" native compiler flags if none specified on command
7532 < # line
7533 < if test "$ac_test_CXXFLAGS" != "set"; then
7534 <  CXXFLAGS=""
7535 <  case "${host_cpu}-${host_os}" in
7536 <
7537 <  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
7538 <                    CXXFLAGS="-O"
7539 <                fi;;
7540 <  sparc-solaris2*) if test "$CXX" = CC; then
7541 <                    CXXFLAGS="-native -fast -xO5 -dalign"
7542 <                 fi;;
7543 <   rs6000*-aix*)  if test "$CXX" = xlC; then
7544 <                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
7545 <                fi;;
7546 <   powerpc*-aix*)
7547 <        if test "$CXX" = xlC; then
7548 <                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
7549 <                echo "*******************************************************"
7550 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
7551 <                echo "*  recommended that you use                           *"
7552 <                echo "*                                                     *"
7553 <                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
7554 <                echo "*                                 ^^^                 *"
7555 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
7556 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
7557 <                echo "*******************************************************"
7558 <        fi;;
7559 <   *darwin*)
7560 <        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
7561 <                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
7562 <        fi;;
7563 <  esac
7564 <
7565 <  # use default flags for gcc on all systems
7566 <  if test $ac_cv_prog_really_gxx = yes; then
7567 <     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
7568 <  fi
7569 <
7570 <  # test for gcc-specific flags:
7571 <  if test $ac_cv_prog_really_gxx = yes; then
7572 <    # -malign-double for x86 systems
7573 <
7574 <
7575 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
7576 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
7577 < if test "${ac_align_double+set}" = set; then
7578 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7579 < else
7580 <  echo 'void f(){}' > conftest.cpp
7581 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
7582 <        ac_align_double=yes
7583 < else
7584 <        ac_align_double=no
7585 < fi
7586 < rm -f conftest*
7587 <
7588 < fi
7589 < echo "$as_me:$LINENO: result: $ac_align_double" >&5
7590 < echo "${ECHO_T}$ac_align_double" >&6
7591 < if test "$ac_align_double" = yes; then
7592 <        :
7593 <        CXXFLAGS="$CXXFLAGS -malign-double"
7594 < else
7595 <        :
7596 <
7597 < fi
7598 <
7599 <    # -fstrict-aliasing for gcc-2.95+
7600 <
7601 <
7602 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
7603 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
7604 < if test "${ac_fstrict_aliasing+set}" = set; then
7605 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7606 < else
7607 <  echo 'void f(){}' > conftest.cpp
7608 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
7609 <        ac_fstrict_aliasing=yes
7610 < else
7611 <        ac_fstrict_aliasing=no
7612 < fi
7613 < rm -f conftest*
7614 <
7615 < fi
7616 < echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
7617 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6
7618 < if test "$ac_fstrict_aliasing" = yes; then
7619 <        :
7620 <        CXXFLAGS="$CXXFLAGS -fstrict-aliasing"
7621 < else
7622 <        :
7623 <
7624 < fi
7625 <
7626 <  fi
7627 <
7628 <  CPU_FLAGS=""
7629 <  if test $ac_cv_prog_really_gxx = yes; then
7630 <                  case "${host_cpu}" in
7631 <          i586*)
7632 <
7633 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
7634 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
7635 < if test "${ac_cpu_pentium+set}" = set; then
7636 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7637 < else
7638 <  echo 'void f(){}' > conftest.cpp
7639 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
7640 <        ac_cpu_pentium=yes
7641 < else
7642 <        ac_cpu_pentium=no
7643 < fi
7644 < rm -f conftest*
7645 <
7646 < fi
7647 < echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
7648 < echo "${ECHO_T}$ac_cpu_pentium" >&6
7649 < if test "$ac_cpu_pentium" = yes; then
7650 <        :
7651 <        CPU_FLAGS=-mcpu=pentium
7652 < else
7653 <        :
7654 <
7655 <
7656 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
7657 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
7658 < if test "${ac_pentium+set}" = set; then
7659 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7660 < else
7661 <  echo 'void f(){}' > conftest.cpp
7662 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
7663 <        ac_pentium=yes
7664 < else
7665 <        ac_pentium=no
7666 < fi
7667 < rm -f conftest*
7668 <
7669 < fi
7670 < echo "$as_me:$LINENO: result: $ac_pentium" >&5
7671 < echo "${ECHO_T}$ac_pentium" >&6
7672 < if test "$ac_pentium" = yes; then
7673 <        :
7674 <        CPU_FLAGS=-mpentium
7675 < else
7676 <        :
7677 <
7678 < fi
7679 <
7680 < fi
7681 <
7682 <                  ;;
7683 <          i686*)
7684 <
7685 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
7686 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
7687 < if test "${ac_cpu_pentiumpro+set}" = set; then
7688 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7689 < else
7690 <  echo 'void f(){}' > conftest.cpp
7691 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
7692 <        ac_cpu_pentiumpro=yes
7693 < else
7694 <        ac_cpu_pentiumpro=no
7695 < fi
7696 < rm -f conftest*
7697 <
7698 < fi
7699 < echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
7700 < echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
7701 < if test "$ac_cpu_pentiumpro" = yes; then
7702 <        :
7703 <        CPU_FLAGS=-mcpu=pentiumpro
7704 < else
7705 <        :
7706 <
7707 <
7708 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
7709 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
7710 < if test "${ac_pentiumpro+set}" = set; then
7711 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7712 < else
7713 <  echo 'void f(){}' > conftest.cpp
7714 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
7715 <        ac_pentiumpro=yes
7716 < else
7717 <        ac_pentiumpro=no
7718 < fi
7719 < rm -f conftest*
7720 <
7721 < fi
7722 < echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
7723 < echo "${ECHO_T}$ac_pentiumpro" >&6
7724 < if test "$ac_pentiumpro" = yes; then
7725 <        :
7726 <        CPU_FLAGS=-mpentiumpro
7727 < else
7728 <        :
7729 <
7730 < fi
7731 <
7732 < fi
7733 <
7734 <                  ;;
7735 <          powerpc*)
7736 <                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
7737 <                is60x=`echo $cputype | egrep "^600-9e?$"`
7738 <                if test -n "$is60x"; then
7739 <
7740 <
7741 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
7742 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
7743 < if test "${ac_m_cpu_60x+set}" = set; then
7744 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7745 < else
7746 <  echo 'void f(){}' > conftest.cpp
7747 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
7748 <        ac_m_cpu_60x=yes
7749 < else
7750 <        ac_m_cpu_60x=no
7751 < fi
7752 < rm -f conftest*
7753 <
7754 < fi
7755 < echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
7756 < echo "${ECHO_T}$ac_m_cpu_60x" >&6
7757 < if test "$ac_m_cpu_60x" = yes; then
7758 <        :
7759 <        CPU_FLAGS=-mcpu=$cputype
7760 < else
7761 <        :
7762 <
7763 < fi
7764 <
7765 <                elif test "$cputype" = 750; then
7766 <
7767 <
7768 < echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
7769 < echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
7770 < if test "${ac_cv_prog_gxx_2_95+set}" = set; then
7771 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7772 < else
7773 <
7774 < cat > conftest.cpp <<EOF
7775 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
7776 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
7777 <     yes;
7778 < #  endif
7779 < #endif
7780 < EOF
7781 < if { ac_try='${CXX-c++} -E conftest.cpp'
7782 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7783 <  (eval $ac_try) 2>&5
7784 <  ac_status=$?
7785 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7786 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
7787 <  ac_cv_prog_gxx_2_95=yes
7788 < else
7789 <  ac_cv_prog_gxx_2_95=no
7790 < fi
7791 <
7792 < fi
7793 < echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
7794 < echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
7795 < if test "$ac_cv_prog_gxx_2_95" = yes; then
7796 <        :
7797 <
7798 <
7799 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
7800 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
7801 < if test "${ac_m_cpu_750+set}" = set; then
7802 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7803 < else
7804 <  echo 'void f(){}' > conftest.cpp
7805 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
7806 <        ac_m_cpu_750=yes
7807 < else
7808 <        ac_m_cpu_750=no
7809 < fi
7810 < rm -f conftest*
7811 <
7812 < fi
7813 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
7814 < echo "${ECHO_T}$ac_m_cpu_750" >&6
7815 < if test "$ac_m_cpu_750" = yes; then
7816 <        :
7817 <        CPU_FLAGS=-mcpu=750
7818 < else
7819 <        :
7820 <
7821 < fi
7822 <
7823 < else
7824 <        :
7825 <
7826 < fi
7827 <
7828 <                fi
7829 <                if test -z "$CPU_FLAGS"; then
7830 <
7831 <
7832 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
7833 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
7834 < if test "${ac_m_cpu_powerpc+set}" = set; then
7835 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7836 < else
7837 <  echo 'void f(){}' > conftest.cpp
7838 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
7839 <        ac_m_cpu_powerpc=yes
7840 < else
7841 <        ac_m_cpu_powerpc=no
7842 < fi
7843 < rm -f conftest*
7844 <
7845 < fi
7846 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
7847 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
7848 < if test "$ac_m_cpu_powerpc" = yes; then
7849 <        :
7850 <        CPU_FLAGS=-mcpu=powerpc
7851 < else
7852 <        :
7853 <
7854 < fi
7855 <
7856 <                fi
7857 <                if test -z "$CPU_FLAGS"; then
7858 <
7859 <
7860 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
7861 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
7862 < if test "${ac_m_powerpc+set}" = set; then
7863 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7864 < else
7865 <  echo 'void f(){}' > conftest.cpp
7866 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
7867 <        ac_m_powerpc=yes
7868 < else
7869 <        ac_m_powerpc=no
7870 < fi
7871 < rm -f conftest*
7872 <
7873 < fi
7874 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
7875 < echo "${ECHO_T}$ac_m_powerpc" >&6
7876 < if test "$ac_m_powerpc" = yes; then
7877 <        :
7878 <        CPU_FLAGS=-mpowerpc
7879 < else
7880 <        :
7881 <
7882 < fi
7883 <
7884 <                fi
7885 <          esac
7886 <  fi
7887 <
7888 <  if test -n "$CPU_FLAGS"; then
7889 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
7890 <  fi
7891 <
7892 <  if test -z "$CXXFLAGS"; then
7893 <        echo ""
7894 <        echo "**********************************************************"
7895 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
7896 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7897 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
7898 <        echo "**********************************************************"
7899 <        echo ""
7900 <        CXXFLAGS="-O3"
7901 <  fi
7902 <
7903 <
7904 <
7905 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
7906 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
7907 < if test "${ac_guessed_cxxflags+set}" = set; then
7908 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7909 < else
7910 <  echo 'void f(){}' > conftest.cpp
7911 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
7912 <        ac_guessed_cxxflags=yes
7913 < else
7914 <        ac_guessed_cxxflags=no
7915 < fi
7916 < rm -f conftest*
7917 <
7918 < fi
7919 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
7920 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
7921 < if test "$ac_guessed_cxxflags" = yes; then
7922 <        :
7923 <
7924 < else
7925 <        :
7926 <
7927 <        echo ""
7928 <        echo "**********************************************************"
7929 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
7930 <        echo "* your compiler.                                         *"
7931 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7932 <        echo "**********************************************************"
7933 <        echo ""
7934 <        CXXFLAGS=""
7935 <
7936 < fi
7937 <
7938 <
7939 < fi
7940 <
7941 <
7942 <
7943 <
7944 <
7945 < # Try to determine "good" native compiler flags if none specified on command
7946 < # line
7947 <
7948 < if test x"$F90FLAGS" = x ; then
7949 <  F90FLAGS=""
7950 <  case "${host_cpu}-${host_os}" in
7951 <
7952 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
7953 <                    F90FLAGS="-O"
7954 <                fi;;
7955 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
7956 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
7957 <                fi;;
7958 <   powerpc*-aix*)
7959 <        if test "$F90" = f90 -o "$F90" = xlf90; then
7960 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
7961 <                echo "*******************************************************"
7962 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
7963 <                echo "*  recommended that you use                           *"
7964 <                echo "*                                                     *"
7965 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
7966 <                echo "*                                 ^^^                 *"
7967 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
7968 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
7969 <                echo "*******************************************************"
7970 <        fi;;
7971 <   *darwin*)
7972 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
7973 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
7974 <        fi;;
7975 <  esac
7976 <
7977 <  if test -n "$CPU_FLAGS"; then
7978 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
7979 <  fi
7980 <
7981 <  if test -z "$F90FLAGS"; then
7982 <        echo ""
7983 <        echo "**********************************************************"
7984 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
7985 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
7986 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
7987 <        echo "**********************************************************"
7988 <        echo ""
7989 <        F90FLAGS="-O3"
7990 <  fi
7991 <
7992 <
7993 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
7994 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
7995 < if test "${ac_guessed_f90flags+set}" = set; then
7996 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7997 < else
7998 <
7999 <
8000 <
8001 < ac_ext=f90
8002 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8003 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8004 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8005 <
8006 < echo 'program main' > conftest.$ac_ext
8007 < echo 'end program main' >> conftest.$ac_ext
8008 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8009 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8010 <  (eval $ac_compile) 2>&5
8011 <  ac_status=$?
8012 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8013 <  (exit $ac_status); }; then
8014 <        ac_guessed_f90flags=yes
8015 < else
8016 <        ac_guessed_f90flags=no
8017 < fi
8018 < rm -f conftest*
8019 < ac_ext=c
8020 < ac_cpp='$CPP $CPPFLAGS'
8021 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8022 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8023 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8024 <
8025 <
8026 < fi
8027 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8028 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
8029 < if test "$ac_guessed_f90flags" = yes; then
8030 <        :
8031 <
8032 < else
8033 <        :
8034 <
8035 <        echo ""
8036 <        echo "**********************************************************"
8037 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8038 <        echo "* your compiler.                                         *"
8039 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8040 <        echo "**********************************************************"
8041 <        echo ""
8042 <        F90FLAGS=""
8043 <
8044 < fi
8045 <
8046 <
8047 < fi
8048 <
8049 <     ;;
8050 < esac
8051 <
8052 < # Find a good install program.  We prefer a C program (faster),
8053 < # so one script is as good as another.  But avoid the broken or
8054 < # incompatible versions:
8055 < # SysV /etc/install, /usr/sbin/install
8056 < # SunOS /usr/etc/install
8057 < # IRIX /sbin/install
8058 < # AIX /bin/install
8059 < # AmigaOS /C/install, which installs bootblocks on floppy discs
8060 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8061 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8062 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8063 < # OS/2's system install, which has a completely different semantic
8064 < # ./install, which can be erroneously created by make from ./install.sh.
8065 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8066 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8067 < if test -z "$INSTALL"; then
8068 < if test "${ac_cv_path_install+set}" = set; then
8069 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8070 < else
8071 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8072 < for as_dir in $PATH
8073 < do
8074 <  IFS=$as_save_IFS
8075 <  test -z "$as_dir" && as_dir=.
8076 <  # Account for people who put trailing slashes in PATH elements.
8077 < case $as_dir/ in
8078 <  ./ | .// | /cC/* | \
8079 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8080 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8081 <  /usr/ucb/* ) ;;
8082 <  *)
8083 <    # OSF1 and SCO ODT 3.0 have their own names for install.
8084 <    # Don't use installbsd from OSF since it installs stuff as root
8085 <    # by default.
8086 <    for ac_prog in ginstall scoinst install; do
8087 <      for ac_exec_ext in '' $ac_executable_extensions; do
8088 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8089 <          if test $ac_prog = install &&
8090 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8091 <            # AIX install.  It has an incompatible calling convention.
8092 <            :
8093 <          elif test $ac_prog = install &&
8094 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8095 <            # program-specific install script used by HP pwplus--don't use.
8096 <            :
8097 <          else
8098 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8099 <            break 3
8100 <          fi
8101 <        fi
8102 <      done
8103 <    done
8104 <    ;;
8105 < esac
8106 < done
8107 <
8108 <
8109 < fi
8110 <  if test "${ac_cv_path_install+set}" = set; then
8111 <    INSTALL=$ac_cv_path_install
8112 <  else
8113 <    # As a last resort, use the slow shell script.  We don't cache a
8114 <    # path for INSTALL within a source directory, because that will
8115 <    # break other packages using the cache if that directory is
8116 <    # removed, or if the path is relative.
8117 <    INSTALL=$ac_install_sh
8118 <  fi
8119 < fi
8120 < echo "$as_me:$LINENO: result: $INSTALL" >&5
8121 < echo "${ECHO_T}$INSTALL" >&6
8122 <
8123 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8124 < # It thinks the first close brace ends the variable substitution.
8125 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8126 <
8127 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8128 <
8129 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
7083 > if test $ac_cv_header_stdc = yes; then
7084 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7085 >  if test "$cross_compiling" = yes; then
7086 >  :
7087 > else
7088 >  cat >conftest.$ac_ext <<_ACEOF
7089 > /* confdefs.h.  */
7090 > _ACEOF
7091 > cat confdefs.h >>conftest.$ac_ext
7092 > cat >>conftest.$ac_ext <<_ACEOF
7093 > /* end confdefs.h.  */
7094 > #include <ctype.h>
7095 > #if ((' ' & 0x0FF) == 0x020)
7096 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7097 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7098 > #else
7099 > # define ISLOWER(c) \
7100 >                   (('a' <= (c) && (c) <= 'i') \
7101 >                     || ('j' <= (c) && (c) <= 'r') \
7102 >                     || ('s' <= (c) && (c) <= 'z'))
7103 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7104 > #endif
7105 >
7106 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7107 > int
7108 > main ()
7109 > {
7110 >  int i;
7111 >  for (i = 0; i < 256; i++)
7112 >    if (XOR (islower (i), ISLOWER (i))
7113 >        || toupper (i) != TOUPPER (i))
7114 >      exit(2);
7115 >  exit (0);
7116 > }
7117 > _ACEOF
7118 > rm -f conftest$ac_exeext
7119 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7120 >  (eval $ac_link) 2>&5
7121 >  ac_status=$?
7122 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7123 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7124 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7125 >  (eval $ac_try) 2>&5
7126 >  ac_status=$?
7127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7128 >  (exit $ac_status); }; }; then
7129 >  :
7130 > else
7131 >  echo "$as_me: program exited with status $ac_status" >&5
7132 > echo "$as_me: failed program was:" >&5
7133 > sed 's/^/| /' conftest.$ac_ext >&5
7134 >
7135 > ( exit $ac_status )
7136 > ac_cv_header_stdc=no
7137 > fi
7138 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7139 > fi
7140 > fi
7141 > fi
7142 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7143 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7144 > if test $ac_cv_header_stdc = yes; then
7145 >
7146 > cat >>confdefs.h <<\_ACEOF
7147 > #define STDC_HEADERS 1
7148 > _ACEOF
7149 >
7150 > fi
7151 >
7152 >
7153 >
7154 >
7155 >
7156 >
7157 >
7158 >
7159 >
7160 >
7161 >
7162 >
7163 >
7164 >
7165 >
7166 >
7167 >
7168 >
7169 >
7170 >
7171 >
7172 >
7173 >
7174 >
7175 >
7176 >
7177 > 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
7178 > do
7179 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7180 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7181 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7182 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7183 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7184 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7185 > fi
7186 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7187 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7188 > else
7189 >  # Is the header compilable?
7190 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7191 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7192 > cat >conftest.$ac_ext <<_ACEOF
7193 > /* confdefs.h.  */
7194 > _ACEOF
7195 > cat confdefs.h >>conftest.$ac_ext
7196 > cat >>conftest.$ac_ext <<_ACEOF
7197 > /* end confdefs.h.  */
7198 > $ac_includes_default
7199 > #include <$ac_header>
7200 > _ACEOF
7201 > rm -f conftest.$ac_objext
7202 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7203 >  (eval $ac_compile) 2>conftest.er1
7204 >  ac_status=$?
7205 >  grep -v '^ *+' conftest.er1 >conftest.err
7206 >  rm -f conftest.er1
7207 >  cat conftest.err >&5
7208 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7209 >  (exit $ac_status); } &&
7210 >         { ac_try='test -z "$ac_c_werror_flag"
7211 >                         || test ! -s conftest.err'
7212 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7213 >  (eval $ac_try) 2>&5
7214 >  ac_status=$?
7215 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7216 >  (exit $ac_status); }; } &&
7217 >         { ac_try='test -s conftest.$ac_objext'
7218 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7219 >  (eval $ac_try) 2>&5
7220 >  ac_status=$?
7221 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7222 >  (exit $ac_status); }; }; then
7223 >  ac_header_compiler=yes
7224 > else
7225 >  echo "$as_me: failed program was:" >&5
7226 > sed 's/^/| /' conftest.$ac_ext >&5
7227 >
7228 > ac_header_compiler=no
7229 > fi
7230 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7231 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7232 > echo "${ECHO_T}$ac_header_compiler" >&6
7233 >
7234 > # Is the header present?
7235 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7236 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7237 > cat >conftest.$ac_ext <<_ACEOF
7238 > /* confdefs.h.  */
7239 > _ACEOF
7240 > cat confdefs.h >>conftest.$ac_ext
7241 > cat >>conftest.$ac_ext <<_ACEOF
7242 > /* end confdefs.h.  */
7243 > #include <$ac_header>
7244 > _ACEOF
7245 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7246 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7247 >  ac_status=$?
7248 >  grep -v '^ *+' conftest.er1 >conftest.err
7249 >  rm -f conftest.er1
7250 >  cat conftest.err >&5
7251 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7252 >  (exit $ac_status); } >/dev/null; then
7253 >  if test -s conftest.err; then
7254 >    ac_cpp_err=$ac_c_preproc_warn_flag
7255 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7256 >  else
7257 >    ac_cpp_err=
7258 >  fi
7259 > else
7260 >  ac_cpp_err=yes
7261 > fi
7262 > if test -z "$ac_cpp_err"; then
7263 >  ac_header_preproc=yes
7264 > else
7265 >  echo "$as_me: failed program was:" >&5
7266 > sed 's/^/| /' conftest.$ac_ext >&5
7267 >
7268 >  ac_header_preproc=no
7269 > fi
7270 > rm -f conftest.err conftest.$ac_ext
7271 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7272 > echo "${ECHO_T}$ac_header_preproc" >&6
7273 >
7274 > # So?  What about this header?
7275 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7276 >  yes:no: )
7277 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7278 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7279 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7280 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7281 >    ac_header_preproc=yes
7282 >    ;;
7283 >  no:yes:* )
7284 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7285 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7286 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7287 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7288 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7289 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7290 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7291 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7292 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7293 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7294 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7295 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7296 >    (
7297 >      cat <<\_ASBOX
7298 > ## ------------------------------ ##
7299 > ## Report this to gezelter@nd.edu ##
7300 > ## ------------------------------ ##
7301 > _ASBOX
7302 >    ) |
7303 >      sed "s/^/$as_me: WARNING:     /" >&2
7304 >    ;;
7305 > esac
7306 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7307 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7308 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7309 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7310 > else
7311 >  eval "$as_ac_Header=\$ac_header_preproc"
7312 > fi
7313 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7314 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7315 >
7316 > fi
7317 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7318 >  cat >>confdefs.h <<_ACEOF
7319 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7320 > _ACEOF
7321 >
7322 > fi
7323 >
7324 > done
7325 >
7326 >
7327 > # Checks for typedefs, structures, and compiler characteristics.
7328 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7329 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7330 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7331 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7332 > else
7333 >  cat >conftest.$ac_ext <<_ACEOF
7334 > /* confdefs.h.  */
7335 > _ACEOF
7336 > cat confdefs.h >>conftest.$ac_ext
7337 > cat >>conftest.$ac_ext <<_ACEOF
7338 > /* end confdefs.h.  */
7339 >
7340 > #include <stdbool.h>
7341 > #ifndef bool
7342 > # error bool is not defined
7343 > #endif
7344 > #ifndef false
7345 > # error false is not defined
7346 > #endif
7347 > #if false
7348 > # error false is not 0
7349 > #endif
7350 > #ifndef true
7351 > # error true is not defined
7352 > #endif
7353 > #if true != 1
7354 > # error true is not 1
7355 > #endif
7356 > #ifndef __bool_true_false_are_defined
7357 > # error __bool_true_false_are_defined is not defined
7358 > #endif
7359 >
7360 >        struct s { _Bool s: 1; _Bool t; } s;
7361 >
7362 >        char a[true == 1 ? 1 : -1];
7363 >        char b[false == 0 ? 1 : -1];
7364 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7365 >        char d[(bool) -0.5 == true ? 1 : -1];
7366 >        bool e = &s;
7367 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7368 >        char g[true];
7369 >        char h[sizeof (_Bool)];
7370 >        char i[sizeof s.t];
7371 >
7372 > #ifdef FC_DUMMY_MAIN
7373 > #ifndef FC_DUMMY_MAIN_EQ_F77
7374 > #  ifdef __cplusplus
7375 >     extern "C"
7376 > #  endif
7377 >   int FC_DUMMY_MAIN() { return 1; }
7378 > #endif
7379 > #endif
7380 > int
7381 > main ()
7382 > {
7383 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7384 >  ;
7385 >  return 0;
7386 > }
7387 > _ACEOF
7388 > rm -f conftest.$ac_objext
7389 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7390 >  (eval $ac_compile) 2>conftest.er1
7391 >  ac_status=$?
7392 >  grep -v '^ *+' conftest.er1 >conftest.err
7393 >  rm -f conftest.er1
7394 >  cat conftest.err >&5
7395 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7396 >  (exit $ac_status); } &&
7397 >         { ac_try='test -z "$ac_c_werror_flag"
7398 >                         || test ! -s conftest.err'
7399 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7400 >  (eval $ac_try) 2>&5
7401 >  ac_status=$?
7402 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7403 >  (exit $ac_status); }; } &&
7404 >         { ac_try='test -s conftest.$ac_objext'
7405 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7406 >  (eval $ac_try) 2>&5
7407 >  ac_status=$?
7408 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7409 >  (exit $ac_status); }; }; then
7410 >  ac_cv_header_stdbool_h=yes
7411 > else
7412 >  echo "$as_me: failed program was:" >&5
7413 > sed 's/^/| /' conftest.$ac_ext >&5
7414 >
7415 > ac_cv_header_stdbool_h=no
7416 > fi
7417 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7418 > fi
7419 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7420 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7421 > echo "$as_me:$LINENO: checking for _Bool" >&5
7422 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7423 > if test "${ac_cv_type__Bool+set}" = set; then
7424 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7425 > else
7426 >  cat >conftest.$ac_ext <<_ACEOF
7427 > /* confdefs.h.  */
7428 > _ACEOF
7429 > cat confdefs.h >>conftest.$ac_ext
7430 > cat >>conftest.$ac_ext <<_ACEOF
7431 > /* end confdefs.h.  */
7432 > $ac_includes_default
7433 > #ifdef FC_DUMMY_MAIN
7434 > #ifndef FC_DUMMY_MAIN_EQ_F77
7435 > #  ifdef __cplusplus
7436 >     extern "C"
7437 > #  endif
7438 >   int FC_DUMMY_MAIN() { return 1; }
7439 > #endif
7440 > #endif
7441 > int
7442 > main ()
7443 > {
7444 > if ((_Bool *) 0)
7445 >  return 0;
7446 > if (sizeof (_Bool))
7447 >  return 0;
7448 >  ;
7449 >  return 0;
7450 > }
7451 > _ACEOF
7452 > rm -f conftest.$ac_objext
7453 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7454 >  (eval $ac_compile) 2>conftest.er1
7455 >  ac_status=$?
7456 >  grep -v '^ *+' conftest.er1 >conftest.err
7457 >  rm -f conftest.er1
7458 >  cat conftest.err >&5
7459 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7460 >  (exit $ac_status); } &&
7461 >         { ac_try='test -z "$ac_c_werror_flag"
7462 >                         || test ! -s conftest.err'
7463 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7464 >  (eval $ac_try) 2>&5
7465 >  ac_status=$?
7466 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7467 >  (exit $ac_status); }; } &&
7468 >         { ac_try='test -s conftest.$ac_objext'
7469 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7470 >  (eval $ac_try) 2>&5
7471 >  ac_status=$?
7472 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7473 >  (exit $ac_status); }; }; then
7474 >  ac_cv_type__Bool=yes
7475 > else
7476 >  echo "$as_me: failed program was:" >&5
7477 > sed 's/^/| /' conftest.$ac_ext >&5
7478 >
7479 > ac_cv_type__Bool=no
7480 > fi
7481 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7482 > fi
7483 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7484 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7485 > if test $ac_cv_type__Bool = yes; then
7486 >
7487 > cat >>confdefs.h <<_ACEOF
7488 > #define HAVE__BOOL 1
7489 > _ACEOF
7490 >
7491 >
7492 > fi
7493 >
7494 > if test $ac_cv_header_stdbool_h = yes; then
7495 >
7496 > cat >>confdefs.h <<\_ACEOF
7497 > #define HAVE_STDBOOL_H 1
7498 > _ACEOF
7499 >
7500 > fi
7501 >
7502 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7503 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7504 > if test "${ac_cv_c_const+set}" = set; then
7505 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7506 > else
7507 >  cat >conftest.$ac_ext <<_ACEOF
7508 > /* confdefs.h.  */
7509 > _ACEOF
7510 > cat confdefs.h >>conftest.$ac_ext
7511 > cat >>conftest.$ac_ext <<_ACEOF
7512 > /* end confdefs.h.  */
7513 >
7514 > #ifdef FC_DUMMY_MAIN
7515 > #ifndef FC_DUMMY_MAIN_EQ_F77
7516 > #  ifdef __cplusplus
7517 >     extern "C"
7518 > #  endif
7519 >   int FC_DUMMY_MAIN() { return 1; }
7520 > #endif
7521 > #endif
7522 > int
7523 > main ()
7524 > {
7525 > /* FIXME: Include the comments suggested by Paul. */
7526 > #ifndef __cplusplus
7527 >  /* Ultrix mips cc rejects this.  */
7528 >  typedef int charset[2];
7529 >  const charset x;
7530 >  /* SunOS 4.1.1 cc rejects this.  */
7531 >  char const *const *ccp;
7532 >  char **p;
7533 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7534 >  struct point {int x, y;};
7535 >  static struct point const zero = {0,0};
7536 >  /* AIX XL C 1.02.0.0 rejects this.
7537 >     It does not let you subtract one const X* pointer from another in
7538 >     an arm of an if-expression whose if-part is not a constant
7539 >     expression */
7540 >  const char *g = "string";
7541 >  ccp = &g + (g ? g-g : 0);
7542 >  /* HPUX 7.0 cc rejects these. */
7543 >  ++ccp;
7544 >  p = (char**) ccp;
7545 >  ccp = (char const *const *) p;
7546 >  { /* SCO 3.2v4 cc rejects this.  */
7547 >    char *t;
7548 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7549 >
7550 >    *t++ = 0;
7551 >  }
7552 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7553 >    int x[] = {25, 17};
7554 >    const int *foo = &x[0];
7555 >    ++foo;
7556 >  }
7557 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7558 >    typedef const int *iptr;
7559 >    iptr p = 0;
7560 >    ++p;
7561 >  }
7562 >  { /* AIX XL C 1.02.0.0 rejects this saying
7563 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7564 >    struct s { int j; const int *ap[3]; };
7565 >    struct s *b; b->j = 5;
7566 >  }
7567 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7568 >    const int foo = 10;
7569 >  }
7570 > #endif
7571 >
7572 >  ;
7573 >  return 0;
7574 > }
7575 > _ACEOF
7576 > rm -f conftest.$ac_objext
7577 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7578 >  (eval $ac_compile) 2>conftest.er1
7579 >  ac_status=$?
7580 >  grep -v '^ *+' conftest.er1 >conftest.err
7581 >  rm -f conftest.er1
7582 >  cat conftest.err >&5
7583 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7584 >  (exit $ac_status); } &&
7585 >         { ac_try='test -z "$ac_c_werror_flag"
7586 >                         || test ! -s conftest.err'
7587 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7588 >  (eval $ac_try) 2>&5
7589 >  ac_status=$?
7590 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7591 >  (exit $ac_status); }; } &&
7592 >         { ac_try='test -s conftest.$ac_objext'
7593 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7594 >  (eval $ac_try) 2>&5
7595 >  ac_status=$?
7596 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7597 >  (exit $ac_status); }; }; then
7598 >  ac_cv_c_const=yes
7599 > else
7600 >  echo "$as_me: failed program was:" >&5
7601 > sed 's/^/| /' conftest.$ac_ext >&5
7602 >
7603 > ac_cv_c_const=no
7604 > fi
7605 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7606 > fi
7607 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7608 > echo "${ECHO_T}$ac_cv_c_const" >&6
7609 > if test $ac_cv_c_const = no; then
7610 >
7611 > cat >>confdefs.h <<\_ACEOF
7612 > #define const
7613 > _ACEOF
7614 >
7615 > fi
7616 >
7617 > echo "$as_me:$LINENO: checking for inline" >&5
7618 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7619 > if test "${ac_cv_c_inline+set}" = set; then
7620 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7621 > else
7622 >  ac_cv_c_inline=no
7623 > for ac_kw in inline __inline__ __inline; do
7624 >  cat >conftest.$ac_ext <<_ACEOF
7625 > /* confdefs.h.  */
7626 > _ACEOF
7627 > cat confdefs.h >>conftest.$ac_ext
7628 > cat >>conftest.$ac_ext <<_ACEOF
7629 > /* end confdefs.h.  */
7630 > #ifndef __cplusplus
7631 > typedef int foo_t;
7632 > static $ac_kw foo_t static_foo () {return 0; }
7633 > $ac_kw foo_t foo () {return 0; }
7634 > #endif
7635 >
7636 > _ACEOF
7637 > rm -f conftest.$ac_objext
7638 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7639 >  (eval $ac_compile) 2>conftest.er1
7640 >  ac_status=$?
7641 >  grep -v '^ *+' conftest.er1 >conftest.err
7642 >  rm -f conftest.er1
7643 >  cat conftest.err >&5
7644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7645 >  (exit $ac_status); } &&
7646 >         { ac_try='test -z "$ac_c_werror_flag"
7647 >                         || test ! -s conftest.err'
7648 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7649 >  (eval $ac_try) 2>&5
7650 >  ac_status=$?
7651 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7652 >  (exit $ac_status); }; } &&
7653 >         { ac_try='test -s conftest.$ac_objext'
7654 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7655 >  (eval $ac_try) 2>&5
7656 >  ac_status=$?
7657 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7658 >  (exit $ac_status); }; }; then
7659 >  ac_cv_c_inline=$ac_kw; break
7660 > else
7661 >  echo "$as_me: failed program was:" >&5
7662 > sed 's/^/| /' conftest.$ac_ext >&5
7663 >
7664 > fi
7665 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666 > done
7667 >
7668 > fi
7669 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7670 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7671 >
7672 >
7673 > case $ac_cv_c_inline in
7674 >  inline | yes) ;;
7675 >  *)
7676 >    case $ac_cv_c_inline in
7677 >      no) ac_val=;;
7678 >      *) ac_val=$ac_cv_c_inline;;
7679 >    esac
7680 >    cat >>confdefs.h <<_ACEOF
7681 > #ifndef __cplusplus
7682 > #define inline $ac_val
7683 > #endif
7684 > _ACEOF
7685 >    ;;
7686 > esac
7687 >
7688 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7689 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7690 > if test "${ac_cv_c_restrict+set}" = set; then
7691 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7692 > else
7693 >  ac_cv_c_restrict=no
7694 >   # Try the official restrict keyword, then gcc's __restrict, and
7695 >   # the less common variants.
7696 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7697 >     cat >conftest.$ac_ext <<_ACEOF
7698 > /* confdefs.h.  */
7699 > _ACEOF
7700 > cat confdefs.h >>conftest.$ac_ext
7701 > cat >>conftest.$ac_ext <<_ACEOF
7702 > /* end confdefs.h.  */
7703 > float * $ac_kw x;
7704 > _ACEOF
7705 > rm -f conftest.$ac_objext
7706 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7707 >  (eval $ac_compile) 2>conftest.er1
7708 >  ac_status=$?
7709 >  grep -v '^ *+' conftest.er1 >conftest.err
7710 >  rm -f conftest.er1
7711 >  cat conftest.err >&5
7712 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7713 >  (exit $ac_status); } &&
7714 >         { ac_try='test -z "$ac_c_werror_flag"
7715 >                         || test ! -s conftest.err'
7716 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7717 >  (eval $ac_try) 2>&5
7718 >  ac_status=$?
7719 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720 >  (exit $ac_status); }; } &&
7721 >         { ac_try='test -s conftest.$ac_objext'
7722 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7723 >  (eval $ac_try) 2>&5
7724 >  ac_status=$?
7725 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7726 >  (exit $ac_status); }; }; then
7727 >  ac_cv_c_restrict=$ac_kw; break
7728 > else
7729 >  echo "$as_me: failed program was:" >&5
7730 > sed 's/^/| /' conftest.$ac_ext >&5
7731 >
7732 > fi
7733 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7734 >   done
7735 >
7736 > fi
7737 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7738 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7739 > case $ac_cv_c_restrict in
7740 >   restrict) ;;
7741 >   no)
7742 > cat >>confdefs.h <<\_ACEOF
7743 > #define restrict
7744 > _ACEOF
7745 > ;;
7746 >   *)  cat >>confdefs.h <<_ACEOF
7747 > #define restrict $ac_cv_c_restrict
7748 > _ACEOF
7749 > ;;
7750 > esac
7751 >
7752 > echo "$as_me:$LINENO: checking for size_t" >&5
7753 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7754 > if test "${ac_cv_type_size_t+set}" = set; then
7755 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7756 > else
7757 >  cat >conftest.$ac_ext <<_ACEOF
7758 > /* confdefs.h.  */
7759 > _ACEOF
7760 > cat confdefs.h >>conftest.$ac_ext
7761 > cat >>conftest.$ac_ext <<_ACEOF
7762 > /* end confdefs.h.  */
7763 > $ac_includes_default
7764 > #ifdef FC_DUMMY_MAIN
7765 > #ifndef FC_DUMMY_MAIN_EQ_F77
7766 > #  ifdef __cplusplus
7767 >     extern "C"
7768 > #  endif
7769 >   int FC_DUMMY_MAIN() { return 1; }
7770 > #endif
7771 > #endif
7772 > int
7773 > main ()
7774 > {
7775 > if ((size_t *) 0)
7776 >  return 0;
7777 > if (sizeof (size_t))
7778 >  return 0;
7779 >  ;
7780 >  return 0;
7781 > }
7782 > _ACEOF
7783 > rm -f conftest.$ac_objext
7784 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7785 >  (eval $ac_compile) 2>conftest.er1
7786 >  ac_status=$?
7787 >  grep -v '^ *+' conftest.er1 >conftest.err
7788 >  rm -f conftest.er1
7789 >  cat conftest.err >&5
7790 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7791 >  (exit $ac_status); } &&
7792 >         { ac_try='test -z "$ac_c_werror_flag"
7793 >                         || test ! -s conftest.err'
7794 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7795 >  (eval $ac_try) 2>&5
7796 >  ac_status=$?
7797 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7798 >  (exit $ac_status); }; } &&
7799 >         { ac_try='test -s conftest.$ac_objext'
7800 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7801 >  (eval $ac_try) 2>&5
7802 >  ac_status=$?
7803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7804 >  (exit $ac_status); }; }; then
7805 >  ac_cv_type_size_t=yes
7806 > else
7807 >  echo "$as_me: failed program was:" >&5
7808 > sed 's/^/| /' conftest.$ac_ext >&5
7809 >
7810 > ac_cv_type_size_t=no
7811 > fi
7812 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7813 > fi
7814 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7815 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7816 > if test $ac_cv_type_size_t = yes; then
7817 >  :
7818 > else
7819 >
7820 > cat >>confdefs.h <<_ACEOF
7821 > #define size_t unsigned
7822 > _ACEOF
7823 >
7824 > fi
7825 >
7826 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7827 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7828 > if test "${ac_cv_header_time+set}" = set; then
7829 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7830 > else
7831 >  cat >conftest.$ac_ext <<_ACEOF
7832 > /* confdefs.h.  */
7833 > _ACEOF
7834 > cat confdefs.h >>conftest.$ac_ext
7835 > cat >>conftest.$ac_ext <<_ACEOF
7836 > /* end confdefs.h.  */
7837 > #include <sys/types.h>
7838 > #include <sys/time.h>
7839 > #include <time.h>
7840 >
7841 > #ifdef FC_DUMMY_MAIN
7842 > #ifndef FC_DUMMY_MAIN_EQ_F77
7843 > #  ifdef __cplusplus
7844 >     extern "C"
7845 > #  endif
7846 >   int FC_DUMMY_MAIN() { return 1; }
7847 > #endif
7848 > #endif
7849 > int
7850 > main ()
7851 > {
7852 > if ((struct tm *) 0)
7853 > return 0;
7854 >  ;
7855 >  return 0;
7856 > }
7857 > _ACEOF
7858 > rm -f conftest.$ac_objext
7859 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7860 >  (eval $ac_compile) 2>conftest.er1
7861 >  ac_status=$?
7862 >  grep -v '^ *+' conftest.er1 >conftest.err
7863 >  rm -f conftest.er1
7864 >  cat conftest.err >&5
7865 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7866 >  (exit $ac_status); } &&
7867 >         { ac_try='test -z "$ac_c_werror_flag"
7868 >                         || test ! -s conftest.err'
7869 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7870 >  (eval $ac_try) 2>&5
7871 >  ac_status=$?
7872 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7873 >  (exit $ac_status); }; } &&
7874 >         { ac_try='test -s conftest.$ac_objext'
7875 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7876 >  (eval $ac_try) 2>&5
7877 >  ac_status=$?
7878 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879 >  (exit $ac_status); }; }; then
7880 >  ac_cv_header_time=yes
7881 > else
7882 >  echo "$as_me: failed program was:" >&5
7883 > sed 's/^/| /' conftest.$ac_ext >&5
7884 >
7885 > ac_cv_header_time=no
7886 > fi
7887 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7888 > fi
7889 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7890 > echo "${ECHO_T}$ac_cv_header_time" >&6
7891 > if test $ac_cv_header_time = yes; then
7892 >
7893 > cat >>confdefs.h <<\_ACEOF
7894 > #define TIME_WITH_SYS_TIME 1
7895 > _ACEOF
7896 >
7897 > fi
7898 >
7899 > echo "$as_me:$LINENO: checking for clock_t" >&5
7900 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7901 > if test "${ac_cv_type_clock_t+set}" = set; then
7902 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7903 > else
7904 >  cat >conftest.$ac_ext <<_ACEOF
7905 > /* confdefs.h.  */
7906 > _ACEOF
7907 > cat confdefs.h >>conftest.$ac_ext
7908 > cat >>conftest.$ac_ext <<_ACEOF
7909 > /* end confdefs.h.  */
7910 > $ac_includes_default
7911 > #ifdef FC_DUMMY_MAIN
7912 > #ifndef FC_DUMMY_MAIN_EQ_F77
7913 > #  ifdef __cplusplus
7914 >     extern "C"
7915 > #  endif
7916 >   int FC_DUMMY_MAIN() { return 1; }
7917 > #endif
7918 > #endif
7919 > int
7920 > main ()
7921 > {
7922 > if ((clock_t *) 0)
7923 >  return 0;
7924 > if (sizeof (clock_t))
7925 >  return 0;
7926 >  ;
7927 >  return 0;
7928 > }
7929 > _ACEOF
7930 > rm -f conftest.$ac_objext
7931 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7932 >  (eval $ac_compile) 2>conftest.er1
7933 >  ac_status=$?
7934 >  grep -v '^ *+' conftest.er1 >conftest.err
7935 >  rm -f conftest.er1
7936 >  cat conftest.err >&5
7937 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7938 >  (exit $ac_status); } &&
7939 >         { ac_try='test -z "$ac_c_werror_flag"
7940 >                         || test ! -s conftest.err'
7941 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7942 >  (eval $ac_try) 2>&5
7943 >  ac_status=$?
7944 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7945 >  (exit $ac_status); }; } &&
7946 >         { ac_try='test -s conftest.$ac_objext'
7947 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7948 >  (eval $ac_try) 2>&5
7949 >  ac_status=$?
7950 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7951 >  (exit $ac_status); }; }; then
7952 >  ac_cv_type_clock_t=yes
7953 > else
7954 >  echo "$as_me: failed program was:" >&5
7955 > sed 's/^/| /' conftest.$ac_ext >&5
7956 >
7957 > ac_cv_type_clock_t=no
7958 > fi
7959 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7960 > fi
7961 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7962 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7963 > if test $ac_cv_type_clock_t = yes; then
7964 >
7965 > cat >>confdefs.h <<_ACEOF
7966 > #define HAVE_CLOCK_T 1
7967 > _ACEOF
7968 >
7969 >
7970 > fi
7971 >
7972 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7973 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7974 > if test "${ac_cv_c_const+set}" = set; then
7975 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7976 > else
7977 >  cat >conftest.$ac_ext <<_ACEOF
7978 > /* confdefs.h.  */
7979 > _ACEOF
7980 > cat confdefs.h >>conftest.$ac_ext
7981 > cat >>conftest.$ac_ext <<_ACEOF
7982 > /* end confdefs.h.  */
7983 >
7984 > #ifdef FC_DUMMY_MAIN
7985 > #ifndef FC_DUMMY_MAIN_EQ_F77
7986 > #  ifdef __cplusplus
7987 >     extern "C"
7988 > #  endif
7989 >   int FC_DUMMY_MAIN() { return 1; }
7990 > #endif
7991 > #endif
7992 > int
7993 > main ()
7994 > {
7995 > /* FIXME: Include the comments suggested by Paul. */
7996 > #ifndef __cplusplus
7997 >  /* Ultrix mips cc rejects this.  */
7998 >  typedef int charset[2];
7999 >  const charset x;
8000 >  /* SunOS 4.1.1 cc rejects this.  */
8001 >  char const *const *ccp;
8002 >  char **p;
8003 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8004 >  struct point {int x, y;};
8005 >  static struct point const zero = {0,0};
8006 >  /* AIX XL C 1.02.0.0 rejects this.
8007 >     It does not let you subtract one const X* pointer from another in
8008 >     an arm of an if-expression whose if-part is not a constant
8009 >     expression */
8010 >  const char *g = "string";
8011 >  ccp = &g + (g ? g-g : 0);
8012 >  /* HPUX 7.0 cc rejects these. */
8013 >  ++ccp;
8014 >  p = (char**) ccp;
8015 >  ccp = (char const *const *) p;
8016 >  { /* SCO 3.2v4 cc rejects this.  */
8017 >    char *t;
8018 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8019 >
8020 >    *t++ = 0;
8021 >  }
8022 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8023 >    int x[] = {25, 17};
8024 >    const int *foo = &x[0];
8025 >    ++foo;
8026 >  }
8027 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8028 >    typedef const int *iptr;
8029 >    iptr p = 0;
8030 >    ++p;
8031 >  }
8032 >  { /* AIX XL C 1.02.0.0 rejects this saying
8033 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8034 >    struct s { int j; const int *ap[3]; };
8035 >    struct s *b; b->j = 5;
8036 >  }
8037 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8038 >    const int foo = 10;
8039 >  }
8040 > #endif
8041 >
8042 >  ;
8043 >  return 0;
8044 > }
8045 > _ACEOF
8046 > rm -f conftest.$ac_objext
8047 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8048 >  (eval $ac_compile) 2>conftest.er1
8049 >  ac_status=$?
8050 >  grep -v '^ *+' conftest.er1 >conftest.err
8051 >  rm -f conftest.er1
8052 >  cat conftest.err >&5
8053 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8054 >  (exit $ac_status); } &&
8055 >         { ac_try='test -z "$ac_c_werror_flag"
8056 >                         || test ! -s conftest.err'
8057 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8058 >  (eval $ac_try) 2>&5
8059 >  ac_status=$?
8060 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8061 >  (exit $ac_status); }; } &&
8062 >         { ac_try='test -s conftest.$ac_objext'
8063 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8064 >  (eval $ac_try) 2>&5
8065 >  ac_status=$?
8066 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8067 >  (exit $ac_status); }; }; then
8068 >  ac_cv_c_const=yes
8069 > else
8070 >  echo "$as_me: failed program was:" >&5
8071 > sed 's/^/| /' conftest.$ac_ext >&5
8072 >
8073 > ac_cv_c_const=no
8074 > fi
8075 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8076 > fi
8077 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8078 > echo "${ECHO_T}$ac_cv_c_const" >&6
8079 > if test $ac_cv_c_const = no; then
8080 >
8081 > cat >>confdefs.h <<\_ACEOF
8082 > #define const
8083 > _ACEOF
8084 >
8085 > fi
8086 >
8087 > echo "$as_me:$LINENO: checking for inline" >&5
8088 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8089 > if test "${ac_cv_c_inline+set}" = set; then
8090 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8091 > else
8092 >  ac_cv_c_inline=no
8093 > for ac_kw in inline __inline__ __inline; do
8094 >  cat >conftest.$ac_ext <<_ACEOF
8095 > /* confdefs.h.  */
8096 > _ACEOF
8097 > cat confdefs.h >>conftest.$ac_ext
8098 > cat >>conftest.$ac_ext <<_ACEOF
8099 > /* end confdefs.h.  */
8100 > #ifndef __cplusplus
8101 > typedef int foo_t;
8102 > static $ac_kw foo_t static_foo () {return 0; }
8103 > $ac_kw foo_t foo () {return 0; }
8104 > #endif
8105 >
8106 > _ACEOF
8107 > rm -f conftest.$ac_objext
8108 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8109 >  (eval $ac_compile) 2>conftest.er1
8110 >  ac_status=$?
8111 >  grep -v '^ *+' conftest.er1 >conftest.err
8112 >  rm -f conftest.er1
8113 >  cat conftest.err >&5
8114 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8115 >  (exit $ac_status); } &&
8116 >         { ac_try='test -z "$ac_c_werror_flag"
8117 >                         || test ! -s conftest.err'
8118 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8119 >  (eval $ac_try) 2>&5
8120 >  ac_status=$?
8121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122 >  (exit $ac_status); }; } &&
8123 >         { ac_try='test -s conftest.$ac_objext'
8124 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8125 >  (eval $ac_try) 2>&5
8126 >  ac_status=$?
8127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8128 >  (exit $ac_status); }; }; then
8129 >  ac_cv_c_inline=$ac_kw; break
8130 > else
8131 >  echo "$as_me: failed program was:" >&5
8132 > sed 's/^/| /' conftest.$ac_ext >&5
8133 >
8134 > fi
8135 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136 > done
8137 >
8138 > fi
8139 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8140 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8141 >
8142 >
8143 > case $ac_cv_c_inline in
8144 >  inline | yes) ;;
8145 >  *)
8146 >    case $ac_cv_c_inline in
8147 >      no) ac_val=;;
8148 >      *) ac_val=$ac_cv_c_inline;;
8149 >    esac
8150 >    cat >>confdefs.h <<_ACEOF
8151 > #ifndef __cplusplus
8152 > #define inline $ac_val
8153 > #endif
8154 > _ACEOF
8155 >    ;;
8156 > esac
8157 >
8158 >
8159 > # Checks for library functions.
8160 >
8161 > for ac_header in stdlib.h
8162 > do
8163 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8164 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8165 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8166 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8167 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8168 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8169 > fi
8170 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8171 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8172 > else
8173 >  # Is the header compilable?
8174 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8175 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8176 > cat >conftest.$ac_ext <<_ACEOF
8177 > /* confdefs.h.  */
8178 > _ACEOF
8179 > cat confdefs.h >>conftest.$ac_ext
8180 > cat >>conftest.$ac_ext <<_ACEOF
8181 > /* end confdefs.h.  */
8182 > $ac_includes_default
8183 > #include <$ac_header>
8184 > _ACEOF
8185 > rm -f conftest.$ac_objext
8186 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8187 >  (eval $ac_compile) 2>conftest.er1
8188 >  ac_status=$?
8189 >  grep -v '^ *+' conftest.er1 >conftest.err
8190 >  rm -f conftest.er1
8191 >  cat conftest.err >&5
8192 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193 >  (exit $ac_status); } &&
8194 >         { ac_try='test -z "$ac_c_werror_flag"
8195 >                         || test ! -s conftest.err'
8196 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8197 >  (eval $ac_try) 2>&5
8198 >  ac_status=$?
8199 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8200 >  (exit $ac_status); }; } &&
8201 >         { ac_try='test -s conftest.$ac_objext'
8202 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8203 >  (eval $ac_try) 2>&5
8204 >  ac_status=$?
8205 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8206 >  (exit $ac_status); }; }; then
8207 >  ac_header_compiler=yes
8208 > else
8209 >  echo "$as_me: failed program was:" >&5
8210 > sed 's/^/| /' conftest.$ac_ext >&5
8211 >
8212 > ac_header_compiler=no
8213 > fi
8214 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8215 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8216 > echo "${ECHO_T}$ac_header_compiler" >&6
8217 >
8218 > # Is the header present?
8219 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8220 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8221 > cat >conftest.$ac_ext <<_ACEOF
8222 > /* confdefs.h.  */
8223 > _ACEOF
8224 > cat confdefs.h >>conftest.$ac_ext
8225 > cat >>conftest.$ac_ext <<_ACEOF
8226 > /* end confdefs.h.  */
8227 > #include <$ac_header>
8228 > _ACEOF
8229 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8230 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8231 >  ac_status=$?
8232 >  grep -v '^ *+' conftest.er1 >conftest.err
8233 >  rm -f conftest.er1
8234 >  cat conftest.err >&5
8235 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8236 >  (exit $ac_status); } >/dev/null; then
8237 >  if test -s conftest.err; then
8238 >    ac_cpp_err=$ac_c_preproc_warn_flag
8239 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8240 >  else
8241 >    ac_cpp_err=
8242 >  fi
8243 > else
8244 >  ac_cpp_err=yes
8245 > fi
8246 > if test -z "$ac_cpp_err"; then
8247 >  ac_header_preproc=yes
8248 > else
8249 >  echo "$as_me: failed program was:" >&5
8250 > sed 's/^/| /' conftest.$ac_ext >&5
8251 >
8252 >  ac_header_preproc=no
8253 > fi
8254 > rm -f conftest.err conftest.$ac_ext
8255 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8256 > echo "${ECHO_T}$ac_header_preproc" >&6
8257 >
8258 > # So?  What about this header?
8259 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8260 >  yes:no: )
8261 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8262 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8263 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8264 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8265 >    ac_header_preproc=yes
8266 >    ;;
8267 >  no:yes:* )
8268 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8269 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8270 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8271 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8272 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8273 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8274 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8275 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8276 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8277 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8278 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8279 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8280 >    (
8281 >      cat <<\_ASBOX
8282 > ## ------------------------------ ##
8283 > ## Report this to gezelter@nd.edu ##
8284 > ## ------------------------------ ##
8285 > _ASBOX
8286 >    ) |
8287 >      sed "s/^/$as_me: WARNING:     /" >&2
8288 >    ;;
8289 > esac
8290 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8291 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8292 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8293 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8294 > else
8295 >  eval "$as_ac_Header=\$ac_header_preproc"
8296 > fi
8297 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8298 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8299 >
8300 > fi
8301 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8302 >  cat >>confdefs.h <<_ACEOF
8303 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8304 > _ACEOF
8305 >
8306 > fi
8307 >
8308 > done
8309 >
8310 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8311 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8312 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8313 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8314 > else
8315 >  if test "$cross_compiling" = yes; then
8316 >  ac_cv_func_malloc_0_nonnull=no
8317 > else
8318 >  cat >conftest.$ac_ext <<_ACEOF
8319 > /* confdefs.h.  */
8320 > _ACEOF
8321 > cat confdefs.h >>conftest.$ac_ext
8322 > cat >>conftest.$ac_ext <<_ACEOF
8323 > /* end confdefs.h.  */
8324 > #if STDC_HEADERS || HAVE_STDLIB_H
8325 > # include <stdlib.h>
8326 > #else
8327 > char *malloc ();
8328 > #endif
8329 >
8330 > #ifdef FC_DUMMY_MAIN
8331 > #ifndef FC_DUMMY_MAIN_EQ_F77
8332 > #  ifdef __cplusplus
8333 >     extern "C"
8334 > #  endif
8335 >   int FC_DUMMY_MAIN() { return 1; }
8336 > #endif
8337 > #endif
8338 > int
8339 > main ()
8340 > {
8341 > exit (malloc (0) ? 0 : 1);
8342 >  ;
8343 >  return 0;
8344 > }
8345 > _ACEOF
8346 > rm -f conftest$ac_exeext
8347 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8348 >  (eval $ac_link) 2>&5
8349 >  ac_status=$?
8350 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8351 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8352 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8353 >  (eval $ac_try) 2>&5
8354 >  ac_status=$?
8355 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8356 >  (exit $ac_status); }; }; then
8357 >  ac_cv_func_malloc_0_nonnull=yes
8358 > else
8359 >  echo "$as_me: program exited with status $ac_status" >&5
8360 > echo "$as_me: failed program was:" >&5
8361 > sed 's/^/| /' conftest.$ac_ext >&5
8362 >
8363 > ( exit $ac_status )
8364 > ac_cv_func_malloc_0_nonnull=no
8365 > fi
8366 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8367 > fi
8368 > fi
8369 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8370 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8371 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8372 >
8373 > cat >>confdefs.h <<\_ACEOF
8374 > #define HAVE_MALLOC 1
8375 > _ACEOF
8376 >
8377 > else
8378 >  cat >>confdefs.h <<\_ACEOF
8379 > #define HAVE_MALLOC 0
8380 > _ACEOF
8381 >
8382 >   case $LIBOBJS in
8383 >    "malloc.$ac_objext"   | \
8384 >  *" malloc.$ac_objext"   | \
8385 >    "malloc.$ac_objext "* | \
8386 >  *" malloc.$ac_objext "* ) ;;
8387 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8388 > esac
8389 >
8390 >
8391 > cat >>confdefs.h <<\_ACEOF
8392 > #define malloc rpl_malloc
8393 > _ACEOF
8394 >
8395 > fi
8396 >
8397 >
8398 >
8399 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8400 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8401 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8402 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8403 > else
8404 >  if test "$cross_compiling" = yes; then
8405 >  ac_cv_func_memcmp_working=no
8406 > else
8407 >  cat >conftest.$ac_ext <<_ACEOF
8408 > /* confdefs.h.  */
8409 > _ACEOF
8410 > cat confdefs.h >>conftest.$ac_ext
8411 > cat >>conftest.$ac_ext <<_ACEOF
8412 > /* end confdefs.h.  */
8413 > $ac_includes_default
8414 > #ifdef FC_DUMMY_MAIN
8415 > #ifndef FC_DUMMY_MAIN_EQ_F77
8416 > #  ifdef __cplusplus
8417 >     extern "C"
8418 > #  endif
8419 >   int FC_DUMMY_MAIN() { return 1; }
8420 > #endif
8421 > #endif
8422 > int
8423 > main ()
8424 > {
8425 >
8426 >  /* Some versions of memcmp are not 8-bit clean.  */
8427 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8428 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8429 >    exit (1);
8430 >
8431 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8432 >     or more and with at least one buffer not starting on a 4-byte boundary.
8433 >     William Lewis provided this test program.   */
8434 >  {
8435 >    char foo[21];
8436 >    char bar[21];
8437 >    int i;
8438 >    for (i = 0; i < 4; i++)
8439 >      {
8440 >        char *a = foo + i;
8441 >        char *b = bar + i;
8442 >        strcpy (a, "--------01111111");
8443 >        strcpy (b, "--------10000000");
8444 >        if (memcmp (a, b, 16) >= 0)
8445 >          exit (1);
8446 >      }
8447 >    exit (0);
8448 >  }
8449 >
8450 >  ;
8451 >  return 0;
8452 > }
8453 > _ACEOF
8454 > rm -f conftest$ac_exeext
8455 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8456 >  (eval $ac_link) 2>&5
8457 >  ac_status=$?
8458 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8459 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8461 >  (eval $ac_try) 2>&5
8462 >  ac_status=$?
8463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8464 >  (exit $ac_status); }; }; then
8465 >  ac_cv_func_memcmp_working=yes
8466 > else
8467 >  echo "$as_me: program exited with status $ac_status" >&5
8468 > echo "$as_me: failed program was:" >&5
8469 > sed 's/^/| /' conftest.$ac_ext >&5
8470 >
8471 > ( exit $ac_status )
8472 > ac_cv_func_memcmp_working=no
8473 > fi
8474 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8475 > fi
8476 > fi
8477 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8478 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8479 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8480 >    "memcmp.$ac_objext"   | \
8481 >  *" memcmp.$ac_objext"   | \
8482 >    "memcmp.$ac_objext "* | \
8483 >  *" memcmp.$ac_objext "* ) ;;
8484 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8485 > esac
8486 >
8487 >
8488 >
8489 > for ac_header in stdlib.h
8490 > do
8491 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8492 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8493 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8494 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8495 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8496 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8497 > fi
8498 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8499 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8500 > else
8501 >  # Is the header compilable?
8502 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8503 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8504 > cat >conftest.$ac_ext <<_ACEOF
8505 > /* confdefs.h.  */
8506 > _ACEOF
8507 > cat confdefs.h >>conftest.$ac_ext
8508 > cat >>conftest.$ac_ext <<_ACEOF
8509 > /* end confdefs.h.  */
8510 > $ac_includes_default
8511 > #include <$ac_header>
8512 > _ACEOF
8513 > rm -f conftest.$ac_objext
8514 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8515 >  (eval $ac_compile) 2>conftest.er1
8516 >  ac_status=$?
8517 >  grep -v '^ *+' conftest.er1 >conftest.err
8518 >  rm -f conftest.er1
8519 >  cat conftest.err >&5
8520 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8521 >  (exit $ac_status); } &&
8522 >         { ac_try='test -z "$ac_c_werror_flag"
8523 >                         || test ! -s conftest.err'
8524 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8525 >  (eval $ac_try) 2>&5
8526 >  ac_status=$?
8527 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8528 >  (exit $ac_status); }; } &&
8529 >         { ac_try='test -s conftest.$ac_objext'
8530 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8531 >  (eval $ac_try) 2>&5
8532 >  ac_status=$?
8533 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8534 >  (exit $ac_status); }; }; then
8535 >  ac_header_compiler=yes
8536 > else
8537 >  echo "$as_me: failed program was:" >&5
8538 > sed 's/^/| /' conftest.$ac_ext >&5
8539 >
8540 > ac_header_compiler=no
8541 > fi
8542 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8543 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8544 > echo "${ECHO_T}$ac_header_compiler" >&6
8545 >
8546 > # Is the header present?
8547 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8548 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8549 > cat >conftest.$ac_ext <<_ACEOF
8550 > /* confdefs.h.  */
8551 > _ACEOF
8552 > cat confdefs.h >>conftest.$ac_ext
8553 > cat >>conftest.$ac_ext <<_ACEOF
8554 > /* end confdefs.h.  */
8555 > #include <$ac_header>
8556 > _ACEOF
8557 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8558 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8559 >  ac_status=$?
8560 >  grep -v '^ *+' conftest.er1 >conftest.err
8561 >  rm -f conftest.er1
8562 >  cat conftest.err >&5
8563 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8564 >  (exit $ac_status); } >/dev/null; then
8565 >  if test -s conftest.err; then
8566 >    ac_cpp_err=$ac_c_preproc_warn_flag
8567 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8568 >  else
8569 >    ac_cpp_err=
8570 >  fi
8571 > else
8572 >  ac_cpp_err=yes
8573 > fi
8574 > if test -z "$ac_cpp_err"; then
8575 >  ac_header_preproc=yes
8576 > else
8577 >  echo "$as_me: failed program was:" >&5
8578 > sed 's/^/| /' conftest.$ac_ext >&5
8579 >
8580 >  ac_header_preproc=no
8581 > fi
8582 > rm -f conftest.err conftest.$ac_ext
8583 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8584 > echo "${ECHO_T}$ac_header_preproc" >&6
8585 >
8586 > # So?  What about this header?
8587 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8588 >  yes:no: )
8589 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8590 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8591 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8592 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8593 >    ac_header_preproc=yes
8594 >    ;;
8595 >  no:yes:* )
8596 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8597 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8598 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8599 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8600 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8601 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8602 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8603 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8604 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8605 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8606 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8607 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8608 >    (
8609 >      cat <<\_ASBOX
8610 > ## ------------------------------ ##
8611 > ## Report this to gezelter@nd.edu ##
8612 > ## ------------------------------ ##
8613 > _ASBOX
8614 >    ) |
8615 >      sed "s/^/$as_me: WARNING:     /" >&2
8616 >    ;;
8617 > esac
8618 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8619 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8620 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8621 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8622 > else
8623 >  eval "$as_ac_Header=\$ac_header_preproc"
8624 > fi
8625 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8626 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8627 >
8628 > fi
8629 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8630 >  cat >>confdefs.h <<_ACEOF
8631 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8632 > _ACEOF
8633 >
8634 > fi
8635 >
8636 > done
8637 >
8638 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8639 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8640 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8641 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8642 > else
8643 >  if test "$cross_compiling" = yes; then
8644 >  ac_cv_func_realloc_0_nonnull=no
8645 > else
8646 >  cat >conftest.$ac_ext <<_ACEOF
8647 > /* confdefs.h.  */
8648 > _ACEOF
8649 > cat confdefs.h >>conftest.$ac_ext
8650 > cat >>conftest.$ac_ext <<_ACEOF
8651 > /* end confdefs.h.  */
8652 > #if STDC_HEADERS || HAVE_STDLIB_H
8653 > # include <stdlib.h>
8654 > #else
8655 > char *realloc ();
8656 > #endif
8657 >
8658 > #ifdef FC_DUMMY_MAIN
8659 > #ifndef FC_DUMMY_MAIN_EQ_F77
8660 > #  ifdef __cplusplus
8661 >     extern "C"
8662 > #  endif
8663 >   int FC_DUMMY_MAIN() { return 1; }
8664 > #endif
8665 > #endif
8666 > int
8667 > main ()
8668 > {
8669 > exit (realloc (0, 0) ? 0 : 1);
8670 >  ;
8671 >  return 0;
8672 > }
8673 > _ACEOF
8674 > rm -f conftest$ac_exeext
8675 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8676 >  (eval $ac_link) 2>&5
8677 >  ac_status=$?
8678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8679 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8680 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8681 >  (eval $ac_try) 2>&5
8682 >  ac_status=$?
8683 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8684 >  (exit $ac_status); }; }; then
8685 >  ac_cv_func_realloc_0_nonnull=yes
8686 > else
8687 >  echo "$as_me: program exited with status $ac_status" >&5
8688 > echo "$as_me: failed program was:" >&5
8689 > sed 's/^/| /' conftest.$ac_ext >&5
8690 >
8691 > ( exit $ac_status )
8692 > ac_cv_func_realloc_0_nonnull=no
8693 > fi
8694 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8695 > fi
8696 > fi
8697 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8698 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8699 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8700 >
8701 > cat >>confdefs.h <<\_ACEOF
8702 > #define HAVE_REALLOC 1
8703 > _ACEOF
8704 >
8705 > else
8706 >  cat >>confdefs.h <<\_ACEOF
8707 > #define HAVE_REALLOC 0
8708 > _ACEOF
8709 >
8710 >   case $LIBOBJS in
8711 >    "realloc.$ac_objext"   | \
8712 >  *" realloc.$ac_objext"   | \
8713 >    "realloc.$ac_objext "* | \
8714 >  *" realloc.$ac_objext "* ) ;;
8715 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8716 > esac
8717 >
8718 >
8719 > cat >>confdefs.h <<\_ACEOF
8720 > #define realloc rpl_realloc
8721 > _ACEOF
8722 >
8723 > fi
8724 >
8725 >
8726 >
8727 >
8728 >
8729 > for ac_header in sys/select.h sys/socket.h
8730 > do
8731 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8732 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8733 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8734 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8735 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8736 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8737 > fi
8738 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8739 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8740 > else
8741 >  # Is the header compilable?
8742 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8743 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8744 > cat >conftest.$ac_ext <<_ACEOF
8745 > /* confdefs.h.  */
8746 > _ACEOF
8747 > cat confdefs.h >>conftest.$ac_ext
8748 > cat >>conftest.$ac_ext <<_ACEOF
8749 > /* end confdefs.h.  */
8750 > $ac_includes_default
8751 > #include <$ac_header>
8752 > _ACEOF
8753 > rm -f conftest.$ac_objext
8754 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8755 >  (eval $ac_compile) 2>conftest.er1
8756 >  ac_status=$?
8757 >  grep -v '^ *+' conftest.er1 >conftest.err
8758 >  rm -f conftest.er1
8759 >  cat conftest.err >&5
8760 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8761 >  (exit $ac_status); } &&
8762 >         { ac_try='test -z "$ac_c_werror_flag"
8763 >                         || test ! -s conftest.err'
8764 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8765 >  (eval $ac_try) 2>&5
8766 >  ac_status=$?
8767 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8768 >  (exit $ac_status); }; } &&
8769 >         { ac_try='test -s conftest.$ac_objext'
8770 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8771 >  (eval $ac_try) 2>&5
8772 >  ac_status=$?
8773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8774 >  (exit $ac_status); }; }; then
8775 >  ac_header_compiler=yes
8776 > else
8777 >  echo "$as_me: failed program was:" >&5
8778 > sed 's/^/| /' conftest.$ac_ext >&5
8779 >
8780 > ac_header_compiler=no
8781 > fi
8782 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8783 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8784 > echo "${ECHO_T}$ac_header_compiler" >&6
8785 >
8786 > # Is the header present?
8787 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8788 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8789 > cat >conftest.$ac_ext <<_ACEOF
8790 > /* confdefs.h.  */
8791 > _ACEOF
8792 > cat confdefs.h >>conftest.$ac_ext
8793 > cat >>conftest.$ac_ext <<_ACEOF
8794 > /* end confdefs.h.  */
8795 > #include <$ac_header>
8796 > _ACEOF
8797 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8798 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8799 >  ac_status=$?
8800 >  grep -v '^ *+' conftest.er1 >conftest.err
8801 >  rm -f conftest.er1
8802 >  cat conftest.err >&5
8803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8804 >  (exit $ac_status); } >/dev/null; then
8805 >  if test -s conftest.err; then
8806 >    ac_cpp_err=$ac_c_preproc_warn_flag
8807 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8808 >  else
8809 >    ac_cpp_err=
8810 >  fi
8811 > else
8812 >  ac_cpp_err=yes
8813 > fi
8814 > if test -z "$ac_cpp_err"; then
8815 >  ac_header_preproc=yes
8816 > else
8817 >  echo "$as_me: failed program was:" >&5
8818 > sed 's/^/| /' conftest.$ac_ext >&5
8819 >
8820 >  ac_header_preproc=no
8821 > fi
8822 > rm -f conftest.err conftest.$ac_ext
8823 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8824 > echo "${ECHO_T}$ac_header_preproc" >&6
8825 >
8826 > # So?  What about this header?
8827 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8828 >  yes:no: )
8829 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8830 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8831 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8832 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8833 >    ac_header_preproc=yes
8834 >    ;;
8835 >  no:yes:* )
8836 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8837 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8838 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8839 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8840 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8841 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8842 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8843 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8844 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8845 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8846 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8847 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8848 >    (
8849 >      cat <<\_ASBOX
8850 > ## ------------------------------ ##
8851 > ## Report this to gezelter@nd.edu ##
8852 > ## ------------------------------ ##
8853 > _ASBOX
8854 >    ) |
8855 >      sed "s/^/$as_me: WARNING:     /" >&2
8856 >    ;;
8857 > esac
8858 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8859 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8860 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8861 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8862 > else
8863 >  eval "$as_ac_Header=\$ac_header_preproc"
8864 > fi
8865 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8866 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8867 >
8868 > fi
8869 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8870 >  cat >>confdefs.h <<_ACEOF
8871 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8872 > _ACEOF
8873 >
8874 > fi
8875 >
8876 > done
8877 >
8878 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8879 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8880 > if test "${ac_cv_func_select_args+set}" = set; then
8881 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8882 > else
8883 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8884 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8885 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8886 >   cat >conftest.$ac_ext <<_ACEOF
8887 > /* confdefs.h.  */
8888 > _ACEOF
8889 > cat confdefs.h >>conftest.$ac_ext
8890 > cat >>conftest.$ac_ext <<_ACEOF
8891 > /* end confdefs.h.  */
8892 > $ac_includes_default
8893 > #if HAVE_SYS_SELECT_H
8894 > # include <sys/select.h>
8895 > #endif
8896 > #if HAVE_SYS_SOCKET_H
8897 > # include <sys/socket.h>
8898 > #endif
8899 >
8900 > #ifdef FC_DUMMY_MAIN
8901 > #ifndef FC_DUMMY_MAIN_EQ_F77
8902 > #  ifdef __cplusplus
8903 >     extern "C"
8904 > #  endif
8905 >   int FC_DUMMY_MAIN() { return 1; }
8906 > #endif
8907 > #endif
8908 > int
8909 > main ()
8910 > {
8911 > extern int select ($ac_arg1,
8912 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8913 >                                            $ac_arg5);
8914 >  ;
8915 >  return 0;
8916 > }
8917 > _ACEOF
8918 > rm -f conftest.$ac_objext
8919 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8920 >  (eval $ac_compile) 2>conftest.er1
8921 >  ac_status=$?
8922 >  grep -v '^ *+' conftest.er1 >conftest.err
8923 >  rm -f conftest.er1
8924 >  cat conftest.err >&5
8925 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8926 >  (exit $ac_status); } &&
8927 >         { ac_try='test -z "$ac_c_werror_flag"
8928 >                         || test ! -s conftest.err'
8929 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8930 >  (eval $ac_try) 2>&5
8931 >  ac_status=$?
8932 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8933 >  (exit $ac_status); }; } &&
8934 >         { ac_try='test -s conftest.$ac_objext'
8935 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8936 >  (eval $ac_try) 2>&5
8937 >  ac_status=$?
8938 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8939 >  (exit $ac_status); }; }; then
8940 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8941 > else
8942 >  echo "$as_me: failed program was:" >&5
8943 > sed 's/^/| /' conftest.$ac_ext >&5
8944 >
8945 > fi
8946 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8947 >  done
8948 > done
8949 > done
8950 > # Provide a safe default value.
8951 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8952 >
8953 > fi
8954 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8955 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8956 > ac_save_IFS=$IFS; IFS=','
8957 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8958 > IFS=$ac_save_IFS
8959 > shift
8960 >
8961 > cat >>confdefs.h <<_ACEOF
8962 > #define SELECT_TYPE_ARG1 $1
8963 > _ACEOF
8964 >
8965 >
8966 > cat >>confdefs.h <<_ACEOF
8967 > #define SELECT_TYPE_ARG234 ($2)
8968 > _ACEOF
8969 >
8970 >
8971 > cat >>confdefs.h <<_ACEOF
8972 > #define SELECT_TYPE_ARG5 ($3)
8973 > _ACEOF
8974 >
8975 > rm -f conftest*
8976 >
8977 >
8978 > for ac_func in strftime
8979 > do
8980 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8981 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8982 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8983 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8984 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8985 > else
8986 >  cat >conftest.$ac_ext <<_ACEOF
8987 > /* confdefs.h.  */
8988 > _ACEOF
8989 > cat confdefs.h >>conftest.$ac_ext
8990 > cat >>conftest.$ac_ext <<_ACEOF
8991 > /* end confdefs.h.  */
8992 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8993 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8994 > #define $ac_func innocuous_$ac_func
8995 >
8996 > /* System header to define __stub macros and hopefully few prototypes,
8997 >    which can conflict with char $ac_func (); below.
8998 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8999 >    <limits.h> exists even on freestanding compilers.  */
9000 >
9001 > #ifdef __STDC__
9002 > # include <limits.h>
9003 > #else
9004 > # include <assert.h>
9005 > #endif
9006 >
9007 > #undef $ac_func
9008 >
9009 > /* Override any gcc2 internal prototype to avoid an error.  */
9010 > #ifdef __cplusplus
9011 > extern "C"
9012 > {
9013 > #endif
9014 > /* We use char because int might match the return type of a gcc2
9015 >   builtin and then its argument prototype would still apply.  */
9016 > char $ac_func ();
9017 > /* The GNU C library defines this for functions which it implements
9018 >    to always fail with ENOSYS.  Some functions are actually named
9019 >    something starting with __ and the normal name is an alias.  */
9020 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9021 > choke me
9022 > #else
9023 > char (*f) () = $ac_func;
9024 > #endif
9025 > #ifdef __cplusplus
9026 > }
9027 > #endif
9028 >
9029 > #ifdef FC_DUMMY_MAIN
9030 > #ifndef FC_DUMMY_MAIN_EQ_F77
9031 > #  ifdef __cplusplus
9032 >     extern "C"
9033 > #  endif
9034 >   int FC_DUMMY_MAIN() { return 1; }
9035 > #endif
9036 > #endif
9037 > int
9038 > main ()
9039 > {
9040 > return f != $ac_func;
9041 >  ;
9042 >  return 0;
9043 > }
9044 > _ACEOF
9045 > rm -f conftest.$ac_objext conftest$ac_exeext
9046 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9047 >  (eval $ac_link) 2>conftest.er1
9048 >  ac_status=$?
9049 >  grep -v '^ *+' conftest.er1 >conftest.err
9050 >  rm -f conftest.er1
9051 >  cat conftest.err >&5
9052 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9053 >  (exit $ac_status); } &&
9054 >         { ac_try='test -z "$ac_c_werror_flag"
9055 >                         || test ! -s conftest.err'
9056 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9057 >  (eval $ac_try) 2>&5
9058 >  ac_status=$?
9059 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9060 >  (exit $ac_status); }; } &&
9061 >         { ac_try='test -s conftest$ac_exeext'
9062 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9063 >  (eval $ac_try) 2>&5
9064 >  ac_status=$?
9065 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9066 >  (exit $ac_status); }; }; then
9067 >  eval "$as_ac_var=yes"
9068 > else
9069 >  echo "$as_me: failed program was:" >&5
9070 > sed 's/^/| /' conftest.$ac_ext >&5
9071 >
9072 > eval "$as_ac_var=no"
9073 > fi
9074 > rm -f conftest.err conftest.$ac_objext \
9075 >      conftest$ac_exeext conftest.$ac_ext
9076 > fi
9077 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9078 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9079 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9080 >  cat >>confdefs.h <<_ACEOF
9081 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9082 > _ACEOF
9083 >
9084 > else
9085 >  # strftime is in -lintl on SCO UNIX.
9086 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9087 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9088 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9089 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9090 > else
9091 >  ac_check_lib_save_LIBS=$LIBS
9092 > LIBS="-lintl  $LIBS"
9093 > cat >conftest.$ac_ext <<_ACEOF
9094 > /* confdefs.h.  */
9095 > _ACEOF
9096 > cat confdefs.h >>conftest.$ac_ext
9097 > cat >>conftest.$ac_ext <<_ACEOF
9098 > /* end confdefs.h.  */
9099 >
9100 > /* Override any gcc2 internal prototype to avoid an error.  */
9101 > #ifdef __cplusplus
9102 > extern "C"
9103 > #endif
9104 > /* We use char because int might match the return type of a gcc2
9105 >   builtin and then its argument prototype would still apply.  */
9106 > char strftime ();
9107 > #ifdef FC_DUMMY_MAIN
9108 > #ifndef FC_DUMMY_MAIN_EQ_F77
9109 > #  ifdef __cplusplus
9110 >     extern "C"
9111 > #  endif
9112 >   int FC_DUMMY_MAIN() { return 1; }
9113 > #endif
9114 > #endif
9115 > int
9116 > main ()
9117 > {
9118 > strftime ();
9119 >  ;
9120 >  return 0;
9121 > }
9122 > _ACEOF
9123 > rm -f conftest.$ac_objext conftest$ac_exeext
9124 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9125 >  (eval $ac_link) 2>conftest.er1
9126 >  ac_status=$?
9127 >  grep -v '^ *+' conftest.er1 >conftest.err
9128 >  rm -f conftest.er1
9129 >  cat conftest.err >&5
9130 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9131 >  (exit $ac_status); } &&
9132 >         { ac_try='test -z "$ac_c_werror_flag"
9133 >                         || test ! -s conftest.err'
9134 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9135 >  (eval $ac_try) 2>&5
9136 >  ac_status=$?
9137 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9138 >  (exit $ac_status); }; } &&
9139 >         { ac_try='test -s conftest$ac_exeext'
9140 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9141 >  (eval $ac_try) 2>&5
9142 >  ac_status=$?
9143 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9144 >  (exit $ac_status); }; }; then
9145 >  ac_cv_lib_intl_strftime=yes
9146 > else
9147 >  echo "$as_me: failed program was:" >&5
9148 > sed 's/^/| /' conftest.$ac_ext >&5
9149 >
9150 > ac_cv_lib_intl_strftime=no
9151 > fi
9152 > rm -f conftest.err conftest.$ac_objext \
9153 >      conftest$ac_exeext conftest.$ac_ext
9154 > LIBS=$ac_check_lib_save_LIBS
9155 > fi
9156 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9157 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9158 > if test $ac_cv_lib_intl_strftime = yes; then
9159 >  cat >>confdefs.h <<\_ACEOF
9160 > #define HAVE_STRFTIME 1
9161 > _ACEOF
9162 >
9163 > LIBS="-lintl $LIBS"
9164 > fi
9165 >
9166 > fi
9167 > done
9168 >
9169 > echo "$as_me:$LINENO: checking for working strtod" >&5
9170 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9171 > if test "${ac_cv_func_strtod+set}" = set; then
9172 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9173 > else
9174 >  if test "$cross_compiling" = yes; then
9175 >  ac_cv_func_strtod=no
9176 > else
9177 >  cat >conftest.$ac_ext <<_ACEOF
9178 > /* confdefs.h.  */
9179 > _ACEOF
9180 > cat confdefs.h >>conftest.$ac_ext
9181 > cat >>conftest.$ac_ext <<_ACEOF
9182 > /* end confdefs.h.  */
9183 >
9184 > double strtod ();
9185 > int
9186 > main()
9187 > {
9188 >  {
9189 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9190 >    char *string = " +69";
9191 >    char *term;
9192 >    double value;
9193 >    value = strtod (string, &term);
9194 >    if (value != 69 || term != (string + 4))
9195 >      exit (1);
9196 >  }
9197 >
9198 >  {
9199 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9200 >       terminating character under some conditions.  */
9201 >    char *string = "NaN";
9202 >    char *term;
9203 >    strtod (string, &term);
9204 >    if (term != string && *(term - 1) == 0)
9205 >      exit (1);
9206 >  }
9207 >  exit (0);
9208 > }
9209 >
9210 > _ACEOF
9211 > rm -f conftest$ac_exeext
9212 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9213 >  (eval $ac_link) 2>&5
9214 >  ac_status=$?
9215 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9216 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9217 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9218 >  (eval $ac_try) 2>&5
9219 >  ac_status=$?
9220 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9221 >  (exit $ac_status); }; }; then
9222 >  ac_cv_func_strtod=yes
9223 > else
9224 >  echo "$as_me: program exited with status $ac_status" >&5
9225 > echo "$as_me: failed program was:" >&5
9226 > sed 's/^/| /' conftest.$ac_ext >&5
9227 >
9228 > ( exit $ac_status )
9229 > ac_cv_func_strtod=no
9230 > fi
9231 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9232 > fi
9233 > fi
9234 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9235 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9236 > if test $ac_cv_func_strtod = no; then
9237 >  case $LIBOBJS in
9238 >    "strtod.$ac_objext"   | \
9239 >  *" strtod.$ac_objext"   | \
9240 >    "strtod.$ac_objext "* | \
9241 >  *" strtod.$ac_objext "* ) ;;
9242 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9243 > esac
9244 >
9245 > echo "$as_me:$LINENO: checking for pow" >&5
9246 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9247 > if test "${ac_cv_func_pow+set}" = set; then
9248 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9249 > else
9250 >  cat >conftest.$ac_ext <<_ACEOF
9251 > /* confdefs.h.  */
9252 > _ACEOF
9253 > cat confdefs.h >>conftest.$ac_ext
9254 > cat >>conftest.$ac_ext <<_ACEOF
9255 > /* end confdefs.h.  */
9256 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9257 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9258 > #define pow innocuous_pow
9259 >
9260 > /* System header to define __stub macros and hopefully few prototypes,
9261 >    which can conflict with char pow (); below.
9262 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9263 >    <limits.h> exists even on freestanding compilers.  */
9264 >
9265 > #ifdef __STDC__
9266 > # include <limits.h>
9267 > #else
9268 > # include <assert.h>
9269 > #endif
9270 >
9271 > #undef pow
9272 >
9273 > /* Override any gcc2 internal prototype to avoid an error.  */
9274 > #ifdef __cplusplus
9275 > extern "C"
9276 > {
9277 > #endif
9278 > /* We use char because int might match the return type of a gcc2
9279 >   builtin and then its argument prototype would still apply.  */
9280 > char pow ();
9281 > /* The GNU C library defines this for functions which it implements
9282 >    to always fail with ENOSYS.  Some functions are actually named
9283 >    something starting with __ and the normal name is an alias.  */
9284 > #if defined (__stub_pow) || defined (__stub___pow)
9285 > choke me
9286 > #else
9287 > char (*f) () = pow;
9288 > #endif
9289 > #ifdef __cplusplus
9290 > }
9291 > #endif
9292 >
9293 > #ifdef FC_DUMMY_MAIN
9294 > #ifndef FC_DUMMY_MAIN_EQ_F77
9295 > #  ifdef __cplusplus
9296 >     extern "C"
9297 > #  endif
9298 >   int FC_DUMMY_MAIN() { return 1; }
9299 > #endif
9300 > #endif
9301 > int
9302 > main ()
9303 > {
9304 > return f != pow;
9305 >  ;
9306 >  return 0;
9307 > }
9308 > _ACEOF
9309 > rm -f conftest.$ac_objext conftest$ac_exeext
9310 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9311 >  (eval $ac_link) 2>conftest.er1
9312 >  ac_status=$?
9313 >  grep -v '^ *+' conftest.er1 >conftest.err
9314 >  rm -f conftest.er1
9315 >  cat conftest.err >&5
9316 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9317 >  (exit $ac_status); } &&
9318 >         { ac_try='test -z "$ac_c_werror_flag"
9319 >                         || test ! -s conftest.err'
9320 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9321 >  (eval $ac_try) 2>&5
9322 >  ac_status=$?
9323 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9324 >  (exit $ac_status); }; } &&
9325 >         { ac_try='test -s conftest$ac_exeext'
9326 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9327 >  (eval $ac_try) 2>&5
9328 >  ac_status=$?
9329 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9330 >  (exit $ac_status); }; }; then
9331 >  ac_cv_func_pow=yes
9332 > else
9333 >  echo "$as_me: failed program was:" >&5
9334 > sed 's/^/| /' conftest.$ac_ext >&5
9335 >
9336 > ac_cv_func_pow=no
9337 > fi
9338 > rm -f conftest.err conftest.$ac_objext \
9339 >      conftest$ac_exeext conftest.$ac_ext
9340 > fi
9341 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9342 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9343 >
9344 > if test $ac_cv_func_pow = no; then
9345 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9346 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9347 > if test "${ac_cv_lib_m_pow+set}" = set; then
9348 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9349 > else
9350 >  ac_check_lib_save_LIBS=$LIBS
9351 > LIBS="-lm  $LIBS"
9352 > cat >conftest.$ac_ext <<_ACEOF
9353 > /* confdefs.h.  */
9354 > _ACEOF
9355 > cat confdefs.h >>conftest.$ac_ext
9356 > cat >>conftest.$ac_ext <<_ACEOF
9357 > /* end confdefs.h.  */
9358 >
9359 > /* Override any gcc2 internal prototype to avoid an error.  */
9360 > #ifdef __cplusplus
9361 > extern "C"
9362 > #endif
9363 > /* We use char because int might match the return type of a gcc2
9364 >   builtin and then its argument prototype would still apply.  */
9365 > char pow ();
9366 > #ifdef FC_DUMMY_MAIN
9367 > #ifndef FC_DUMMY_MAIN_EQ_F77
9368 > #  ifdef __cplusplus
9369 >     extern "C"
9370 > #  endif
9371 >   int FC_DUMMY_MAIN() { return 1; }
9372 > #endif
9373 > #endif
9374 > int
9375 > main ()
9376 > {
9377 > pow ();
9378 >  ;
9379 >  return 0;
9380 > }
9381 > _ACEOF
9382 > rm -f conftest.$ac_objext conftest$ac_exeext
9383 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9384 >  (eval $ac_link) 2>conftest.er1
9385 >  ac_status=$?
9386 >  grep -v '^ *+' conftest.er1 >conftest.err
9387 >  rm -f conftest.er1
9388 >  cat conftest.err >&5
9389 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9390 >  (exit $ac_status); } &&
9391 >         { ac_try='test -z "$ac_c_werror_flag"
9392 >                         || test ! -s conftest.err'
9393 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9394 >  (eval $ac_try) 2>&5
9395 >  ac_status=$?
9396 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9397 >  (exit $ac_status); }; } &&
9398 >         { ac_try='test -s conftest$ac_exeext'
9399 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9400 >  (eval $ac_try) 2>&5
9401 >  ac_status=$?
9402 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9403 >  (exit $ac_status); }; }; then
9404 >  ac_cv_lib_m_pow=yes
9405 > else
9406 >  echo "$as_me: failed program was:" >&5
9407 > sed 's/^/| /' conftest.$ac_ext >&5
9408 >
9409 > ac_cv_lib_m_pow=no
9410 > fi
9411 > rm -f conftest.err conftest.$ac_objext \
9412 >      conftest$ac_exeext conftest.$ac_ext
9413 > LIBS=$ac_check_lib_save_LIBS
9414 > fi
9415 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9416 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9417 > if test $ac_cv_lib_m_pow = yes; then
9418 >  POW_LIB=-lm
9419 > else
9420 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9421 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9422 > fi
9423 >
9424 > fi
9425 >
9426 > fi
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 >
9453 >
9454 >
9455 > 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
9456 > do
9457 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9458 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9459 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9460 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9461 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9462 > else
9463 >  cat >conftest.$ac_ext <<_ACEOF
9464 > /* confdefs.h.  */
9465 > _ACEOF
9466 > cat confdefs.h >>conftest.$ac_ext
9467 > cat >>conftest.$ac_ext <<_ACEOF
9468 > /* end confdefs.h.  */
9469 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9470 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9471 > #define $ac_func innocuous_$ac_func
9472 >
9473 > /* System header to define __stub macros and hopefully few prototypes,
9474 >    which can conflict with char $ac_func (); below.
9475 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9476 >    <limits.h> exists even on freestanding compilers.  */
9477 >
9478 > #ifdef __STDC__
9479 > # include <limits.h>
9480 > #else
9481 > # include <assert.h>
9482 > #endif
9483 >
9484 > #undef $ac_func
9485 >
9486 > /* Override any gcc2 internal prototype to avoid an error.  */
9487 > #ifdef __cplusplus
9488 > extern "C"
9489 > {
9490 > #endif
9491 > /* We use char because int might match the return type of a gcc2
9492 >   builtin and then its argument prototype would still apply.  */
9493 > char $ac_func ();
9494 > /* The GNU C library defines this for functions which it implements
9495 >    to always fail with ENOSYS.  Some functions are actually named
9496 >    something starting with __ and the normal name is an alias.  */
9497 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9498 > choke me
9499 > #else
9500 > char (*f) () = $ac_func;
9501 > #endif
9502 > #ifdef __cplusplus
9503 > }
9504 > #endif
9505 >
9506 > #ifdef FC_DUMMY_MAIN
9507 > #ifndef FC_DUMMY_MAIN_EQ_F77
9508 > #  ifdef __cplusplus
9509 >     extern "C"
9510 > #  endif
9511 >   int FC_DUMMY_MAIN() { return 1; }
9512 > #endif
9513 > #endif
9514 > int
9515 > main ()
9516 > {
9517 > return f != $ac_func;
9518 >  ;
9519 >  return 0;
9520 > }
9521 > _ACEOF
9522 > rm -f conftest.$ac_objext conftest$ac_exeext
9523 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9524 >  (eval $ac_link) 2>conftest.er1
9525 >  ac_status=$?
9526 >  grep -v '^ *+' conftest.er1 >conftest.err
9527 >  rm -f conftest.er1
9528 >  cat conftest.err >&5
9529 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9530 >  (exit $ac_status); } &&
9531 >         { ac_try='test -z "$ac_c_werror_flag"
9532 >                         || test ! -s conftest.err'
9533 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9534 >  (eval $ac_try) 2>&5
9535 >  ac_status=$?
9536 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9537 >  (exit $ac_status); }; } &&
9538 >         { ac_try='test -s conftest$ac_exeext'
9539 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9540 >  (eval $ac_try) 2>&5
9541 >  ac_status=$?
9542 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9543 >  (exit $ac_status); }; }; then
9544 >  eval "$as_ac_var=yes"
9545 > else
9546 >  echo "$as_me: failed program was:" >&5
9547 > sed 's/^/| /' conftest.$ac_ext >&5
9548 >
9549 > eval "$as_ac_var=no"
9550 > fi
9551 > rm -f conftest.err conftest.$ac_objext \
9552 >      conftest$ac_exeext conftest.$ac_ext
9553 > fi
9554 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9555 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9556 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9557 >  cat >>confdefs.h <<_ACEOF
9558 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9559 > _ACEOF
9560 >
9561 > fi
9562 > done
9563 >
9564 >
9565 > # special check for _system_configuration because AIX <4.3.2 do not
9566 > # contain the `physmem' member.
9567 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9568 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9569 > cat >conftest.$ac_ext <<_ACEOF
9570 > /* confdefs.h.  */
9571 > _ACEOF
9572 > cat confdefs.h >>conftest.$ac_ext
9573 > cat >>conftest.$ac_ext <<_ACEOF
9574 > /* end confdefs.h.  */
9575 > #include <sys/systemcfg.h>
9576 > #ifdef FC_DUMMY_MAIN
9577 > #ifndef FC_DUMMY_MAIN_EQ_F77
9578 > #  ifdef __cplusplus
9579 >     extern "C"
9580 > #  endif
9581 >   int FC_DUMMY_MAIN() { return 1; }
9582 > #endif
9583 > #endif
9584 > int
9585 > main ()
9586 > {
9587 > double x = _system_configuration.physmem;
9588 >  ;
9589 >  return 0;
9590 > }
9591 > _ACEOF
9592 > rm -f conftest.$ac_objext
9593 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9594 >  (eval $ac_compile) 2>conftest.er1
9595 >  ac_status=$?
9596 >  grep -v '^ *+' conftest.er1 >conftest.err
9597 >  rm -f conftest.er1
9598 >  cat conftest.err >&5
9599 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9600 >  (exit $ac_status); } &&
9601 >         { ac_try='test -z "$ac_c_werror_flag"
9602 >                         || test ! -s conftest.err'
9603 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9604 >  (eval $ac_try) 2>&5
9605 >  ac_status=$?
9606 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9607 >  (exit $ac_status); }; } &&
9608 >         { ac_try='test -s conftest.$ac_objext'
9609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9610 >  (eval $ac_try) 2>&5
9611 >  ac_status=$?
9612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9613 >  (exit $ac_status); }; }; then
9614 >  echo "$as_me:$LINENO: result: yes" >&5
9615 > echo "${ECHO_T}yes" >&6
9616 >
9617 > cat >>confdefs.h <<\_ACEOF
9618 > #define HAVE__SYSTEM_CONFIGURATION 1
9619 > _ACEOF
9620 >
9621 > else
9622 >  echo "$as_me: failed program was:" >&5
9623 > sed 's/^/| /' conftest.$ac_ext >&5
9624 >
9625 > echo "$as_me:$LINENO: result: no" >&5
9626 > echo "${ECHO_T}no" >&6
9627 > fi
9628 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9629 >
9630 >  # clean out junk possibly left behind by a previous configuration
9631 >  rm -f src/getopt.h
9632 >  # Check for getopt_long support
9633 >
9634 > for ac_header in getopt.h
9635 > do
9636 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9637 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9638 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9639 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9640 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9641 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9642 > fi
9643 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9644 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9645 > else
9646 >  # Is the header compilable?
9647 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9648 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9649 > cat >conftest.$ac_ext <<_ACEOF
9650 > /* confdefs.h.  */
9651 > _ACEOF
9652 > cat confdefs.h >>conftest.$ac_ext
9653 > cat >>conftest.$ac_ext <<_ACEOF
9654 > /* end confdefs.h.  */
9655 > $ac_includes_default
9656 > #include <$ac_header>
9657 > _ACEOF
9658 > rm -f conftest.$ac_objext
9659 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9660 >  (eval $ac_compile) 2>conftest.er1
9661 >  ac_status=$?
9662 >  grep -v '^ *+' conftest.er1 >conftest.err
9663 >  rm -f conftest.er1
9664 >  cat conftest.err >&5
9665 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9666 >  (exit $ac_status); } &&
9667 >         { ac_try='test -z "$ac_c_werror_flag"
9668 >                         || test ! -s conftest.err'
9669 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9670 >  (eval $ac_try) 2>&5
9671 >  ac_status=$?
9672 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9673 >  (exit $ac_status); }; } &&
9674 >         { ac_try='test -s conftest.$ac_objext'
9675 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9676 >  (eval $ac_try) 2>&5
9677 >  ac_status=$?
9678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9679 >  (exit $ac_status); }; }; then
9680 >  ac_header_compiler=yes
9681 > else
9682 >  echo "$as_me: failed program was:" >&5
9683 > sed 's/^/| /' conftest.$ac_ext >&5
9684 >
9685 > ac_header_compiler=no
9686 > fi
9687 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9688 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9689 > echo "${ECHO_T}$ac_header_compiler" >&6
9690 >
9691 > # Is the header present?
9692 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9693 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9694 > cat >conftest.$ac_ext <<_ACEOF
9695 > /* confdefs.h.  */
9696 > _ACEOF
9697 > cat confdefs.h >>conftest.$ac_ext
9698 > cat >>conftest.$ac_ext <<_ACEOF
9699 > /* end confdefs.h.  */
9700 > #include <$ac_header>
9701 > _ACEOF
9702 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9703 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9704 >  ac_status=$?
9705 >  grep -v '^ *+' conftest.er1 >conftest.err
9706 >  rm -f conftest.er1
9707 >  cat conftest.err >&5
9708 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9709 >  (exit $ac_status); } >/dev/null; then
9710 >  if test -s conftest.err; then
9711 >    ac_cpp_err=$ac_c_preproc_warn_flag
9712 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9713 >  else
9714 >    ac_cpp_err=
9715 >  fi
9716 > else
9717 >  ac_cpp_err=yes
9718 > fi
9719 > if test -z "$ac_cpp_err"; then
9720 >  ac_header_preproc=yes
9721 > else
9722 >  echo "$as_me: failed program was:" >&5
9723 > sed 's/^/| /' conftest.$ac_ext >&5
9724 >
9725 >  ac_header_preproc=no
9726 > fi
9727 > rm -f conftest.err conftest.$ac_ext
9728 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9729 > echo "${ECHO_T}$ac_header_preproc" >&6
9730 >
9731 > # So?  What about this header?
9732 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9733 >  yes:no: )
9734 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9735 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9736 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9737 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9738 >    ac_header_preproc=yes
9739 >    ;;
9740 >  no:yes:* )
9741 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9742 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9743 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9744 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9745 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9746 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9747 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9748 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9749 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9750 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9751 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9752 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9753 >    (
9754 >      cat <<\_ASBOX
9755 > ## ------------------------------ ##
9756 > ## Report this to gezelter@nd.edu ##
9757 > ## ------------------------------ ##
9758 > _ASBOX
9759 >    ) |
9760 >      sed "s/^/$as_me: WARNING:     /" >&2
9761 >    ;;
9762 > esac
9763 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9764 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9765 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9766 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9767 > else
9768 >  eval "$as_ac_Header=\$ac_header_preproc"
9769 > fi
9770 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9771 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9772 >
9773 > fi
9774 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9775 >  cat >>confdefs.h <<_ACEOF
9776 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9777 > _ACEOF
9778 >
9779 > fi
9780 >
9781 > done
9782 >
9783 >
9784 > for ac_func in getopt_long
9785 > do
9786 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9787 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9788 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9789 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9790 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9791 > else
9792 >  cat >conftest.$ac_ext <<_ACEOF
9793 > /* confdefs.h.  */
9794 > _ACEOF
9795 > cat confdefs.h >>conftest.$ac_ext
9796 > cat >>conftest.$ac_ext <<_ACEOF
9797 > /* end confdefs.h.  */
9798 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9799 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9800 > #define $ac_func innocuous_$ac_func
9801 >
9802 > /* System header to define __stub macros and hopefully few prototypes,
9803 >    which can conflict with char $ac_func (); below.
9804 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9805 >    <limits.h> exists even on freestanding compilers.  */
9806 >
9807 > #ifdef __STDC__
9808 > # include <limits.h>
9809 > #else
9810 > # include <assert.h>
9811 > #endif
9812 >
9813 > #undef $ac_func
9814 >
9815 > /* Override any gcc2 internal prototype to avoid an error.  */
9816 > #ifdef __cplusplus
9817 > extern "C"
9818 > {
9819 > #endif
9820 > /* We use char because int might match the return type of a gcc2
9821 >   builtin and then its argument prototype would still apply.  */
9822 > char $ac_func ();
9823 > /* The GNU C library defines this for functions which it implements
9824 >    to always fail with ENOSYS.  Some functions are actually named
9825 >    something starting with __ and the normal name is an alias.  */
9826 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9827 > choke me
9828 > #else
9829 > char (*f) () = $ac_func;
9830 > #endif
9831 > #ifdef __cplusplus
9832 > }
9833 > #endif
9834 >
9835 > #ifdef FC_DUMMY_MAIN
9836 > #ifndef FC_DUMMY_MAIN_EQ_F77
9837 > #  ifdef __cplusplus
9838 >     extern "C"
9839 > #  endif
9840 >   int FC_DUMMY_MAIN() { return 1; }
9841 > #endif
9842 > #endif
9843 > int
9844 > main ()
9845 > {
9846 > return f != $ac_func;
9847 >  ;
9848 >  return 0;
9849 > }
9850 > _ACEOF
9851 > rm -f conftest.$ac_objext conftest$ac_exeext
9852 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9853 >  (eval $ac_link) 2>conftest.er1
9854 >  ac_status=$?
9855 >  grep -v '^ *+' conftest.er1 >conftest.err
9856 >  rm -f conftest.er1
9857 >  cat conftest.err >&5
9858 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9859 >  (exit $ac_status); } &&
9860 >         { ac_try='test -z "$ac_c_werror_flag"
9861 >                         || test ! -s conftest.err'
9862 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9863 >  (eval $ac_try) 2>&5
9864 >  ac_status=$?
9865 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866 >  (exit $ac_status); }; } &&
9867 >         { ac_try='test -s conftest$ac_exeext'
9868 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9869 >  (eval $ac_try) 2>&5
9870 >  ac_status=$?
9871 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9872 >  (exit $ac_status); }; }; then
9873 >  eval "$as_ac_var=yes"
9874 > else
9875 >  echo "$as_me: failed program was:" >&5
9876 > sed 's/^/| /' conftest.$ac_ext >&5
9877 >
9878 > eval "$as_ac_var=no"
9879 > fi
9880 > rm -f conftest.err conftest.$ac_objext \
9881 >      conftest$ac_exeext conftest.$ac_ext
9882 > fi
9883 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9884 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9885 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9886 >  cat >>confdefs.h <<_ACEOF
9887 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9888 > _ACEOF
9889 >
9890 > else
9891 >  # FreeBSD has a gnugetopt library for this
9892 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9893 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9894 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9895 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9896 > else
9897 >  ac_check_lib_save_LIBS=$LIBS
9898 > LIBS="-lgnugetopt  $LIBS"
9899 > cat >conftest.$ac_ext <<_ACEOF
9900 > /* confdefs.h.  */
9901 > _ACEOF
9902 > cat confdefs.h >>conftest.$ac_ext
9903 > cat >>conftest.$ac_ext <<_ACEOF
9904 > /* end confdefs.h.  */
9905 >
9906 > /* Override any gcc2 internal prototype to avoid an error.  */
9907 > #ifdef __cplusplus
9908 > extern "C"
9909 > #endif
9910 > /* We use char because int might match the return type of a gcc2
9911 >   builtin and then its argument prototype would still apply.  */
9912 > char getopt_long ();
9913 > #ifdef FC_DUMMY_MAIN
9914 > #ifndef FC_DUMMY_MAIN_EQ_F77
9915 > #  ifdef __cplusplus
9916 >     extern "C"
9917 > #  endif
9918 >   int FC_DUMMY_MAIN() { return 1; }
9919 > #endif
9920 > #endif
9921 > int
9922 > main ()
9923 > {
9924 > getopt_long ();
9925 >  ;
9926 >  return 0;
9927 > }
9928 > _ACEOF
9929 > rm -f conftest.$ac_objext conftest$ac_exeext
9930 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9931 >  (eval $ac_link) 2>conftest.er1
9932 >  ac_status=$?
9933 >  grep -v '^ *+' conftest.er1 >conftest.err
9934 >  rm -f conftest.er1
9935 >  cat conftest.err >&5
9936 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9937 >  (exit $ac_status); } &&
9938 >         { ac_try='test -z "$ac_c_werror_flag"
9939 >                         || test ! -s conftest.err'
9940 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9941 >  (eval $ac_try) 2>&5
9942 >  ac_status=$?
9943 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9944 >  (exit $ac_status); }; } &&
9945 >         { ac_try='test -s conftest$ac_exeext'
9946 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9947 >  (eval $ac_try) 2>&5
9948 >  ac_status=$?
9949 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9950 >  (exit $ac_status); }; }; then
9951 >  ac_cv_lib_gnugetopt_getopt_long=yes
9952 > else
9953 >  echo "$as_me: failed program was:" >&5
9954 > sed 's/^/| /' conftest.$ac_ext >&5
9955 >
9956 > ac_cv_lib_gnugetopt_getopt_long=no
9957 > fi
9958 > rm -f conftest.err conftest.$ac_objext \
9959 >      conftest$ac_exeext conftest.$ac_ext
9960 > LIBS=$ac_check_lib_save_LIBS
9961 > fi
9962 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9963 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9964 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9965 >  cat >>confdefs.h <<\_ACEOF
9966 > #define HAVE_GETOPT_LONG 1
9967 > _ACEOF
9968 >
9969 > else
9970 >  # use the GNU replacement
9971 >      case $LIBOBJS in
9972 >    "getopt.$ac_objext"   | \
9973 >  *" getopt.$ac_objext"   | \
9974 >    "getopt.$ac_objext "* | \
9975 >  *" getopt.$ac_objext "* ) ;;
9976 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9977 > esac
9978 >
9979 >      case $LIBOBJS in
9980 >    "getopt1.$ac_objext"   | \
9981 >  *" getopt1.$ac_objext"   | \
9982 >    "getopt1.$ac_objext "* | \
9983 >  *" getopt1.$ac_objext "* ) ;;
9984 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9985 > esac
9986 >
9987 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9988 >
9989 > fi
9990 >
9991 > fi
9992 > done
9993 >
9994 >
9995 > ac_ext=cc
9996 > ac_cpp='$CXXCPP $CPPFLAGS'
9997 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9998 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9999 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10000 >
10001 >
10002 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10003 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10004 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10005 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10006 > else
10007 >
10008 >
10009 > ac_ext=cc
10010 > ac_cpp='$CXXCPP $CPPFLAGS'
10011 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10012 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10013 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10014 >
10015 > cat >conftest.$ac_ext <<_ACEOF
10016 > /* confdefs.h.  */
10017 > _ACEOF
10018 > cat confdefs.h >>conftest.$ac_ext
10019 > cat >>conftest.$ac_ext <<_ACEOF
10020 > /* end confdefs.h.  */
10021 > namespace Outer { namespace Inner { int i = 0; }}
10022 > #ifdef FC_DUMMY_MAIN
10023 > #ifndef FC_DUMMY_MAIN_EQ_F77
10024 > #  ifdef __cplusplus
10025 >     extern "C"
10026 > #  endif
10027 >   int FC_DUMMY_MAIN() { return 1; }
10028 > #endif
10029 > #endif
10030 > int
10031 > main ()
10032 > {
10033 > using namespace Outer::Inner; return i;
10034 >  ;
10035 >  return 0;
10036 > }
10037 > _ACEOF
10038 > rm -f conftest.$ac_objext
10039 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10040 >  (eval $ac_compile) 2>conftest.er1
10041 >  ac_status=$?
10042 >  grep -v '^ *+' conftest.er1 >conftest.err
10043 >  rm -f conftest.er1
10044 >  cat conftest.err >&5
10045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10046 >  (exit $ac_status); } &&
10047 >         { ac_try='test -z "$ac_cxx_werror_flag"
10048 >                         || test ! -s conftest.err'
10049 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10050 >  (eval $ac_try) 2>&5
10051 >  ac_status=$?
10052 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10053 >  (exit $ac_status); }; } &&
10054 >         { ac_try='test -s conftest.$ac_objext'
10055 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10056 >  (eval $ac_try) 2>&5
10057 >  ac_status=$?
10058 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10059 >  (exit $ac_status); }; }; then
10060 >  ac_cv_cxx_namespaces=yes
10061 > else
10062 >  echo "$as_me: failed program was:" >&5
10063 > sed 's/^/| /' conftest.$ac_ext >&5
10064 >
10065 > ac_cv_cxx_namespaces=no
10066 > fi
10067 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10068 > ac_ext=cc
10069 > ac_cpp='$CXXCPP $CPPFLAGS'
10070 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10071 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10072 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10073 >
10074 >
10075 > fi
10076 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10077 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10078 > if test "$ac_cv_cxx_namespaces" = yes; then
10079 >
10080 > cat >>confdefs.h <<\_ACEOF
10081 > #define HAVE_NAMESPACES
10082 > _ACEOF
10083 >
10084 > fi
10085 >
10086 > ac_ext=cc
10087 > ac_cpp='$CXXCPP $CPPFLAGS'
10088 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10089 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10090 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10091 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10092 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10093 > if test -z "$CXXCPP"; then
10094 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10095 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10096 > else
10097 >      # Double quotes because CXXCPP needs to be expanded
10098 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10099 >    do
10100 >      ac_preproc_ok=false
10101 > for ac_cxx_preproc_warn_flag in '' yes
10102 > do
10103 >  # Use a header file that comes with gcc, so configuring glibc
10104 >  # with a fresh cross-compiler works.
10105 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10106 >  # <limits.h> exists even on freestanding compilers.
10107 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10108 >  # not just through cpp. "Syntax error" is here to catch this case.
10109 >  cat >conftest.$ac_ext <<_ACEOF
10110 > /* confdefs.h.  */
10111 > _ACEOF
10112 > cat confdefs.h >>conftest.$ac_ext
10113 > cat >>conftest.$ac_ext <<_ACEOF
10114 > /* end confdefs.h.  */
10115 > #ifdef __STDC__
10116 > # include <limits.h>
10117 > #else
10118 > # include <assert.h>
10119 > #endif
10120 >                     Syntax error
10121 > _ACEOF
10122 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10123 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10124 >  ac_status=$?
10125 >  grep -v '^ *+' conftest.er1 >conftest.err
10126 >  rm -f conftest.er1
10127 >  cat conftest.err >&5
10128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10129 >  (exit $ac_status); } >/dev/null; then
10130 >  if test -s conftest.err; then
10131 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10132 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10133 >  else
10134 >    ac_cpp_err=
10135 >  fi
10136 > else
10137 >  ac_cpp_err=yes
10138 > fi
10139 > if test -z "$ac_cpp_err"; then
10140 >  :
10141 > else
10142 >  echo "$as_me: failed program was:" >&5
10143 > sed 's/^/| /' conftest.$ac_ext >&5
10144 >
10145 >  # Broken: fails on valid input.
10146 > continue
10147 > fi
10148 > rm -f conftest.err conftest.$ac_ext
10149 >
10150 >  # OK, works on sane cases.  Now check whether non-existent headers
10151 >  # can be detected and how.
10152 >  cat >conftest.$ac_ext <<_ACEOF
10153 > /* confdefs.h.  */
10154 > _ACEOF
10155 > cat confdefs.h >>conftest.$ac_ext
10156 > cat >>conftest.$ac_ext <<_ACEOF
10157 > /* end confdefs.h.  */
10158 > #include <ac_nonexistent.h>
10159 > _ACEOF
10160 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10161 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10162 >  ac_status=$?
10163 >  grep -v '^ *+' conftest.er1 >conftest.err
10164 >  rm -f conftest.er1
10165 >  cat conftest.err >&5
10166 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10167 >  (exit $ac_status); } >/dev/null; then
10168 >  if test -s conftest.err; then
10169 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10170 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10171 >  else
10172 >    ac_cpp_err=
10173 >  fi
10174 > else
10175 >  ac_cpp_err=yes
10176 > fi
10177 > if test -z "$ac_cpp_err"; then
10178 >  # Broken: success on invalid input.
10179 > continue
10180 > else
10181 >  echo "$as_me: failed program was:" >&5
10182 > sed 's/^/| /' conftest.$ac_ext >&5
10183 >
10184 >  # Passes both tests.
10185 > ac_preproc_ok=:
10186 > break
10187 > fi
10188 > rm -f conftest.err conftest.$ac_ext
10189 >
10190 > done
10191 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10192 > rm -f conftest.err conftest.$ac_ext
10193 > if $ac_preproc_ok; then
10194 >  break
10195 > fi
10196 >
10197 >    done
10198 >    ac_cv_prog_CXXCPP=$CXXCPP
10199 >
10200 > fi
10201 >  CXXCPP=$ac_cv_prog_CXXCPP
10202 > else
10203 >  ac_cv_prog_CXXCPP=$CXXCPP
10204 > fi
10205 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10206 > echo "${ECHO_T}$CXXCPP" >&6
10207 > ac_preproc_ok=false
10208 > for ac_cxx_preproc_warn_flag in '' yes
10209 > do
10210 >  # Use a header file that comes with gcc, so configuring glibc
10211 >  # with a fresh cross-compiler works.
10212 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10213 >  # <limits.h> exists even on freestanding compilers.
10214 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10215 >  # not just through cpp. "Syntax error" is here to catch this case.
10216 >  cat >conftest.$ac_ext <<_ACEOF
10217 > /* confdefs.h.  */
10218 > _ACEOF
10219 > cat confdefs.h >>conftest.$ac_ext
10220 > cat >>conftest.$ac_ext <<_ACEOF
10221 > /* end confdefs.h.  */
10222 > #ifdef __STDC__
10223 > # include <limits.h>
10224 > #else
10225 > # include <assert.h>
10226 > #endif
10227 >                     Syntax error
10228 > _ACEOF
10229 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10230 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10231 >  ac_status=$?
10232 >  grep -v '^ *+' conftest.er1 >conftest.err
10233 >  rm -f conftest.er1
10234 >  cat conftest.err >&5
10235 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10236 >  (exit $ac_status); } >/dev/null; then
10237 >  if test -s conftest.err; then
10238 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10239 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10240 >  else
10241 >    ac_cpp_err=
10242 >  fi
10243 > else
10244 >  ac_cpp_err=yes
10245 > fi
10246 > if test -z "$ac_cpp_err"; then
10247 >  :
10248 > else
10249 >  echo "$as_me: failed program was:" >&5
10250 > sed 's/^/| /' conftest.$ac_ext >&5
10251 >
10252 >  # Broken: fails on valid input.
10253 > continue
10254 > fi
10255 > rm -f conftest.err conftest.$ac_ext
10256 >
10257 >  # OK, works on sane cases.  Now check whether non-existent headers
10258 >  # can be detected and how.
10259 >  cat >conftest.$ac_ext <<_ACEOF
10260 > /* confdefs.h.  */
10261 > _ACEOF
10262 > cat confdefs.h >>conftest.$ac_ext
10263 > cat >>conftest.$ac_ext <<_ACEOF
10264 > /* end confdefs.h.  */
10265 > #include <ac_nonexistent.h>
10266 > _ACEOF
10267 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10268 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10269 >  ac_status=$?
10270 >  grep -v '^ *+' conftest.er1 >conftest.err
10271 >  rm -f conftest.er1
10272 >  cat conftest.err >&5
10273 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10274 >  (exit $ac_status); } >/dev/null; then
10275 >  if test -s conftest.err; then
10276 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10277 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10278 >  else
10279 >    ac_cpp_err=
10280 >  fi
10281 > else
10282 >  ac_cpp_err=yes
10283 > fi
10284 > if test -z "$ac_cpp_err"; then
10285 >  # Broken: success on invalid input.
10286 > continue
10287 > else
10288 >  echo "$as_me: failed program was:" >&5
10289 > sed 's/^/| /' conftest.$ac_ext >&5
10290 >
10291 >  # Passes both tests.
10292 > ac_preproc_ok=:
10293 > break
10294 > fi
10295 > rm -f conftest.err conftest.$ac_ext
10296 >
10297 > done
10298 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10299 > rm -f conftest.err conftest.$ac_ext
10300 > if $ac_preproc_ok; then
10301 >  :
10302 > else
10303 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10304 > See \`config.log' for more details." >&5
10305 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10306 > See \`config.log' for more details." >&2;}
10307 >   { (exit 1); exit 1; }; }
10308 > fi
10309 >
10310 > ac_ext=cc
10311 > ac_cpp='$CXXCPP $CPPFLAGS'
10312 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10313 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10314 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10315 >
10316 >
10317 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10318 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10319 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10320 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10321 > else
10322 >
10323 >
10324 >
10325 > ac_ext=cc
10326 > ac_cpp='$CXXCPP $CPPFLAGS'
10327 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10328 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10329 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10330 >
10331 > cat >conftest.$ac_ext <<_ACEOF
10332 > /* confdefs.h.  */
10333 > _ACEOF
10334 > cat confdefs.h >>conftest.$ac_ext
10335 > cat >>conftest.$ac_ext <<_ACEOF
10336 > /* end confdefs.h.  */
10337 > #include <list>
10338 > #include <deque>
10339 > #ifdef HAVE_NAMESPACES
10340 > using namespace std;
10341 > #endif
10342 > #ifdef FC_DUMMY_MAIN
10343 > #ifndef FC_DUMMY_MAIN_EQ_F77
10344 > #  ifdef __cplusplus
10345 >     extern "C"
10346 > #  endif
10347 >   int FC_DUMMY_MAIN() { return 1; }
10348 > #endif
10349 > #endif
10350 > int
10351 > main ()
10352 > {
10353 > list<int> x; x.push_back(5);
10354 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10355 >  ;
10356 >  return 0;
10357 > }
10358 > _ACEOF
10359 > rm -f conftest.$ac_objext
10360 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10361 >  (eval $ac_compile) 2>conftest.er1
10362 >  ac_status=$?
10363 >  grep -v '^ *+' conftest.er1 >conftest.err
10364 >  rm -f conftest.er1
10365 >  cat conftest.err >&5
10366 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10367 >  (exit $ac_status); } &&
10368 >         { ac_try='test -z "$ac_cxx_werror_flag"
10369 >                         || test ! -s conftest.err'
10370 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10371 >  (eval $ac_try) 2>&5
10372 >  ac_status=$?
10373 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10374 >  (exit $ac_status); }; } &&
10375 >         { ac_try='test -s conftest.$ac_objext'
10376 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10377 >  (eval $ac_try) 2>&5
10378 >  ac_status=$?
10379 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380 >  (exit $ac_status); }; }; then
10381 >  ac_cv_cxx_have_stl=yes
10382 > else
10383 >  echo "$as_me: failed program was:" >&5
10384 > sed 's/^/| /' conftest.$ac_ext >&5
10385 >
10386 > ac_cv_cxx_have_stl=no
10387 > fi
10388 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10389 > ac_ext=cc
10390 > ac_cpp='$CXXCPP $CPPFLAGS'
10391 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10392 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10393 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10394 >
10395 >
10396 > fi
10397 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10398 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10399 > if test "$ac_cv_cxx_have_stl" = yes; then
10400 >
10401 > cat >>confdefs.h <<\_ACEOF
10402 > #define HAVE_STL
10403 > _ACEOF
10404 >
10405 > fi
10406 >
10407 >
10408 >
10409 >  if test "${ac_cv_header_iostream+set}" = set; then
10410 >  echo "$as_me:$LINENO: checking for iostream" >&5
10411 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10412 > if test "${ac_cv_header_iostream+set}" = set; then
10413 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10414 > fi
10415 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10416 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10417 > else
10418 >  # Is the header compilable?
10419 > echo "$as_me:$LINENO: checking iostream usability" >&5
10420 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10421 > cat >conftest.$ac_ext <<_ACEOF
10422 > /* confdefs.h.  */
10423 > _ACEOF
10424 > cat confdefs.h >>conftest.$ac_ext
10425 > cat >>conftest.$ac_ext <<_ACEOF
10426 > /* end confdefs.h.  */
10427 > $ac_includes_default
10428 > #include <iostream>
10429 > _ACEOF
10430 > rm -f conftest.$ac_objext
10431 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10432 >  (eval $ac_compile) 2>conftest.er1
10433 >  ac_status=$?
10434 >  grep -v '^ *+' conftest.er1 >conftest.err
10435 >  rm -f conftest.er1
10436 >  cat conftest.err >&5
10437 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10438 >  (exit $ac_status); } &&
10439 >         { ac_try='test -z "$ac_cxx_werror_flag"
10440 >                         || test ! -s conftest.err'
10441 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10442 >  (eval $ac_try) 2>&5
10443 >  ac_status=$?
10444 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10445 >  (exit $ac_status); }; } &&
10446 >         { ac_try='test -s conftest.$ac_objext'
10447 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10448 >  (eval $ac_try) 2>&5
10449 >  ac_status=$?
10450 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10451 >  (exit $ac_status); }; }; then
10452 >  ac_header_compiler=yes
10453 > else
10454 >  echo "$as_me: failed program was:" >&5
10455 > sed 's/^/| /' conftest.$ac_ext >&5
10456 >
10457 > ac_header_compiler=no
10458 > fi
10459 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10460 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10461 > echo "${ECHO_T}$ac_header_compiler" >&6
10462 >
10463 > # Is the header present?
10464 > echo "$as_me:$LINENO: checking iostream presence" >&5
10465 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10466 > cat >conftest.$ac_ext <<_ACEOF
10467 > /* confdefs.h.  */
10468 > _ACEOF
10469 > cat confdefs.h >>conftest.$ac_ext
10470 > cat >>conftest.$ac_ext <<_ACEOF
10471 > /* end confdefs.h.  */
10472 > #include <iostream>
10473 > _ACEOF
10474 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10475 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10476 >  ac_status=$?
10477 >  grep -v '^ *+' conftest.er1 >conftest.err
10478 >  rm -f conftest.er1
10479 >  cat conftest.err >&5
10480 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10481 >  (exit $ac_status); } >/dev/null; then
10482 >  if test -s conftest.err; then
10483 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10484 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10485 >  else
10486 >    ac_cpp_err=
10487 >  fi
10488 > else
10489 >  ac_cpp_err=yes
10490 > fi
10491 > if test -z "$ac_cpp_err"; then
10492 >  ac_header_preproc=yes
10493 > else
10494 >  echo "$as_me: failed program was:" >&5
10495 > sed 's/^/| /' conftest.$ac_ext >&5
10496 >
10497 >  ac_header_preproc=no
10498 > fi
10499 > rm -f conftest.err conftest.$ac_ext
10500 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10501 > echo "${ECHO_T}$ac_header_preproc" >&6
10502 >
10503 > # So?  What about this header?
10504 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10505 >  yes:no: )
10506 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10507 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10508 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10509 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10510 >    ac_header_preproc=yes
10511 >    ;;
10512 >  no:yes:* )
10513 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10514 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10515 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10516 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10517 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10518 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10519 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10520 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10521 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10522 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10523 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10524 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10525 >    (
10526 >      cat <<\_ASBOX
10527 > ## ------------------------------ ##
10528 > ## Report this to gezelter@nd.edu ##
10529 > ## ------------------------------ ##
10530 > _ASBOX
10531 >    ) |
10532 >      sed "s/^/$as_me: WARNING:     /" >&2
10533 >    ;;
10534 > esac
10535 > echo "$as_me:$LINENO: checking for iostream" >&5
10536 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10537 > if test "${ac_cv_header_iostream+set}" = set; then
10538 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10539 > else
10540 >  ac_cv_header_iostream=$ac_header_preproc
10541 > fi
10542 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10543 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10544 >
10545 > fi
10546 > if test $ac_cv_header_iostream = yes; then
10547 >
10548 >
10549 > cat >>confdefs.h <<\_ACEOF
10550 > #define HAVE_IOSTREAM 1
10551 > _ACEOF
10552 >
10553 >
10554 > else
10555 >
10556 >
10557 > for ac_header in iostream.h
10558 > do
10559 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10560 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10561 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10562 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10563 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10564 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10565 > fi
10566 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10567 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10568 > else
10569 >  # Is the header compilable?
10570 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10571 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10572 > cat >conftest.$ac_ext <<_ACEOF
10573 > /* confdefs.h.  */
10574 > _ACEOF
10575 > cat confdefs.h >>conftest.$ac_ext
10576 > cat >>conftest.$ac_ext <<_ACEOF
10577 > /* end confdefs.h.  */
10578 > $ac_includes_default
10579 > #include <$ac_header>
10580 > _ACEOF
10581 > rm -f conftest.$ac_objext
10582 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10583 >  (eval $ac_compile) 2>conftest.er1
10584 >  ac_status=$?
10585 >  grep -v '^ *+' conftest.er1 >conftest.err
10586 >  rm -f conftest.er1
10587 >  cat conftest.err >&5
10588 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589 >  (exit $ac_status); } &&
10590 >         { ac_try='test -z "$ac_cxx_werror_flag"
10591 >                         || test ! -s conftest.err'
10592 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10593 >  (eval $ac_try) 2>&5
10594 >  ac_status=$?
10595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10596 >  (exit $ac_status); }; } &&
10597 >         { ac_try='test -s conftest.$ac_objext'
10598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10599 >  (eval $ac_try) 2>&5
10600 >  ac_status=$?
10601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10602 >  (exit $ac_status); }; }; then
10603 >  ac_header_compiler=yes
10604 > else
10605 >  echo "$as_me: failed program was:" >&5
10606 > sed 's/^/| /' conftest.$ac_ext >&5
10607 >
10608 > ac_header_compiler=no
10609 > fi
10610 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10611 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10612 > echo "${ECHO_T}$ac_header_compiler" >&6
10613 >
10614 > # Is the header present?
10615 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10616 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10617 > cat >conftest.$ac_ext <<_ACEOF
10618 > /* confdefs.h.  */
10619 > _ACEOF
10620 > cat confdefs.h >>conftest.$ac_ext
10621 > cat >>conftest.$ac_ext <<_ACEOF
10622 > /* end confdefs.h.  */
10623 > #include <$ac_header>
10624 > _ACEOF
10625 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10626 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10627 >  ac_status=$?
10628 >  grep -v '^ *+' conftest.er1 >conftest.err
10629 >  rm -f conftest.er1
10630 >  cat conftest.err >&5
10631 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10632 >  (exit $ac_status); } >/dev/null; then
10633 >  if test -s conftest.err; then
10634 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10635 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10636 >  else
10637 >    ac_cpp_err=
10638 >  fi
10639 > else
10640 >  ac_cpp_err=yes
10641 > fi
10642 > if test -z "$ac_cpp_err"; then
10643 >  ac_header_preproc=yes
10644 > else
10645 >  echo "$as_me: failed program was:" >&5
10646 > sed 's/^/| /' conftest.$ac_ext >&5
10647 >
10648 >  ac_header_preproc=no
10649 > fi
10650 > rm -f conftest.err conftest.$ac_ext
10651 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10652 > echo "${ECHO_T}$ac_header_preproc" >&6
10653 >
10654 > # So?  What about this header?
10655 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10656 >  yes:no: )
10657 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10658 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10659 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10660 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10661 >    ac_header_preproc=yes
10662 >    ;;
10663 >  no:yes:* )
10664 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10665 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10666 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10667 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10668 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10669 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10670 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10671 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10672 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10673 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10674 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10675 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10676 >    (
10677 >      cat <<\_ASBOX
10678 > ## ------------------------------ ##
10679 > ## Report this to gezelter@nd.edu ##
10680 > ## ------------------------------ ##
10681 > _ASBOX
10682 >    ) |
10683 >      sed "s/^/$as_me: WARNING:     /" >&2
10684 >    ;;
10685 > esac
10686 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10687 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10688 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10689 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10690 > else
10691 >  eval "$as_ac_Header=\$ac_header_preproc"
10692 > fi
10693 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10694 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10695 >
10696 > fi
10697 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10698 >  cat >>confdefs.h <<_ACEOF
10699 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10700 > _ACEOF
10701 >
10702 > fi
10703 >
10704 > done
10705 >
10706 >
10707 > fi
10708 >
10709 >
10710 >
10711 >
10712 >  if test "${ac_cv_header_iomanip+set}" = set; then
10713 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10714 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10715 > if test "${ac_cv_header_iomanip+set}" = set; then
10716 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10717 > fi
10718 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10719 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10720 > else
10721 >  # Is the header compilable?
10722 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10723 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10724 > cat >conftest.$ac_ext <<_ACEOF
10725 > /* confdefs.h.  */
10726 > _ACEOF
10727 > cat confdefs.h >>conftest.$ac_ext
10728 > cat >>conftest.$ac_ext <<_ACEOF
10729 > /* end confdefs.h.  */
10730 > $ac_includes_default
10731 > #include <iomanip>
10732 > _ACEOF
10733 > rm -f conftest.$ac_objext
10734 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10735 >  (eval $ac_compile) 2>conftest.er1
10736 >  ac_status=$?
10737 >  grep -v '^ *+' conftest.er1 >conftest.err
10738 >  rm -f conftest.er1
10739 >  cat conftest.err >&5
10740 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10741 >  (exit $ac_status); } &&
10742 >         { ac_try='test -z "$ac_cxx_werror_flag"
10743 >                         || test ! -s conftest.err'
10744 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10745 >  (eval $ac_try) 2>&5
10746 >  ac_status=$?
10747 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10748 >  (exit $ac_status); }; } &&
10749 >         { ac_try='test -s conftest.$ac_objext'
10750 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10751 >  (eval $ac_try) 2>&5
10752 >  ac_status=$?
10753 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10754 >  (exit $ac_status); }; }; then
10755 >  ac_header_compiler=yes
10756 > else
10757 >  echo "$as_me: failed program was:" >&5
10758 > sed 's/^/| /' conftest.$ac_ext >&5
10759 >
10760 > ac_header_compiler=no
10761 > fi
10762 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10763 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10764 > echo "${ECHO_T}$ac_header_compiler" >&6
10765 >
10766 > # Is the header present?
10767 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10768 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10769 > cat >conftest.$ac_ext <<_ACEOF
10770 > /* confdefs.h.  */
10771 > _ACEOF
10772 > cat confdefs.h >>conftest.$ac_ext
10773 > cat >>conftest.$ac_ext <<_ACEOF
10774 > /* end confdefs.h.  */
10775 > #include <iomanip>
10776 > _ACEOF
10777 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10778 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10779 >  ac_status=$?
10780 >  grep -v '^ *+' conftest.er1 >conftest.err
10781 >  rm -f conftest.er1
10782 >  cat conftest.err >&5
10783 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10784 >  (exit $ac_status); } >/dev/null; then
10785 >  if test -s conftest.err; then
10786 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10787 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10788 >  else
10789 >    ac_cpp_err=
10790 >  fi
10791 > else
10792 >  ac_cpp_err=yes
10793 > fi
10794 > if test -z "$ac_cpp_err"; then
10795 >  ac_header_preproc=yes
10796 > else
10797 >  echo "$as_me: failed program was:" >&5
10798 > sed 's/^/| /' conftest.$ac_ext >&5
10799 >
10800 >  ac_header_preproc=no
10801 > fi
10802 > rm -f conftest.err conftest.$ac_ext
10803 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10804 > echo "${ECHO_T}$ac_header_preproc" >&6
10805 >
10806 > # So?  What about this header?
10807 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10808 >  yes:no: )
10809 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10810 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10811 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10812 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10813 >    ac_header_preproc=yes
10814 >    ;;
10815 >  no:yes:* )
10816 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10817 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10818 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10819 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10820 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10821 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10822 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10823 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10824 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10825 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10826 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10827 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10828 >    (
10829 >      cat <<\_ASBOX
10830 > ## ------------------------------ ##
10831 > ## Report this to gezelter@nd.edu ##
10832 > ## ------------------------------ ##
10833 > _ASBOX
10834 >    ) |
10835 >      sed "s/^/$as_me: WARNING:     /" >&2
10836 >    ;;
10837 > esac
10838 > echo "$as_me:$LINENO: checking for iomanip" >&5
10839 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10840 > if test "${ac_cv_header_iomanip+set}" = set; then
10841 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10842 > else
10843 >  ac_cv_header_iomanip=$ac_header_preproc
10844 > fi
10845 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10846 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10847 >
10848 > fi
10849 > if test $ac_cv_header_iomanip = yes; then
10850 >
10851 >
10852 > cat >>confdefs.h <<\_ACEOF
10853 > #define HAVE_IOMANIP 1
10854 > _ACEOF
10855 >
10856 >
10857 > else
10858 >
10859 >
10860 > for ac_header in iomanip.h
10861 > do
10862 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10863 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10864 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10865 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10866 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10867 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10868 > fi
10869 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10870 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10871 > else
10872 >  # Is the header compilable?
10873 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10874 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10875 > cat >conftest.$ac_ext <<_ACEOF
10876 > /* confdefs.h.  */
10877 > _ACEOF
10878 > cat confdefs.h >>conftest.$ac_ext
10879 > cat >>conftest.$ac_ext <<_ACEOF
10880 > /* end confdefs.h.  */
10881 > $ac_includes_default
10882 > #include <$ac_header>
10883 > _ACEOF
10884 > rm -f conftest.$ac_objext
10885 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10886 >  (eval $ac_compile) 2>conftest.er1
10887 >  ac_status=$?
10888 >  grep -v '^ *+' conftest.er1 >conftest.err
10889 >  rm -f conftest.er1
10890 >  cat conftest.err >&5
10891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10892 >  (exit $ac_status); } &&
10893 >         { ac_try='test -z "$ac_cxx_werror_flag"
10894 >                         || test ! -s conftest.err'
10895 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10896 >  (eval $ac_try) 2>&5
10897 >  ac_status=$?
10898 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10899 >  (exit $ac_status); }; } &&
10900 >         { ac_try='test -s conftest.$ac_objext'
10901 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10902 >  (eval $ac_try) 2>&5
10903 >  ac_status=$?
10904 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10905 >  (exit $ac_status); }; }; then
10906 >  ac_header_compiler=yes
10907 > else
10908 >  echo "$as_me: failed program was:" >&5
10909 > sed 's/^/| /' conftest.$ac_ext >&5
10910 >
10911 > ac_header_compiler=no
10912 > fi
10913 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10914 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10915 > echo "${ECHO_T}$ac_header_compiler" >&6
10916 >
10917 > # Is the header present?
10918 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10919 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10920 > cat >conftest.$ac_ext <<_ACEOF
10921 > /* confdefs.h.  */
10922 > _ACEOF
10923 > cat confdefs.h >>conftest.$ac_ext
10924 > cat >>conftest.$ac_ext <<_ACEOF
10925 > /* end confdefs.h.  */
10926 > #include <$ac_header>
10927 > _ACEOF
10928 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10929 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10930 >  ac_status=$?
10931 >  grep -v '^ *+' conftest.er1 >conftest.err
10932 >  rm -f conftest.er1
10933 >  cat conftest.err >&5
10934 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10935 >  (exit $ac_status); } >/dev/null; then
10936 >  if test -s conftest.err; then
10937 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10938 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10939 >  else
10940 >    ac_cpp_err=
10941 >  fi
10942 > else
10943 >  ac_cpp_err=yes
10944 > fi
10945 > if test -z "$ac_cpp_err"; then
10946 >  ac_header_preproc=yes
10947 > else
10948 >  echo "$as_me: failed program was:" >&5
10949 > sed 's/^/| /' conftest.$ac_ext >&5
10950 >
10951 >  ac_header_preproc=no
10952 > fi
10953 > rm -f conftest.err conftest.$ac_ext
10954 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10955 > echo "${ECHO_T}$ac_header_preproc" >&6
10956 >
10957 > # So?  What about this header?
10958 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10959 >  yes:no: )
10960 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10961 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10962 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10963 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10964 >    ac_header_preproc=yes
10965 >    ;;
10966 >  no:yes:* )
10967 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10968 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10969 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10970 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10971 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10972 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10973 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10974 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10975 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10976 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10977 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10978 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10979 >    (
10980 >      cat <<\_ASBOX
10981 > ## ------------------------------ ##
10982 > ## Report this to gezelter@nd.edu ##
10983 > ## ------------------------------ ##
10984 > _ASBOX
10985 >    ) |
10986 >      sed "s/^/$as_me: WARNING:     /" >&2
10987 >    ;;
10988 > esac
10989 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10990 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10991 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10992 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10993 > else
10994 >  eval "$as_ac_Header=\$ac_header_preproc"
10995 > fi
10996 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10997 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10998 >
10999 > fi
11000 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11001 >  cat >>confdefs.h <<_ACEOF
11002 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11003 > _ACEOF
11004 >
11005 > fi
11006 >
11007 > done
11008 >
11009 >
11010 > fi
11011 >
11012 >
11013 >
11014 >
11015 > for ac_header in cmath
11016 > do
11017 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11018 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11019 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11020 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11021 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11022 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11023 > fi
11024 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11025 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11026 > else
11027 >  # Is the header compilable?
11028 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11029 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11030 > cat >conftest.$ac_ext <<_ACEOF
11031 > /* confdefs.h.  */
11032 > _ACEOF
11033 > cat confdefs.h >>conftest.$ac_ext
11034 > cat >>conftest.$ac_ext <<_ACEOF
11035 > /* end confdefs.h.  */
11036 > $ac_includes_default
11037 > #include <$ac_header>
11038 > _ACEOF
11039 > rm -f conftest.$ac_objext
11040 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11041 >  (eval $ac_compile) 2>conftest.er1
11042 >  ac_status=$?
11043 >  grep -v '^ *+' conftest.er1 >conftest.err
11044 >  rm -f conftest.er1
11045 >  cat conftest.err >&5
11046 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11047 >  (exit $ac_status); } &&
11048 >         { ac_try='test -z "$ac_cxx_werror_flag"
11049 >                         || test ! -s conftest.err'
11050 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11051 >  (eval $ac_try) 2>&5
11052 >  ac_status=$?
11053 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11054 >  (exit $ac_status); }; } &&
11055 >         { ac_try='test -s conftest.$ac_objext'
11056 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11057 >  (eval $ac_try) 2>&5
11058 >  ac_status=$?
11059 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11060 >  (exit $ac_status); }; }; then
11061 >  ac_header_compiler=yes
11062 > else
11063 >  echo "$as_me: failed program was:" >&5
11064 > sed 's/^/| /' conftest.$ac_ext >&5
11065 >
11066 > ac_header_compiler=no
11067 > fi
11068 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11069 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11070 > echo "${ECHO_T}$ac_header_compiler" >&6
11071 >
11072 > # Is the header present?
11073 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11074 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11075 > cat >conftest.$ac_ext <<_ACEOF
11076 > /* confdefs.h.  */
11077 > _ACEOF
11078 > cat confdefs.h >>conftest.$ac_ext
11079 > cat >>conftest.$ac_ext <<_ACEOF
11080 > /* end confdefs.h.  */
11081 > #include <$ac_header>
11082 > _ACEOF
11083 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11084 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11085 >  ac_status=$?
11086 >  grep -v '^ *+' conftest.er1 >conftest.err
11087 >  rm -f conftest.er1
11088 >  cat conftest.err >&5
11089 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11090 >  (exit $ac_status); } >/dev/null; then
11091 >  if test -s conftest.err; then
11092 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11093 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11094 >  else
11095 >    ac_cpp_err=
11096 >  fi
11097 > else
11098 >  ac_cpp_err=yes
11099 > fi
11100 > if test -z "$ac_cpp_err"; then
11101 >  ac_header_preproc=yes
11102 > else
11103 >  echo "$as_me: failed program was:" >&5
11104 > sed 's/^/| /' conftest.$ac_ext >&5
11105 >
11106 >  ac_header_preproc=no
11107 > fi
11108 > rm -f conftest.err conftest.$ac_ext
11109 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11110 > echo "${ECHO_T}$ac_header_preproc" >&6
11111 >
11112 > # So?  What about this header?
11113 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11114 >  yes:no: )
11115 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11116 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11117 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11118 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11119 >    ac_header_preproc=yes
11120 >    ;;
11121 >  no:yes:* )
11122 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11123 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11124 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11125 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11126 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11127 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11128 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11129 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11130 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11131 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11132 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11133 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11134 >    (
11135 >      cat <<\_ASBOX
11136 > ## ------------------------------ ##
11137 > ## Report this to gezelter@nd.edu ##
11138 > ## ------------------------------ ##
11139 > _ASBOX
11140 >    ) |
11141 >      sed "s/^/$as_me: WARNING:     /" >&2
11142 >    ;;
11143 > esac
11144 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11145 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11146 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11147 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11148 > else
11149 >  eval "$as_ac_Header=\$ac_header_preproc"
11150 > fi
11151 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11152 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11153 >
11154 > fi
11155 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11156 >  cat >>confdefs.h <<_ACEOF
11157 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11158 > _ACEOF
11159 >
11160 > fi
11161 >
11162 > done
11163 >
11164 >
11165 >
11166 >
11167 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11168 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11169 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11170 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11171 > else
11172 >
11173 >      ac_cv_cxx_have_std_iostream=no
11174 >      ac_cv_cxx_need_use_std_iostream=no
11175 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11176 >
11177 >
11178 >        ac_ext=cc
11179 > ac_cpp='$CXXCPP $CPPFLAGS'
11180 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11181 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11182 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11183 >
11184 >        cat >conftest.$ac_ext <<_ACEOF
11185 > /* confdefs.h.  */
11186 > _ACEOF
11187 > cat confdefs.h >>conftest.$ac_ext
11188 > cat >>conftest.$ac_ext <<_ACEOF
11189 > /* end confdefs.h.  */
11190 >
11191 > #ifdef HAVE_IOSTREAM
11192 > #include <iostream>
11193 > #else
11194 > #include <iostream.h>
11195 > #endif
11196 >
11197 > #ifdef FC_DUMMY_MAIN
11198 > #ifndef FC_DUMMY_MAIN_EQ_F77
11199 > #  ifdef __cplusplus
11200 >     extern "C"
11201 > #  endif
11202 >   int FC_DUMMY_MAIN() { return 1; }
11203 > #endif
11204 > #endif
11205 > int
11206 > main ()
11207 > {
11208 > std::cout<<"Hello World"<<std::endl;return 0;
11209 >  ;
11210 >  return 0;
11211 > }
11212 > _ACEOF
11213 > rm -f conftest.$ac_objext
11214 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11215 >  (eval $ac_compile) 2>conftest.er1
11216 >  ac_status=$?
11217 >  grep -v '^ *+' conftest.er1 >conftest.err
11218 >  rm -f conftest.er1
11219 >  cat conftest.err >&5
11220 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11221 >  (exit $ac_status); } &&
11222 >         { ac_try='test -z "$ac_cxx_werror_flag"
11223 >                         || test ! -s conftest.err'
11224 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11225 >  (eval $ac_try) 2>&5
11226 >  ac_status=$?
11227 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11228 >  (exit $ac_status); }; } &&
11229 >         { ac_try='test -s conftest.$ac_objext'
11230 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11231 >  (eval $ac_try) 2>&5
11232 >  ac_status=$?
11233 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11234 >  (exit $ac_status); }; }; then
11235 >  ac_cv_cxx_have_std_iostream=yes
11236 > else
11237 >  echo "$as_me: failed program was:" >&5
11238 > sed 's/^/| /' conftest.$ac_ext >&5
11239 >
11240 > fi
11241 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11242 >        cat >conftest.$ac_ext <<_ACEOF
11243 > /* confdefs.h.  */
11244 > _ACEOF
11245 > cat confdefs.h >>conftest.$ac_ext
11246 > cat >>conftest.$ac_ext <<_ACEOF
11247 > /* end confdefs.h.  */
11248 >
11249 > #define __USE_STD_IOSTREAM 1
11250 > #ifdef HAVE_IOSTREAM
11251 > #include <iostream>
11252 > #else
11253 > #include <iostream.h>
11254 > #endif
11255 >
11256 > #ifdef FC_DUMMY_MAIN
11257 > #ifndef FC_DUMMY_MAIN_EQ_F77
11258 > #  ifdef __cplusplus
11259 >     extern "C"
11260 > #  endif
11261 >   int FC_DUMMY_MAIN() { return 1; }
11262 > #endif
11263 > #endif
11264 > int
11265 > main ()
11266 > {
11267 > std::cout<<"Hello World"<<std::endl;return 0;
11268 >  ;
11269 >  return 0;
11270 > }
11271 > _ACEOF
11272 > rm -f conftest.$ac_objext
11273 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11274 >  (eval $ac_compile) 2>conftest.er1
11275 >  ac_status=$?
11276 >  grep -v '^ *+' conftest.er1 >conftest.err
11277 >  rm -f conftest.er1
11278 >  cat conftest.err >&5
11279 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11280 >  (exit $ac_status); } &&
11281 >         { ac_try='test -z "$ac_cxx_werror_flag"
11282 >                         || test ! -s conftest.err'
11283 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11284 >  (eval $ac_try) 2>&5
11285 >  ac_status=$?
11286 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11287 >  (exit $ac_status); }; } &&
11288 >         { ac_try='test -s conftest.$ac_objext'
11289 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11290 >  (eval $ac_try) 2>&5
11291 >  ac_status=$?
11292 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11293 >  (exit $ac_status); }; }; then
11294 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11295 > else
11296 >  echo "$as_me: failed program was:" >&5
11297 > sed 's/^/| /' conftest.$ac_ext >&5
11298 >
11299 > fi
11300 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11301 >        ac_ext=cc
11302 > ac_cpp='$CXXCPP $CPPFLAGS'
11303 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11304 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11305 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11306 >
11307 >      fi
11308 >
11309 > fi
11310 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11311 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11312 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11313 >
11314 > cat >>confdefs.h <<\_ACEOF
11315 > #define HAVE_STD_IOSTREAM 1
11316 > _ACEOF
11317 >
11318 >  fi
11319 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11320 >
11321 > cat >>confdefs.h <<\_ACEOF
11322 > #define __USE_STD_IOSTREAM 1
11323 > _ACEOF
11324 >
11325 >  fi
11326 >
11327 >
11328 >
11329 >
11330 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11331 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11332 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11333 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11334 > else
11335 >
11336 >      ac_cv_cxx_have_std_stl=no
11337 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11338 >
11339 >
11340 >        ac_ext=cc
11341 > ac_cpp='$CXXCPP $CPPFLAGS'
11342 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11343 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11344 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11345 >
11346 >        cat >conftest.$ac_ext <<_ACEOF
11347 > /* confdefs.h.  */
11348 > _ACEOF
11349 > cat confdefs.h >>conftest.$ac_ext
11350 > cat >>conftest.$ac_ext <<_ACEOF
11351 > /* end confdefs.h.  */
11352 > #include <list>
11353 >
11354 > #ifdef FC_DUMMY_MAIN
11355 > #ifndef FC_DUMMY_MAIN_EQ_F77
11356 > #  ifdef __cplusplus
11357 >     extern "C"
11358 > #  endif
11359 >   int FC_DUMMY_MAIN() { return 1; }
11360 > #endif
11361 > #endif
11362 > int
11363 > main ()
11364 > {
11365 > std::list<int> foo;return 0;
11366 >  ;
11367 >  return 0;
11368 > }
11369 > _ACEOF
11370 > rm -f conftest.$ac_objext
11371 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11372 >  (eval $ac_compile) 2>conftest.er1
11373 >  ac_status=$?
11374 >  grep -v '^ *+' conftest.er1 >conftest.err
11375 >  rm -f conftest.er1
11376 >  cat conftest.err >&5
11377 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11378 >  (exit $ac_status); } &&
11379 >         { ac_try='test -z "$ac_cxx_werror_flag"
11380 >                         || test ! -s conftest.err'
11381 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11382 >  (eval $ac_try) 2>&5
11383 >  ac_status=$?
11384 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11385 >  (exit $ac_status); }; } &&
11386 >         { ac_try='test -s conftest.$ac_objext'
11387 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11388 >  (eval $ac_try) 2>&5
11389 >  ac_status=$?
11390 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11391 >  (exit $ac_status); }; }; then
11392 >  ac_cv_cxx_have_std_stl=yes
11393 > else
11394 >  echo "$as_me: failed program was:" >&5
11395 > sed 's/^/| /' conftest.$ac_ext >&5
11396 >
11397 > fi
11398 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11399 >        ac_ext=cc
11400 > ac_cpp='$CXXCPP $CPPFLAGS'
11401 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11402 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11403 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11404 >
11405 >      fi
11406 >
11407 > fi
11408 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11409 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11410 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11411 >
11412 > cat >>confdefs.h <<\_ACEOF
11413 > #define HAVE_STD_STL 1
11414 > _ACEOF
11415 >
11416 >  fi
11417 >
11418 >
11419 >
11420 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11421 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11422 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11423 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11424 > else
11425 >
11426 >    ac_cv_cxx_have_fstream_attach=no
11427 >
11428 >
11429 >    ac_ext=cc
11430 > ac_cpp='$CXXCPP $CPPFLAGS'
11431 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11432 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11433 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11434 >
11435 >    cat >conftest.$ac_ext <<_ACEOF
11436 > /* confdefs.h.  */
11437 > _ACEOF
11438 > cat confdefs.h >>conftest.$ac_ext
11439 > cat >>conftest.$ac_ext <<_ACEOF
11440 > /* end confdefs.h.  */
11441 >
11442 > #ifdef HAVE_IOSTREAM
11443 > #include <fstream>
11444 > #else
11445 > #include <fstream.h>
11446 > #endif
11447 > #ifdef HAVE_STD_IOSTREAM
11448 > using namespace std;
11449 > #endif
11450 >
11451 > #ifdef FC_DUMMY_MAIN
11452 > #ifndef FC_DUMMY_MAIN_EQ_F77
11453 > #  ifdef __cplusplus
11454 >     extern "C"
11455 > #  endif
11456 >   int FC_DUMMY_MAIN() { return 1; }
11457 > #endif
11458 > #endif
11459 > int
11460 > main ()
11461 > {
11462 > int fd=0;ofstream s;s.attach(fd);
11463 >  ;
11464 >  return 0;
11465 > }
11466 > _ACEOF
11467 > rm -f conftest.$ac_objext
11468 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11469 >  (eval $ac_compile) 2>conftest.er1
11470 >  ac_status=$?
11471 >  grep -v '^ *+' conftest.er1 >conftest.err
11472 >  rm -f conftest.er1
11473 >  cat conftest.err >&5
11474 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11475 >  (exit $ac_status); } &&
11476 >         { ac_try='test -z "$ac_cxx_werror_flag"
11477 >                         || test ! -s conftest.err'
11478 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11479 >  (eval $ac_try) 2>&5
11480 >  ac_status=$?
11481 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482 >  (exit $ac_status); }; } &&
11483 >         { ac_try='test -s conftest.$ac_objext'
11484 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11485 >  (eval $ac_try) 2>&5
11486 >  ac_status=$?
11487 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11488 >  (exit $ac_status); }; }; then
11489 >  ac_cv_cxx_have_fstream_attach=yes
11490 > else
11491 >  echo "$as_me: failed program was:" >&5
11492 > sed 's/^/| /' conftest.$ac_ext >&5
11493 >
11494 > fi
11495 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11496 >    ac_ext=cc
11497 > ac_cpp='$CXXCPP $CPPFLAGS'
11498 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11499 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11500 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11501 >
11502 >
11503 > fi
11504 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11505 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11506 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11507 >
11508 > cat >>confdefs.h <<\_ACEOF
11509 > #define HAVE_FSTREAM_ATTACH 1
11510 > _ACEOF
11511 >
11512 >  fi
11513 >
11514 >
11515 >
11516 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11517 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11518 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11519 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11520 > else
11521 >
11522 >    ac_cv_cxx_have_fstream_open=no
11523 >    ac_cv_cxx_fstream_open_prot=no
11524 >
11525 >
11526 >    ac_ext=cc
11527 > ac_cpp='$CXXCPP $CPPFLAGS'
11528 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11529 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11530 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11531 >
11532 >    # Try with 2 parameters
11533 >    cat >conftest.$ac_ext <<_ACEOF
11534 > /* confdefs.h.  */
11535 > _ACEOF
11536 > cat confdefs.h >>conftest.$ac_ext
11537 > cat >>conftest.$ac_ext <<_ACEOF
11538 > /* end confdefs.h.  */
11539 >
11540 > #ifdef HAVE_IOSTREAM
11541 > #include <fstream>
11542 > #else
11543 > #include <fstream.h>
11544 > #endif
11545 > #ifdef HAVE_STD_IOSTREAM
11546 > using namespace std;
11547 > #endif
11548 >
11549 > #ifdef FC_DUMMY_MAIN
11550 > #ifndef FC_DUMMY_MAIN_EQ_F77
11551 > #  ifdef __cplusplus
11552 >     extern "C"
11553 > #  endif
11554 >   int FC_DUMMY_MAIN() { return 1; }
11555 > #endif
11556 > #endif
11557 > int
11558 > main ()
11559 > {
11560 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11561 >  ;
11562 >  return 0;
11563 > }
11564 > _ACEOF
11565 > rm -f conftest.$ac_objext
11566 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11567 >  (eval $ac_compile) 2>conftest.er1
11568 >  ac_status=$?
11569 >  grep -v '^ *+' conftest.er1 >conftest.err
11570 >  rm -f conftest.er1
11571 >  cat conftest.err >&5
11572 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11573 >  (exit $ac_status); } &&
11574 >         { ac_try='test -z "$ac_cxx_werror_flag"
11575 >                         || test ! -s conftest.err'
11576 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11577 >  (eval $ac_try) 2>&5
11578 >  ac_status=$?
11579 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11580 >  (exit $ac_status); }; } &&
11581 >         { ac_try='test -s conftest.$ac_objext'
11582 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11583 >  (eval $ac_try) 2>&5
11584 >  ac_status=$?
11585 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11586 >  (exit $ac_status); }; }; then
11587 >  ac_cv_cxx_have_fstream_open=yes
11588 > else
11589 >  echo "$as_me: failed program was:" >&5
11590 > sed 's/^/| /' conftest.$ac_ext >&5
11591 >
11592 > fi
11593 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11594 >    # Try with mode parameter
11595 >    cat >conftest.$ac_ext <<_ACEOF
11596 > /* confdefs.h.  */
11597 > _ACEOF
11598 > cat confdefs.h >>conftest.$ac_ext
11599 > cat >>conftest.$ac_ext <<_ACEOF
11600 > /* end confdefs.h.  */
11601 >
11602 > #ifdef HAVE_IOSTREAM
11603 > #include <fstream>
11604 > #else
11605 > #include <fstream.h>
11606 > #endif
11607 > #ifdef HAVE_STD_IOSTREAM
11608 > using namespace std;
11609 > #endif
11610 >
11611 > #ifdef FC_DUMMY_MAIN
11612 > #ifndef FC_DUMMY_MAIN_EQ_F77
11613 > #  ifdef __cplusplus
11614 >     extern "C"
11615 > #  endif
11616 >   int FC_DUMMY_MAIN() { return 1; }
11617 > #endif
11618 > #endif
11619 > int
11620 > main ()
11621 > {
11622 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11623 >  ;
11624 >  return 0;
11625 > }
11626 > _ACEOF
11627 > rm -f conftest.$ac_objext
11628 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11629 >  (eval $ac_compile) 2>conftest.er1
11630 >  ac_status=$?
11631 >  grep -v '^ *+' conftest.er1 >conftest.err
11632 >  rm -f conftest.er1
11633 >  cat conftest.err >&5
11634 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11635 >  (exit $ac_status); } &&
11636 >         { ac_try='test -z "$ac_cxx_werror_flag"
11637 >                         || test ! -s conftest.err'
11638 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11639 >  (eval $ac_try) 2>&5
11640 >  ac_status=$?
11641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11642 >  (exit $ac_status); }; } &&
11643 >         { ac_try='test -s conftest.$ac_objext'
11644 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11645 >  (eval $ac_try) 2>&5
11646 >  ac_status=$?
11647 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648 >  (exit $ac_status); }; }; then
11649 >  ac_cv_cxx_fstream_open_prot=yes
11650 > else
11651 >  echo "$as_me: failed program was:" >&5
11652 > sed 's/^/| /' conftest.$ac_ext >&5
11653 >
11654 > fi
11655 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11656 >    ac_ext=cc
11657 > ac_cpp='$CXXCPP $CPPFLAGS'
11658 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11659 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11660 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11661 >
11662 >
11663 > fi
11664 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11665 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11666 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11667 >
11668 > cat >>confdefs.h <<\_ACEOF
11669 > #define HAVE_FSTREAM_OPEN 1
11670 > _ACEOF
11671 >
11672 >  fi
11673 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11674 >
11675 > cat >>confdefs.h <<\_ACEOF
11676 > #define FSTREAM_OPEN_PROT 1
11677 > _ACEOF
11678 >
11679 >  fi
11680 >
11681 >
11682 >
11683 >
11684 >
11685 >
11686 >
11687 > for ac_header in ctype.h iostream fstream sstream strstream
11688 > do
11689 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11690 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11691 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11692 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11693 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11694 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11695 > fi
11696 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11697 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11698 > else
11699 >  # Is the header compilable?
11700 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11701 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11702 > cat >conftest.$ac_ext <<_ACEOF
11703 > /* confdefs.h.  */
11704 > _ACEOF
11705 > cat confdefs.h >>conftest.$ac_ext
11706 > cat >>conftest.$ac_ext <<_ACEOF
11707 > /* end confdefs.h.  */
11708 > $ac_includes_default
11709 > #include <$ac_header>
11710 > _ACEOF
11711 > rm -f conftest.$ac_objext
11712 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11713 >  (eval $ac_compile) 2>conftest.er1
11714 >  ac_status=$?
11715 >  grep -v '^ *+' conftest.er1 >conftest.err
11716 >  rm -f conftest.er1
11717 >  cat conftest.err >&5
11718 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11719 >  (exit $ac_status); } &&
11720 >         { ac_try='test -z "$ac_cxx_werror_flag"
11721 >                         || test ! -s conftest.err'
11722 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11723 >  (eval $ac_try) 2>&5
11724 >  ac_status=$?
11725 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11726 >  (exit $ac_status); }; } &&
11727 >         { ac_try='test -s conftest.$ac_objext'
11728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11729 >  (eval $ac_try) 2>&5
11730 >  ac_status=$?
11731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11732 >  (exit $ac_status); }; }; then
11733 >  ac_header_compiler=yes
11734 > else
11735 >  echo "$as_me: failed program was:" >&5
11736 > sed 's/^/| /' conftest.$ac_ext >&5
11737 >
11738 > ac_header_compiler=no
11739 > fi
11740 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11741 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11742 > echo "${ECHO_T}$ac_header_compiler" >&6
11743 >
11744 > # Is the header present?
11745 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11746 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11747 > cat >conftest.$ac_ext <<_ACEOF
11748 > /* confdefs.h.  */
11749 > _ACEOF
11750 > cat confdefs.h >>conftest.$ac_ext
11751 > cat >>conftest.$ac_ext <<_ACEOF
11752 > /* end confdefs.h.  */
11753 > #include <$ac_header>
11754 > _ACEOF
11755 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11756 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11757 >  ac_status=$?
11758 >  grep -v '^ *+' conftest.er1 >conftest.err
11759 >  rm -f conftest.er1
11760 >  cat conftest.err >&5
11761 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11762 >  (exit $ac_status); } >/dev/null; then
11763 >  if test -s conftest.err; then
11764 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11765 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11766 >  else
11767 >    ac_cpp_err=
11768 >  fi
11769 > else
11770 >  ac_cpp_err=yes
11771 > fi
11772 > if test -z "$ac_cpp_err"; then
11773 >  ac_header_preproc=yes
11774 > else
11775 >  echo "$as_me: failed program was:" >&5
11776 > sed 's/^/| /' conftest.$ac_ext >&5
11777 >
11778 >  ac_header_preproc=no
11779 > fi
11780 > rm -f conftest.err conftest.$ac_ext
11781 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11782 > echo "${ECHO_T}$ac_header_preproc" >&6
11783 >
11784 > # So?  What about this header?
11785 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11786 >  yes:no: )
11787 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11788 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11789 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11790 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11791 >    ac_header_preproc=yes
11792 >    ;;
11793 >  no:yes:* )
11794 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11795 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11796 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11797 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11798 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11799 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11800 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11801 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11802 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11803 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11804 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11805 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11806 >    (
11807 >      cat <<\_ASBOX
11808 > ## ------------------------------ ##
11809 > ## Report this to gezelter@nd.edu ##
11810 > ## ------------------------------ ##
11811 > _ASBOX
11812 >    ) |
11813 >      sed "s/^/$as_me: WARNING:     /" >&2
11814 >    ;;
11815 > esac
11816 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11817 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11818 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11819 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11820 > else
11821 >  eval "$as_ac_Header=\$ac_header_preproc"
11822 > fi
11823 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11824 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11825 >
11826 > fi
11827 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11828 >  cat >>confdefs.h <<_ACEOF
11829 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11830 > _ACEOF
11831 >
11832 > fi
11833 >
11834 > done
11835 >
11836 > # AC_CPP_FUNC
11837 > # ------------------ #
11838 > # Checks to see if ANSI C99 CPP variable __func__ works.
11839 > # If not, perhaps __FUNCTION__ works instead.
11840 > # If not, we'll just define __func__ to "".
11841 > # AC_CPP_FUNC
11842 >
11843 >
11844 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11845 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11846 > if test "${ac_cv_cpp_func+set}" = set; then
11847 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11848 > else
11849 >  cat >conftest.$ac_ext <<_ACEOF
11850 > /* confdefs.h.  */
11851 > _ACEOF
11852 > cat confdefs.h >>conftest.$ac_ext
11853 > cat >>conftest.$ac_ext <<_ACEOF
11854 > /* end confdefs.h.  */
11855 >
11856 > #ifdef FC_DUMMY_MAIN
11857 > #ifndef FC_DUMMY_MAIN_EQ_F77
11858 > #  ifdef __cplusplus
11859 >     extern "C"
11860 > #  endif
11861 >   int FC_DUMMY_MAIN() { return 1; }
11862 > #endif
11863 > #endif
11864 > int
11865 > main ()
11866 > {
11867 > const char *foo = __func__;
11868 >  ;
11869 >  return 0;
11870 > }
11871 > _ACEOF
11872 > rm -f conftest.$ac_objext
11873 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11874 >  (eval $ac_compile) 2>conftest.er1
11875 >  ac_status=$?
11876 >  grep -v '^ *+' conftest.er1 >conftest.err
11877 >  rm -f conftest.er1
11878 >  cat conftest.err >&5
11879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11880 >  (exit $ac_status); } &&
11881 >         { ac_try='test -z "$ac_cxx_werror_flag"
11882 >                         || test ! -s conftest.err'
11883 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11884 >  (eval $ac_try) 2>&5
11885 >  ac_status=$?
11886 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11887 >  (exit $ac_status); }; } &&
11888 >         { ac_try='test -s conftest.$ac_objext'
11889 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11890 >  (eval $ac_try) 2>&5
11891 >  ac_status=$?
11892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11893 >  (exit $ac_status); }; }; then
11894 >  ac_cv_cpp_func=yes
11895 > else
11896 >  echo "$as_me: failed program was:" >&5
11897 > sed 's/^/| /' conftest.$ac_ext >&5
11898 >
11899 > cat >conftest.$ac_ext <<_ACEOF
11900 > /* confdefs.h.  */
11901 > _ACEOF
11902 > cat confdefs.h >>conftest.$ac_ext
11903 > cat >>conftest.$ac_ext <<_ACEOF
11904 > /* end confdefs.h.  */
11905 >
11906 > #ifdef FC_DUMMY_MAIN
11907 > #ifndef FC_DUMMY_MAIN_EQ_F77
11908 > #  ifdef __cplusplus
11909 >     extern "C"
11910 > #  endif
11911 >   int FC_DUMMY_MAIN() { return 1; }
11912 > #endif
11913 > #endif
11914 > int
11915 > main ()
11916 > {
11917 > const char *foo = __FUNCTION__;
11918 >  ;
11919 >  return 0;
11920 > }
11921 > _ACEOF
11922 > rm -f conftest.$ac_objext
11923 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11924 >  (eval $ac_compile) 2>conftest.er1
11925 >  ac_status=$?
11926 >  grep -v '^ *+' conftest.er1 >conftest.err
11927 >  rm -f conftest.er1
11928 >  cat conftest.err >&5
11929 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11930 >  (exit $ac_status); } &&
11931 >         { ac_try='test -z "$ac_cxx_werror_flag"
11932 >                         || test ! -s conftest.err'
11933 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11934 >  (eval $ac_try) 2>&5
11935 >  ac_status=$?
11936 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11937 >  (exit $ac_status); }; } &&
11938 >         { ac_try='test -s conftest.$ac_objext'
11939 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11940 >  (eval $ac_try) 2>&5
11941 >  ac_status=$?
11942 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11943 >  (exit $ac_status); }; }; then
11944 >  ac_cv_cpp_func=__FUNCTION__
11945 > else
11946 >  echo "$as_me: failed program was:" >&5
11947 > sed 's/^/| /' conftest.$ac_ext >&5
11948 >
11949 > ac_cv_cpp_func=no
11950 > fi
11951 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11952 > fi
11953 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11954 > fi
11955 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11956 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11957 > if test $ac_cv_cpp_func = __FUNCTION__; then
11958 >
11959 > cat >>confdefs.h <<\_ACEOF
11960 > #define __func__ __FUNCTION__
11961 > _ACEOF
11962 >
11963 > elif test $ac_cv_cpp_func = no; then
11964 >
11965 > cat >>confdefs.h <<\_ACEOF
11966 > #define __func__ ""
11967 > _ACEOF
11968 >
11969 > fi
11970 >
11971 >
11972 >
11973 >
11974 >
11975 > case $debug in
11976 >  1)
11977 >     ;;
11978 >  *)
11979 >
11980 >
11981 >
11982 >
11983 > # Try to determine "good" native compiler flags if none specified on command
11984 > # line
11985 >
11986 > if test "$ac_test_FFLAGS" != "set"; then
11987 >  FCFLAGS=""
11988 >  case "${host_cpu}-${host_os}" in
11989 >
11990 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11991 >                    FCFLAGS="-O3 -ip -no-prec-div"
11992 >                fi;;
11993 >   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11994 >                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11995 >                fi;;
11996 >   powerpc*-aix*)
11997 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11998 >                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11999 >                echo "*******************************************************"
12000 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12001 >                echo "*  recommended that you use                           *"
12002 >                echo "*                                                     *"
12003 >                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12004 >                echo "*                                 ^^^                 *"
12005 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12006 >                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12007 >                echo "*******************************************************"
12008 >        fi;;
12009 >   *darwin*)
12010 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12011 >                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12012 >        fi
12013 >        if test "$FC" = ifort; then
12014 >                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12015 >        fi;;
12016 >  esac
12017 >
12018 >  if test -n "$CPU_FLAGS"; then
12019 >        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12020 >  fi
12021 >
12022 >  if test -z "$FCFLAGS"; then
12023 >        echo ""
12024 >        echo "*********************************************************"
12025 >        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12026 >        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12027 >        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12028 >        echo "*********************************************************"
12029 >        echo ""
12030 >        FCFLAGS="-O3"
12031 >  fi
12032 >
12033 >
12034 > echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12035 > echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12036 > if test "${ac_guessed_f90flags+set}" = set; then
12037 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12038 > else
12039 >
12040 >
12041 >
12042 > ac_ext=${FC_SRCEXT-f}
12043 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12044 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12045 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12046 >
12047 > echo 'program main' > conftest.$ac_ext
12048 > echo 'end program main' >> conftest.$ac_ext
12049 > ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12050 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12051 >  (eval $ac_compile) 2>&5
12052 >  ac_status=$?
12053 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12054 >  (exit $ac_status); }; then
12055 >        ac_guessed_f90flags=yes
12056 > else
12057 >        ac_guessed_f90flags=no
12058 > fi
12059 > rm -f conftest*
12060 > ac_ext=cc
12061 > ac_cpp='$CXXCPP $CPPFLAGS'
12062 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12063 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12064 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12065 >
12066 >
12067 > fi
12068 > echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12069 > echo "${ECHO_T}$ac_guessed_f90flags" >&6
12070 > if test "$ac_guessed_f90flags" = yes; then
12071 >        :
12072 >
12073 > else
12074 >        :
12075 >
12076 >        echo ""
12077 >        echo "**********************************************************"
12078 >        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12079 >        echo "* your compiler.                                        *"
12080 >        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12081 >        echo "*********************************************************"
12082 >        echo ""
12083 >        FCFLAGS=""
12084 >
12085 > fi
12086 >
12087 >
12088 > fi
12089 >
12090 >
12091 >
12092 >
12093 >
12094 >
12095 >
12096 > echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12097 > echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12098 > if test "${ac_cv_prog_really_gcc+set}" = set; then
12099 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12100 > else
12101 >
12102 > cat > conftest.c <<EOF
12103 > #ifdef __GNUC__
12104 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12105 >     no;
12106 >  #else
12107 >     yes;
12108 >  #endif
12109 > #endif
12110 > EOF
12111 > if { ac_try='${CC-cc} -E conftest.c'
12112 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12113 >  (eval $ac_try) 2>&5
12114 >  ac_status=$?
12115 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12116 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12117 >  ac_cv_prog_really_gcc=yes
12118 > else
12119 >  ac_cv_prog_really_gcc=no
12120 > fi
12121 >
12122 > fi
12123 > echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
12124 > echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6
12125 > if test "$ac_cv_prog_really_gcc" = yes; then
12126 >        :
12127 >
12128 > else
12129 >        :
12130 >
12131 > fi
12132 >
12133 >
12134 > # Try to determine "good" native compiler flags if none specified on command
12135 > # line
12136 > if test "$ac_test_CFLAGS" != "set"; then
12137 >  CFLAGS=""
12138 >  case "${host_cpu}-${host_os}" in
12139 >
12140 >  *linux*) if test "$CC" = icc; then
12141 >                    CFLAGS="-O"
12142 >                fi;;
12143 >  sparc-solaris2*) if test "$CC" = cc; then
12144 >                    CFLAGS="-O -dalign"
12145 >                 fi;;
12146 >
12147 >  alpha*-osf*)  if test "$CC" = cc; then
12148 >                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
12149 >                fi;;
12150 >
12151 >  hppa*-hpux*)  if test "$CC" = cc; then
12152 >                    CFLAGS="-Ae +O3 +Oall"
12153 >                fi;;
12154 >
12155 >   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
12156 >                    CFLAGS="-O3 -qtune=auto -qansialias -w"
12157 >                fi;;
12158 >   powerpc*-aix*)
12159 >        if test "$CC" = cc -o "$CC" = xlc; then
12160 >                CFLAGS="-O3 -qtune=auto -qansialias -w"
12161 >                echo "*******************************************************"
12162 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12163 >                echo "*  recommended that you use                           *"
12164 >                echo "*                                                     *"
12165 >                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12166 >                echo "*                                 ^^^                 *"
12167 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12168 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12169 >                echo "*******************************************************"
12170 >        fi;;
12171 >   *darwin*)
12172 >        if test "$CC" = xlc -o "$CC" = cc; then
12173 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12174 >        fi
12175 >        if test "$CC" = icc; then
12176 >                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12177 >        fi;;
12178 >  esac
12179 >
12180 >  # use default flags for gcc on all systems
12181 >  if test $ac_cv_prog_really_gcc = yes; then
12182 >     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12183 >  fi
12184 >
12185 >  # test for gcc-specific flags:
12186 >  if test $ac_cv_prog_really_gcc = yes; then
12187 >    # -malign-double for x86 systems
12188 >
12189 >
12190 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12191 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12192 > if test "${ac_align_double+set}" = set; then
12193 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12194 > else
12195 >  echo 'void f(){}' > conftest.c
12196 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12197 >        ac_align_double=yes
12198 > else
12199 >        ac_align_double=no
12200 > fi
12201 > rm -f conftest*
12202 >
12203 > fi
12204 > echo "$as_me:$LINENO: result: $ac_align_double" >&5
12205 > echo "${ECHO_T}$ac_align_double" >&6
12206 > if test "$ac_align_double" = yes; then
12207 >        :
12208 >        CFLAGS="$CFLAGS -malign-double"
12209 > else
12210 >        :
12211 >
12212 > fi
12213 >
12214 >    # -fstrict-aliasing for gcc-2.95+
12215 >
12216 >
12217 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12218 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12219 > if test "${ac_fstrict_aliasing+set}" = set; then
12220 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12221 > else
12222 >  echo 'void f(){}' > conftest.c
12223 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12224 >        ac_fstrict_aliasing=yes
12225 > else
12226 >        ac_fstrict_aliasing=no
12227 > fi
12228 > rm -f conftest*
12229 >
12230 > fi
12231 > echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
12232 > echo "${ECHO_T}$ac_fstrict_aliasing" >&6
12233 > if test "$ac_fstrict_aliasing" = yes; then
12234 >        :
12235 >        CFLAGS="$CFLAGS -fstrict-aliasing"
12236 > else
12237 >        :
12238 >
12239 > fi
12240 >
12241 >  fi
12242 >
12243 >  CPU_FLAGS=""
12244 >  if test $ac_cv_prog_really_gcc = yes; then
12245 >                  case "${host_cpu}" in
12246 >          i586*)
12247 >
12248 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12249 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12250 > if test "${ac_cpu_pentium+set}" = set; then
12251 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12252 > else
12253 >  echo 'void f(){}' > conftest.c
12254 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12255 >        ac_cpu_pentium=yes
12256 > else
12257 >        ac_cpu_pentium=no
12258 > fi
12259 > rm -f conftest*
12260 >
12261 > fi
12262 > echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
12263 > echo "${ECHO_T}$ac_cpu_pentium" >&6
12264 > if test "$ac_cpu_pentium" = yes; then
12265 >        :
12266 >        CPU_FLAGS=-mcpu=pentium
12267 > else
12268 >        :
12269 >
12270 >
12271 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12272 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12273 > if test "${ac_pentium+set}" = set; then
12274 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12275 > else
12276 >  echo 'void f(){}' > conftest.c
12277 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12278 >        ac_pentium=yes
12279 > else
12280 >        ac_pentium=no
12281 > fi
12282 > rm -f conftest*
12283 >
12284 > fi
12285 > echo "$as_me:$LINENO: result: $ac_pentium" >&5
12286 > echo "${ECHO_T}$ac_pentium" >&6
12287 > if test "$ac_pentium" = yes; then
12288 >        :
12289 >        CPU_FLAGS=-mpentium
12290 > else
12291 >        :
12292 >
12293 > fi
12294 >
12295 > fi
12296 >
12297 >                  ;;
12298 >          i686*)
12299 >
12300 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12301 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12302 > if test "${ac_cpu_pentiumpro+set}" = set; then
12303 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12304 > else
12305 >  echo 'void f(){}' > conftest.c
12306 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12307 >        ac_cpu_pentiumpro=yes
12308 > else
12309 >        ac_cpu_pentiumpro=no
12310 > fi
12311 > rm -f conftest*
12312 >
12313 > fi
12314 > echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
12315 > echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
12316 > if test "$ac_cpu_pentiumpro" = yes; then
12317 >        :
12318 >        CPU_FLAGS=-mcpu=pentiumpro
12319 > else
12320 >        :
12321 >
12322 >
12323 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12324 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12325 > if test "${ac_pentiumpro+set}" = set; then
12326 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12327 > else
12328 >  echo 'void f(){}' > conftest.c
12329 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12330 >        ac_pentiumpro=yes
12331 > else
12332 >        ac_pentiumpro=no
12333 > fi
12334 > rm -f conftest*
12335 >
12336 > fi
12337 > echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
12338 > echo "${ECHO_T}$ac_pentiumpro" >&6
12339 > if test "$ac_pentiumpro" = yes; then
12340 >        :
12341 >        CPU_FLAGS=-mpentiumpro
12342 > else
12343 >        :
12344 >
12345 > fi
12346 >
12347 > fi
12348 >
12349 >                  ;;
12350 >          powerpc*)
12351 >                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
12352 >                is60x=`echo $cputype | egrep "^600-9e?$"`
12353 >                if test -n "$is60x"; then
12354 >
12355 >
12356 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12357 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12358 > if test "${ac_m_cpu_60x+set}" = set; then
12359 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12360 > else
12361 >  echo 'void f(){}' > conftest.c
12362 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12363 >        ac_m_cpu_60x=yes
12364 > else
12365 >        ac_m_cpu_60x=no
12366 > fi
12367 > rm -f conftest*
12368 >
12369 > fi
12370 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
12371 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
12372 > if test "$ac_m_cpu_60x" = yes; then
12373 >        :
12374 >        CPU_FLAGS=-mcpu=$cputype
12375 > else
12376 >        :
12377 >
12378 > fi
12379 >
12380 >                elif test "$cputype" = 750; then
12381 >
12382 >
12383 > echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
12384 > echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6
12385 > if test "${ac_cv_prog_gcc_2_95+set}" = set; then
12386 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12387 > else
12388 >
12389 > cat > conftest.c <<EOF
12390 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12391 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12392 >     yes;
12393 > #  endif
12394 > #endif
12395 > EOF
12396 > if { ac_try='${CC-cc} -E conftest.c'
12397 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12398 >  (eval $ac_try) 2>&5
12399 >  ac_status=$?
12400 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12401 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12402 >  ac_cv_prog_gcc_2_95=yes
12403 > else
12404 >  ac_cv_prog_gcc_2_95=no
12405 > fi
12406 >
12407 > fi
12408 > echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
12409 > echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6
12410 > if test "$ac_cv_prog_gcc_2_95" = yes; then
12411 >        :
12412 >
12413 >
12414 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12415 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12416 > if test "${ac_m_cpu_750+set}" = set; then
12417 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12418 > else
12419 >  echo 'void f(){}' > conftest.c
12420 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12421 >        ac_m_cpu_750=yes
12422 > else
12423 >        ac_m_cpu_750=no
12424 > fi
12425 > rm -f conftest*
12426 >
12427 > fi
12428 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12429 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12430 > if test "$ac_m_cpu_750" = yes; then
12431 >        :
12432 >        CPU_FLAGS=-mcpu=750
12433 > else
12434 >        :
12435 >
12436 > fi
12437 >
12438 > else
12439 >        :
12440 >
12441 > fi
12442 >
12443 >                fi
12444 >                if test -z "$CPU_FLAGS"; then
12445 >
12446 >
12447 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12448 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12449 > if test "${ac_m_cpu_powerpc+set}" = set; then
12450 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12451 > else
12452 >  echo 'void f(){}' > conftest.c
12453 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12454 >        ac_m_cpu_powerpc=yes
12455 > else
12456 >        ac_m_cpu_powerpc=no
12457 > fi
12458 > rm -f conftest*
12459 >
12460 > fi
12461 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12462 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12463 > if test "$ac_m_cpu_powerpc" = yes; then
12464 >        :
12465 >        CPU_FLAGS=-mcpu=powerpc
12466 > else
12467 >        :
12468 >
12469 > fi
12470 >
12471 >                fi
12472 >                if test -z "$CPU_FLAGS"; then
12473 >
12474 >
12475 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12476 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12477 > if test "${ac_m_powerpc+set}" = set; then
12478 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12479 > else
12480 >  echo 'void f(){}' > conftest.c
12481 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12482 >        ac_m_powerpc=yes
12483 > else
12484 >        ac_m_powerpc=no
12485 > fi
12486 > rm -f conftest*
12487 >
12488 > fi
12489 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12490 > echo "${ECHO_T}$ac_m_powerpc" >&6
12491 > if test "$ac_m_powerpc" = yes; then
12492 >        :
12493 >        CPU_FLAGS=-mpowerpc
12494 > else
12495 >        :
12496 >
12497 > fi
12498 >
12499 >                fi
12500 >          esac
12501 >  fi
12502 >
12503 >  if test -n "$CPU_FLAGS"; then
12504 >        CFLAGS="$CFLAGS $CPU_FLAGS"
12505 >  fi
12506 >
12507 >  if test -z "$CFLAGS"; then
12508 >        echo ""
12509 >        echo "********************************************************"
12510 >        echo "* WARNING: Don't know the best CFLAGS for this system  *"
12511 >        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
12512 >        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
12513 >        echo "********************************************************"
12514 >        echo ""
12515 >        CFLAGS="-O3"
12516 >  fi
12517 >
12518 >
12519 >
12520 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12521 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12522 > if test "${ac_guessed_cflags+set}" = set; then
12523 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12524 > else
12525 >  echo 'void f(){}' > conftest.c
12526 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12527 >        ac_guessed_cflags=yes
12528 > else
12529 >        ac_guessed_cflags=no
12530 > fi
12531 > rm -f conftest*
12532 >
12533 > fi
12534 > echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
12535 > echo "${ECHO_T}$ac_guessed_cflags" >&6
12536 > if test "$ac_guessed_cflags" = yes; then
12537 >        :
12538 >
12539 > else
12540 >        :
12541 >
12542 >        echo ""
12543 >        echo "********************************************************"
12544 >        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
12545 >        echo "* your compiler.                                       *"
12546 >        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
12547 >        echo "********************************************************"
12548 >        echo ""
12549 >        CFLAGS=""
12550 >
12551 > fi
12552 >
12553 >
12554 > fi
12555 >
12556 >
12557 >
12558 >
12559 >
12560 >
12561 >
12562 > echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
12563 > echo $ECHO_N "checking whether we are *really* using GNU c++... $ECHO_C" >&6
12564 > if test "${ac_cv_prog_really_gxx+set}" = set; then
12565 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12566 > else
12567 >
12568 > cat > conftest.cpp <<EOF
12569 > #ifdef __GNUC__
12570 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12571 >     no;
12572 >  #else
12573 >     yes;
12574 >  #endif
12575 > #endif
12576 > EOF
12577 > if { ac_try='${CXX-c++} -E conftest.cpp'
12578 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12579 >  (eval $ac_try) 2>&5
12580 >  ac_status=$?
12581 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12582 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12583 >  ac_cv_prog_really_gxx=yes
12584 > else
12585 >  ac_cv_prog_really_gxx=no
12586 > fi
12587 >
12588 > fi
12589 > echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
12590 > echo "${ECHO_T}$ac_cv_prog_really_gxx" >&6
12591 > if test "$ac_cv_prog_really_gxx" = yes; then
12592 >        :
12593 >
12594 > else
12595 >        :
12596 >
12597 > fi
12598 >
12599 >
12600 > # Try to determine "good" native compiler flags if none specified on command
12601 > # line
12602 > if test "$ac_test_CXXFLAGS" != "set"; then
12603 >  CXXFLAGS=""
12604 >  case "${host_cpu}-${host_os}" in
12605 >
12606 >  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
12607 >                    CXXFLAGS="-O"
12608 >                fi;;
12609 >  sparc-solaris2*) if test "$CXX" = CC; then
12610 >                    CXXFLAGS="-features=extensions -O -dalign"
12611 >                 fi;;
12612 >   rs6000*-aix*)  if test "$CXX" = xlC; then
12613 >                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12614 >                fi;;
12615 >   powerpc*-aix*)
12616 >        if test "$CXX" = xlC; then
12617 >                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
12618 >                echo "*******************************************************"
12619 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12620 >                echo "*  recommended that you use                           *"
12621 >                echo "*                                                     *"
12622 >                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12623 >                echo "*                                 ^^^                 *"
12624 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12625 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12626 >                echo "*******************************************************"
12627 >        fi;;
12628 >   *darwin*)
12629 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12630 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12631 >        fi
12632 >        if test "$CXX" = icpc; then
12633 >                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12634 >        fi;;
12635 >  esac
12636 >
12637 >  # use default flags for gcc on all systems
12638 >  if test $ac_cv_prog_really_gxx = yes; then
12639 >     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12640 >  fi
12641 >
12642 >  # test for gcc-specific flags:
12643 >  if test $ac_cv_prog_really_gxx = yes; then
12644 >    # -malign-double for x86 systems
12645 >
12646 >
12647 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12648 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12649 > if test "${ac_align_double+set}" = set; then
12650 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12651 > else
12652 >  echo 'void f(){}' > conftest.cpp
12653 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12654 >        ac_align_double=yes
12655 > else
12656 >        ac_align_double=no
12657 > fi
12658 > rm -f conftest*
12659 >
12660 > fi
12661 > echo "$as_me:$LINENO: result: $ac_align_double" >&5
12662 > echo "${ECHO_T}$ac_align_double" >&6
12663 > if test "$ac_align_double" = yes; then
12664 >        :
12665 >        CXXFLAGS="$CXXFLAGS -malign-double"
12666 > else
12667 >        :
12668 >
12669 > fi
12670 >
12671 >    # -fstrict-aliasing for gcc-2.95+
12672 >
12673 >
12674 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12675 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12676 > if test "${ac_fstrict_aliasing+set}" = set; then
12677 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12678 > else
12679 >  echo 'void f(){}' > conftest.cpp
12680 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12681 >        ac_fstrict_aliasing=yes
12682 > else
12683 >        ac_fstrict_aliasing=no
12684 > fi
12685 > rm -f conftest*
12686 >
12687 > fi
12688 > echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
12689 > echo "${ECHO_T}$ac_fstrict_aliasing" >&6
12690 > if test "$ac_fstrict_aliasing" = yes; then
12691 >        :
12692 >        CXXFLAGS="$CXXFLAGS -fstrict-aliasing"
12693 > else
12694 >        :
12695 >
12696 > fi
12697 >
12698 >  fi
12699 >
12700 >  CPU_FLAGS=""
12701 >  if test $ac_cv_prog_really_gxx = yes; then
12702 >                  case "${host_cpu}" in
12703 >          i586*)
12704 >
12705 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12706 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12707 > if test "${ac_cpu_pentium+set}" = set; then
12708 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12709 > else
12710 >  echo 'void f(){}' > conftest.cpp
12711 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12712 >        ac_cpu_pentium=yes
12713 > else
12714 >        ac_cpu_pentium=no
12715 > fi
12716 > rm -f conftest*
12717 >
12718 > fi
12719 > echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
12720 > echo "${ECHO_T}$ac_cpu_pentium" >&6
12721 > if test "$ac_cpu_pentium" = yes; then
12722 >        :
12723 >        CPU_FLAGS=-mcpu=pentium
12724 > else
12725 >        :
12726 >
12727 >
12728 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12729 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12730 > if test "${ac_pentium+set}" = set; then
12731 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12732 > else
12733 >  echo 'void f(){}' > conftest.cpp
12734 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12735 >        ac_pentium=yes
12736 > else
12737 >        ac_pentium=no
12738 > fi
12739 > rm -f conftest*
12740 >
12741 > fi
12742 > echo "$as_me:$LINENO: result: $ac_pentium" >&5
12743 > echo "${ECHO_T}$ac_pentium" >&6
12744 > if test "$ac_pentium" = yes; then
12745 >        :
12746 >        CPU_FLAGS=-mpentium
12747 > else
12748 >        :
12749 >
12750 > fi
12751 >
12752 > fi
12753 >
12754 >                  ;;
12755 >          i686*)
12756 >
12757 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12758 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12759 > if test "${ac_cpu_pentiumpro+set}" = set; then
12760 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12761 > else
12762 >  echo 'void f(){}' > conftest.cpp
12763 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12764 >        ac_cpu_pentiumpro=yes
12765 > else
12766 >        ac_cpu_pentiumpro=no
12767 > fi
12768 > rm -f conftest*
12769 >
12770 > fi
12771 > echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
12772 > echo "${ECHO_T}$ac_cpu_pentiumpro" >&6
12773 > if test "$ac_cpu_pentiumpro" = yes; then
12774 >        :
12775 >        CPU_FLAGS=-mcpu=pentiumpro
12776 > else
12777 >        :
12778 >
12779 >
12780 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12781 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12782 > if test "${ac_pentiumpro+set}" = set; then
12783 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12784 > else
12785 >  echo 'void f(){}' > conftest.cpp
12786 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12787 >        ac_pentiumpro=yes
12788 > else
12789 >        ac_pentiumpro=no
12790 > fi
12791 > rm -f conftest*
12792 >
12793 > fi
12794 > echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
12795 > echo "${ECHO_T}$ac_pentiumpro" >&6
12796 > if test "$ac_pentiumpro" = yes; then
12797 >        :
12798 >        CPU_FLAGS=-mpentiumpro
12799 > else
12800 >        :
12801 >
12802 > fi
12803 >
12804 > fi
12805 >
12806 >                  ;;
12807 >          powerpc*)
12808 >                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
12809 >                is60x=`echo $cputype | egrep "^600-9e?$"`
12810 >                if test -n "$is60x"; then
12811 >
12812 >
12813 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12814 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12815 > if test "${ac_m_cpu_60x+set}" = set; then
12816 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12817 > else
12818 >  echo 'void f(){}' > conftest.cpp
12819 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12820 >        ac_m_cpu_60x=yes
12821 > else
12822 >        ac_m_cpu_60x=no
12823 > fi
12824 > rm -f conftest*
12825 >
12826 > fi
12827 > echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
12828 > echo "${ECHO_T}$ac_m_cpu_60x" >&6
12829 > if test "$ac_m_cpu_60x" = yes; then
12830 >        :
12831 >        CPU_FLAGS=-mcpu=$cputype
12832 > else
12833 >        :
12834 >
12835 > fi
12836 >
12837 >                elif test "$cputype" = 750; then
12838 >
12839 >
12840 > echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
12841 > echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6
12842 > if test "${ac_cv_prog_gxx_2_95+set}" = set; then
12843 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12844 > else
12845 >
12846 > cat > conftest.cpp <<EOF
12847 > #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
12848 > #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
12849 >     yes;
12850 > #  endif
12851 > #endif
12852 > EOF
12853 > if { ac_try='${CXX-c++} -E conftest.cpp'
12854 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12855 >  (eval $ac_try) 2>&5
12856 >  ac_status=$?
12857 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12858 >  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12859 >  ac_cv_prog_gxx_2_95=yes
12860 > else
12861 >  ac_cv_prog_gxx_2_95=no
12862 > fi
12863 >
12864 > fi
12865 > echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
12866 > echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6
12867 > if test "$ac_cv_prog_gxx_2_95" = yes; then
12868 >        :
12869 >
12870 >
12871 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12872 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12873 > if test "${ac_m_cpu_750+set}" = set; then
12874 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12875 > else
12876 >  echo 'void f(){}' > conftest.cpp
12877 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12878 >        ac_m_cpu_750=yes
12879 > else
12880 >        ac_m_cpu_750=no
12881 > fi
12882 > rm -f conftest*
12883 >
12884 > fi
12885 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
12886 > echo "${ECHO_T}$ac_m_cpu_750" >&6
12887 > if test "$ac_m_cpu_750" = yes; then
12888 >        :
12889 >        CPU_FLAGS=-mcpu=750
12890 > else
12891 >        :
12892 >
12893 > fi
12894 >
12895 > else
12896 >        :
12897 >
12898 > fi
12899 >
12900 >                fi
12901 >                if test -z "$CPU_FLAGS"; then
12902 >
12903 >
12904 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12905 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12906 > if test "${ac_m_cpu_powerpc+set}" = set; then
12907 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12908 > else
12909 >  echo 'void f(){}' > conftest.cpp
12910 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12911 >        ac_m_cpu_powerpc=yes
12912 > else
12913 >        ac_m_cpu_powerpc=no
12914 > fi
12915 > rm -f conftest*
12916 >
12917 > fi
12918 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12919 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12920 > if test "$ac_m_cpu_powerpc" = yes; then
12921 >        :
12922 >        CPU_FLAGS=-mcpu=powerpc
12923 > else
12924 >        :
12925 >
12926 > fi
12927 >
12928 >                fi
12929 >                if test -z "$CPU_FLAGS"; then
12930 >
12931 >
12932 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12933 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12934 > if test "${ac_m_powerpc+set}" = set; then
12935 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12936 > else
12937 >  echo 'void f(){}' > conftest.cpp
12938 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12939 >        ac_m_powerpc=yes
12940 > else
12941 >        ac_m_powerpc=no
12942 > fi
12943 > rm -f conftest*
12944 >
12945 > fi
12946 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12947 > echo "${ECHO_T}$ac_m_powerpc" >&6
12948 > if test "$ac_m_powerpc" = yes; then
12949 >        :
12950 >        CPU_FLAGS=-mpowerpc
12951 > else
12952 >        :
12953 >
12954 > fi
12955 >
12956 >                fi
12957 >          esac
12958 >  fi
12959 >
12960 >  if test -n "$CPU_FLAGS"; then
12961 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12962 >  fi
12963 >
12964 >  if test -z "$CXXFLAGS"; then
12965 >        echo ""
12966 >        echo "**********************************************************"
12967 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12968 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12969 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12970 >        echo "**********************************************************"
12971 >        echo ""
12972 >        CXXFLAGS="-O3"
12973 >  fi
12974 >
12975 >
12976 >
12977 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12978 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12979 > if test "${ac_guessed_cxxflags+set}" = set; then
12980 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12981 > else
12982 >  echo 'void f(){}' > conftest.cpp
12983 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12984 >        ac_guessed_cxxflags=yes
12985 > else
12986 >        ac_guessed_cxxflags=no
12987 > fi
12988 > rm -f conftest*
12989 >
12990 > fi
12991 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12992 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12993 > if test "$ac_guessed_cxxflags" = yes; then
12994 >        :
12995 >
12996 > else
12997 >        :
12998 >
12999 >        echo ""
13000 >        echo "**********************************************************"
13001 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
13002 >        echo "* your compiler.                                         *"
13003 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13004 >        echo "**********************************************************"
13005 >        echo ""
13006 >        CXXFLAGS=""
13007 >
13008 > fi
13009 >
13010 >
13011 > fi
13012 >
13013 >     ;;
13014 > esac
13015 >
13016 >
13017 > cat >>confdefs.h <<\_ACEOF
13018 > #define OBAPI
13019 > _ACEOF
13020 >
13021 >
13022 >
13023 >
13024 > # Check whether --with-mpi or --without-mpi was given.
13025 > if test "${with_mpi+set}" = set; then
13026 >  withval="$with_mpi"
13027 >  with_mpi=$withval
13028 > else
13029 >  with_mpi="no"
13030 > fi;
13031 >
13032 > case "x$with_mpi" in
13033 >        xyes | "x")  USE_MPI=yes;;
13034 >        xno) USE_MPI=no ;;
13035 >        *) MPI="$with_mpi"; USE_MPI=yes ;;
13036 > esac
13037 > if test "$USE_MPI" = "yes" -a -z "$with_mpi"; then
13038 >        MPI="/usr/local"
13039 > fi
13040 > if test "$USE_MPI" = "yes"; then
13041 >
13042 >
13043 > # Set variables...
13044 > MPI_LIB_DIR="$MPI/lib"
13045 > MPI_INC_DIR="$MPI/include"
13046 >
13047 >
13048 >
13049 > ac_ext=c
13050 > ac_cpp='$CPP $CPPFLAGS'
13051 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13052 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13053 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
13054 >
13055 > echo "$as_me:$LINENO: checking for mpi.h" >&5
13056 > echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13057 > have_mpi_h=0
13058 > rm -f conftest*
13059 > echo '#include <mpi.h>' > conftest.c
13060 > if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13061 >        echo "$as_me:$LINENO: result: yes" >&5
13062 > echo "${ECHO_T}yes" >&6
13063 >        have_mpi_h=1
13064 > else
13065 >        if test -s conftest.out ; then
13066 >                cat conftest.out >> config.log
13067 >        fi
13068 >        echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13069 > echo "${ECHO_T}no! Check MPI include paths" >&6
13070 >        USE_MPI="no"
13071 > fi
13072 > rm -f conftest*
13073 > if test "$have_mpi_h" = 1; then
13074 >
13075 > cat >>confdefs.h <<\_ACEOF
13076 > #define HAVE_MPI_H 1
13077 > _ACEOF
13078 >
13079 > fi
13080 >
13081 > echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13082 > echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13083 >
13084 >
13085 > ac_ext=${FC_SRCEXT-f}
13086 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13087 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13088 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13089 >
13090 > ac_save_ext=$ac_ext
13091 > ac_ext=F90
13092 > ac_save_FCFLAGS=$FCFLAGS
13093 > have_mpif_h=0
13094 > rm -f conftest*
13095 > cat >conftest.$ac_ext <<EOF
13096 > program main
13097 >   include 'mpif.h'
13098 > end
13099 > EOF
13100 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13101 >        echo "$as_me:$LINENO: result: yes" >&5
13102 > echo "${ECHO_T}yes" >&6
13103 >        MPI_F90_INC="$MPI_INC_DIR"
13104 >        have_mpif_h=1
13105 > else
13106 >        if test -s conftest.out ; then
13107 >                cat conftest.out >> config.log
13108 >        fi
13109 >        echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13110 > echo "${ECHO_T}no! Check MPI include paths" >&6
13111 >        USE_MPI="no"
13112 > fi
13113 > rm -f conftest*
13114 >
13115 > if test "$have_mpif_h" = 1; then
13116  
13117 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
13118 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6732 < LN_S=$as_ln_s
6733 < if test "$LN_S" = "ln -s"; then
6734 <  echo "$as_me:$LINENO: result: yes" >&5
6735 < echo "${ECHO_T}yes" >&6
6736 < else
6737 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6738 < echo "${ECHO_T}no, using $LN_S" >&6
6739 < fi
6740 <
6741 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6742 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6743 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6744 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6745 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6746 < else
6747 <  cat >conftest.make <<\_ACEOF
6748 < all:
6749 <        @echo 'ac_maketemp="$(MAKE)"'
13117 > cat >>confdefs.h <<\_ACEOF
13118 > #define HAVE_MPIF_H 1
13119   _ACEOF
13120 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6752 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6753 < if test -n "$ac_maketemp"; then
6754 <  eval ac_cv_prog_make_${ac_make}_set=yes
6755 < else
6756 <  eval ac_cv_prog_make_${ac_make}_set=no
13120 >
13121   fi
13122 < rm -f conftest.make
13123 < fi
13124 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
13125 <  echo "$as_me:$LINENO: result: yes" >&5
13126 < echo "${ECHO_T}yes" >&6
13127 <  SET_MAKE=
13128 < else
6765 <  echo "$as_me:$LINENO: result: no" >&5
6766 < echo "${ECHO_T}no" >&6
6767 <  SET_MAKE="MAKE=${MAKE-make}"
6768 < fi
13122 > FCFLAGS=$ac_save_FCFLAGS
13123 > ac_ext=$ac_save_ext
13124 > ac_ext=c
13125 > ac_cpp='$CPP $CPPFLAGS'
13126 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13127 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13128 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
13129  
6770 – if test -n "$ac_tool_prefix"; then
6771 –  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6772 – set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6773 – echo "$as_me:$LINENO: checking for $ac_word" >&5
6774 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6775 – if test "${ac_cv_prog_RANLIB+set}" = set; then
6776 –  echo $ECHO_N "(cached) $ECHO_C" >&6
6777 – else
6778 –  if test -n "$RANLIB"; then
6779 –  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6780 – else
6781 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6782 – for as_dir in $PATH
6783 – do
6784 –  IFS=$as_save_IFS
6785 –  test -z "$as_dir" && as_dir=.
6786 –  for ac_exec_ext in '' $ac_executable_extensions; do
6787 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6788 –    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6789 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6790 –    break 2
6791 –  fi
6792 – done
6793 – done
13130  
13131 < fi
13132 < fi
13133 < RANLIB=$ac_cv_prog_RANLIB
13134 < if test -n "$RANLIB"; then
13135 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6800 < echo "${ECHO_T}$RANLIB" >&6
6801 < else
6802 <  echo "$as_me:$LINENO: result: no" >&5
6803 < echo "${ECHO_T}no" >&6
6804 < fi
13131 > ac_ext=c
13132 > ac_cpp='$CPP $CPPFLAGS'
13133 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13134 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13135 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
13136  
13137 < fi
13138 < if test -z "$ac_cv_prog_RANLIB"; then
13139 <  ac_ct_RANLIB=$RANLIB
13140 <  # Extract the first word of "ranlib", so it can be a program name with args.
13141 < set dummy ranlib; ac_word=$2
13142 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13143 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6813 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
13137 > ac_save_LDFLAGS=$LDFLAGS
13138 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13139 >
13140 > if test x = x"$MPI_LIB"; then
13141 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13142 > echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13143 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13144    echo $ECHO_N "(cached) $ECHO_C" >&6
13145   else
13146 <  if test -n "$ac_ct_RANLIB"; then
13147 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
13146 >  ac_check_lib_save_LIBS=$LIBS
13147 > LIBS="-lmpich  $LIBS"
13148 > cat >conftest.$ac_ext <<_ACEOF
13149 > /* confdefs.h.  */
13150 > _ACEOF
13151 > cat confdefs.h >>conftest.$ac_ext
13152 > cat >>conftest.$ac_ext <<_ACEOF
13153 > /* end confdefs.h.  */
13154 >
13155 > /* Override any gcc2 internal prototype to avoid an error.  */
13156 > #ifdef __cplusplus
13157 > extern "C"
13158 > #endif
13159 > /* We use char because int might match the return type of a gcc2
13160 >   builtin and then its argument prototype would still apply.  */
13161 > char MPI_Init ();
13162 > #ifdef FC_DUMMY_MAIN
13163 > #ifndef FC_DUMMY_MAIN_EQ_F77
13164 > #  ifdef __cplusplus
13165 >     extern "C"
13166 > #  endif
13167 >   int FC_DUMMY_MAIN() { return 1; }
13168 > #endif
13169 > #endif
13170 > int
13171 > main ()
13172 > {
13173 > MPI_Init ();
13174 >  ;
13175 >  return 0;
13176 > }
13177 > _ACEOF
13178 > rm -f conftest.$ac_objext conftest$ac_exeext
13179 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13180 >  (eval $ac_link) 2>conftest.er1
13181 >  ac_status=$?
13182 >  grep -v '^ *+' conftest.er1 >conftest.err
13183 >  rm -f conftest.er1
13184 >  cat conftest.err >&5
13185 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13186 >  (exit $ac_status); } &&
13187 >         { ac_try='test -z "$ac_c_werror_flag"
13188 >                         || test ! -s conftest.err'
13189 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13190 >  (eval $ac_try) 2>&5
13191 >  ac_status=$?
13192 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13193 >  (exit $ac_status); }; } &&
13194 >         { ac_try='test -s conftest$ac_exeext'
13195 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13196 >  (eval $ac_try) 2>&5
13197 >  ac_status=$?
13198 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13199 >  (exit $ac_status); }; }; then
13200 >  ac_cv_lib_mpich_MPI_Init=yes
13201   else
13202 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13203 < for as_dir in $PATH
6821 < do
6822 <  IFS=$as_save_IFS
6823 <  test -z "$as_dir" && as_dir=.
6824 <  for ac_exec_ext in '' $ac_executable_extensions; do
6825 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6826 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6827 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6828 <    break 2
6829 <  fi
6830 < done
6831 < done
13202 >  echo "$as_me: failed program was:" >&5
13203 > sed 's/^/| /' conftest.$ac_ext >&5
13204  
13205 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
13205 > ac_cv_lib_mpich_MPI_Init=no
13206   fi
13207 + rm -f conftest.err conftest.$ac_objext \
13208 +      conftest$ac_exeext conftest.$ac_ext
13209 + LIBS=$ac_check_lib_save_LIBS
13210   fi
13211 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
13212 < if test -n "$ac_ct_RANLIB"; then
13213 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
13214 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6840 < else
6841 <  echo "$as_me:$LINENO: result: no" >&5
6842 < echo "${ECHO_T}no" >&6
13211 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13212 > echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13213 > if test $ac_cv_lib_mpich_MPI_Init = yes; then
13214 >  MPI_LIB="-lmpich"
13215   fi
13216  
6845 –  RANLIB=$ac_ct_RANLIB
6846 – else
6847 –  RANLIB="$ac_cv_prog_RANLIB"
13217   fi
13218 <
13219 < for ac_prog in 'bison -y' byacc
13220 < do
13221 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13222 < set dummy $ac_prog; ac_word=$2
6854 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6855 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6856 < if test "${ac_cv_prog_YACC+set}" = set; then
13218 > $as_unset ac_cv_lib_mpich_MPI_Init
13219 > if test x = x"$MPI_LIB"; then
13220 >        echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13221 > echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13222 > if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13223    echo $ECHO_N "(cached) $ECHO_C" >&6
13224   else
13225 <  if test -n "$YACC"; then
13226 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
13225 >  ac_check_lib_save_LIBS=$LIBS
13226 > LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13227 > cat >conftest.$ac_ext <<_ACEOF
13228 > /* confdefs.h.  */
13229 > _ACEOF
13230 > cat confdefs.h >>conftest.$ac_ext
13231 > cat >>conftest.$ac_ext <<_ACEOF
13232 > /* end confdefs.h.  */
13233 >
13234 > /* Override any gcc2 internal prototype to avoid an error.  */
13235 > #ifdef __cplusplus
13236 > extern "C"
13237 > #endif
13238 > /* We use char because int might match the return type of a gcc2
13239 >   builtin and then its argument prototype would still apply.  */
13240 > char MPI_Init ();
13241 > #ifdef FC_DUMMY_MAIN
13242 > #ifndef FC_DUMMY_MAIN_EQ_F77
13243 > #  ifdef __cplusplus
13244 >     extern "C"
13245 > #  endif
13246 >   int FC_DUMMY_MAIN() { return 1; }
13247 > #endif
13248 > #endif
13249 > int
13250 > main ()
13251 > {
13252 > MPI_Init ();
13253 >  ;
13254 >  return 0;
13255 > }
13256 > _ACEOF
13257 > rm -f conftest.$ac_objext conftest$ac_exeext
13258 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13259 >  (eval $ac_link) 2>conftest.er1
13260 >  ac_status=$?
13261 >  grep -v '^ *+' conftest.er1 >conftest.err
13262 >  rm -f conftest.er1
13263 >  cat conftest.err >&5
13264 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13265 >  (exit $ac_status); } &&
13266 >         { ac_try='test -z "$ac_c_werror_flag"
13267 >                         || test ! -s conftest.err'
13268 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13269 >  (eval $ac_try) 2>&5
13270 >  ac_status=$?
13271 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13272 >  (exit $ac_status); }; } &&
13273 >         { ac_try='test -s conftest$ac_exeext'
13274 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13275 >  (eval $ac_try) 2>&5
13276 >  ac_status=$?
13277 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13278 >  (exit $ac_status); }; }; then
13279 >  ac_cv_lib_pmpich_MPI_Init=yes
13280   else
13281 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13282 < for as_dir in $PATH
6864 < do
6865 <  IFS=$as_save_IFS
6866 <  test -z "$as_dir" && as_dir=.
6867 <  for ac_exec_ext in '' $ac_executable_extensions; do
6868 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6869 <    ac_cv_prog_YACC="$ac_prog"
6870 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6871 <    break 2
6872 <  fi
6873 < done
6874 < done
13281 >  echo "$as_me: failed program was:" >&5
13282 > sed 's/^/| /' conftest.$ac_ext >&5
13283  
13284 + ac_cv_lib_pmpich_MPI_Init=no
13285   fi
13286 + rm -f conftest.err conftest.$ac_objext \
13287 +      conftest$ac_exeext conftest.$ac_ext
13288 + LIBS=$ac_check_lib_save_LIBS
13289   fi
13290 < YACC=$ac_cv_prog_YACC
13291 < if test -n "$YACC"; then
13292 <  echo "$as_me:$LINENO: result: $YACC" >&5
13293 < echo "${ECHO_T}$YACC" >&6
6882 < else
6883 <  echo "$as_me:$LINENO: result: no" >&5
6884 < echo "${ECHO_T}no" >&6
13290 > echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13291 > echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13292 > if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13293 >  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13294   fi
13295  
6887 –  test -n "$YACC" && break
6888 – done
6889 – test -n "$YACC" || YACC="yacc"
6890 –
6891 – for ac_prog in flex lex
6892 – do
6893 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
6894 – set dummy $ac_prog; ac_word=$2
6895 – echo "$as_me:$LINENO: checking for $ac_word" >&5
6896 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6897 – if test "${ac_cv_prog_LEX+set}" = set; then
6898 –  echo $ECHO_N "(cached) $ECHO_C" >&6
6899 – else
6900 –  if test -n "$LEX"; then
6901 –  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6902 – else
6903 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6904 – for as_dir in $PATH
6905 – do
6906 –  IFS=$as_save_IFS
6907 –  test -z "$as_dir" && as_dir=.
6908 –  for ac_exec_ext in '' $ac_executable_extensions; do
6909 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6910 –    ac_cv_prog_LEX="$ac_prog"
6911 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6912 –    break 2
6913 –  fi
6914 – done
6915 – done
6916 –
13296   fi
13297 < fi
13298 < LEX=$ac_cv_prog_LEX
13299 < if test -n "$LEX"; then
13300 <  echo "$as_me:$LINENO: result: $LEX" >&5
6922 < echo "${ECHO_T}$LEX" >&6
6923 < else
6924 <  echo "$as_me:$LINENO: result: no" >&5
6925 < echo "${ECHO_T}no" >&6
6926 < fi
6927 <
6928 <  test -n "$LEX" && break
6929 < done
6930 < test -n "$LEX" || LEX=":"
6931 <
6932 < if test -z "$LEXLIB"
6933 < then
6934 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6935 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6936 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
13297 > if test x = x"$MPI_LIB"; then
13298 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13299 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13300 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13301    echo $ECHO_N "(cached) $ECHO_C" >&6
13302   else
13303    ac_check_lib_save_LIBS=$LIBS
13304 < LIBS="-lfl  $LIBS"
13304 > LIBS="-lmpi  $LIBS"
13305   cat >conftest.$ac_ext <<_ACEOF
13306   /* confdefs.h.  */
13307   _ACEOF
# Line 6951 | Line 13315 | extern "C"
13315   #endif
13316   /* We use char because int might match the return type of a gcc2
13317     builtin and then its argument prototype would still apply.  */
13318 < char yywrap ();
13318 > char MPI_Init ();
13319 > #ifdef FC_DUMMY_MAIN
13320 > #ifndef FC_DUMMY_MAIN_EQ_F77
13321 > #  ifdef __cplusplus
13322 >     extern "C"
13323 > #  endif
13324 >   int FC_DUMMY_MAIN() { return 1; }
13325 > #endif
13326 > #endif
13327   int
13328   main ()
13329   {
13330 < yywrap ();
13330 > MPI_Init ();
13331    ;
13332    return 0;
13333   }
# Line 6982 | Line 13354 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13354    ac_status=$?
13355    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13356    (exit $ac_status); }; }; then
13357 <  ac_cv_lib_fl_yywrap=yes
13357 >  ac_cv_lib_mpi_MPI_Init=yes
13358   else
13359    echo "$as_me: failed program was:" >&5
13360   sed 's/^/| /' conftest.$ac_ext >&5
13361  
13362 < ac_cv_lib_fl_yywrap=no
13362 > ac_cv_lib_mpi_MPI_Init=no
13363   fi
13364   rm -f conftest.err conftest.$ac_objext \
13365        conftest$ac_exeext conftest.$ac_ext
13366   LIBS=$ac_check_lib_save_LIBS
13367   fi
13368 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
13369 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
13370 < if test $ac_cv_lib_fl_yywrap = yes; then
13371 <  LEXLIB="-lfl"
13372 < else
13373 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
13374 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
13375 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
13368 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13369 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13370 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13371 >  MPI_LIB="-lmpi"
13372 > fi
13373 >
13374 > fi
13375 > $as_unset ac_cv_lib_mpi_MPI_Init
13376 > if test x = x"$MPI_LIB"; then
13377 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13378 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13379 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13380    echo $ECHO_N "(cached) $ECHO_C" >&6
13381   else
13382    ac_check_lib_save_LIBS=$LIBS
13383 < LIBS="-ll  $LIBS"
13383 > LIBS="-lmpi -llam $LIBS"
13384   cat >conftest.$ac_ext <<_ACEOF
13385   /* confdefs.h.  */
13386   _ACEOF
# Line 7018 | Line 13394 | extern "C"
13394   #endif
13395   /* We use char because int might match the return type of a gcc2
13396     builtin and then its argument prototype would still apply.  */
13397 < char yywrap ();
13397 > char MPI_Init ();
13398 > #ifdef FC_DUMMY_MAIN
13399 > #ifndef FC_DUMMY_MAIN_EQ_F77
13400 > #  ifdef __cplusplus
13401 >     extern "C"
13402 > #  endif
13403 >   int FC_DUMMY_MAIN() { return 1; }
13404 > #endif
13405 > #endif
13406   int
13407   main ()
13408   {
13409 < yywrap ();
13409 > MPI_Init ();
13410    ;
13411    return 0;
13412   }
# Line 7049 | Line 13433 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13433    ac_status=$?
13434    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13435    (exit $ac_status); }; }; then
13436 <  ac_cv_lib_l_yywrap=yes
13436 >  ac_cv_lib_mpi_MPI_Init=yes
13437   else
13438    echo "$as_me: failed program was:" >&5
13439   sed 's/^/| /' conftest.$ac_ext >&5
13440  
13441 < ac_cv_lib_l_yywrap=no
13441 > ac_cv_lib_mpi_MPI_Init=no
13442   fi
13443   rm -f conftest.err conftest.$ac_objext \
13444        conftest$ac_exeext conftest.$ac_ext
13445   LIBS=$ac_check_lib_save_LIBS
13446   fi
13447 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
13448 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
13449 < if test $ac_cv_lib_l_yywrap = yes; then
13450 <  LEXLIB="-ll"
13447 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13448 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13449 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13450 >  MPI_LIB="-lmpi -llam"
13451   fi
13452  
13453   fi
13454 <
13455 < fi
13456 <
13457 < if test "x$LEX" != "x:"; then
13458 <  echo "$as_me:$LINENO: checking lex output file root" >&5
7075 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
7076 < if test "${ac_cv_prog_lex_root+set}" = set; then
13454 > $as_unset ac_cv_lib_mpi_MPI_Init
13455 > if test x = x"$MPI_LIB"; then
13456 > echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13457 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13458 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13459    echo $ECHO_N "(cached) $ECHO_C" >&6
13460   else
13461 <  # The minimal lex program is just a single line: %%.  But some broken lexes
13462 < # (Solaris, I think it was) want two %% lines, so accommodate them.
13463 < cat >conftest.l <<_ACEOF
13464 < %%
7083 < %%
13461 >  ac_check_lib_save_LIBS=$LIBS
13462 > LIBS="-lmpi -llam -lpthread $LIBS"
13463 > cat >conftest.$ac_ext <<_ACEOF
13464 > /* confdefs.h.  */
13465   _ACEOF
13466 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
13467 <  (eval $LEX conftest.l) 2>&5
13468 <  ac_status=$?
7088 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7089 <  (exit $ac_status); }
7090 < if test -f lex.yy.c; then
7091 <  ac_cv_prog_lex_root=lex.yy
7092 < elif test -f lexyy.c; then
7093 <  ac_cv_prog_lex_root=lexyy
7094 < else
7095 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7096 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7097 <   { (exit 1); exit 1; }; }
7098 < fi
7099 < fi
7100 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7101 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7102 < rm -f conftest.l
7103 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13466 > cat confdefs.h >>conftest.$ac_ext
13467 > cat >>conftest.$ac_ext <<_ACEOF
13468 > /* end confdefs.h.  */
13469  
13470 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
13471 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
13472 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
13473 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13474 < else
13475 <  # POSIX says lex can declare yytext either as a pointer or an array; the
13476 < # default is implementation-dependent. Figure out which it is, since
13477 < # not all implementations provide the %pointer and %array declarations.
13478 < ac_cv_prog_lex_yytext_pointer=no
13479 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
13480 < ac_save_LIBS=$LIBS
13481 < LIBS="$LIBS $LEXLIB"
13482 < cat >conftest.$ac_ext <<_ACEOF
13483 < `cat $LEX_OUTPUT_ROOT.c`
13470 > /* Override any gcc2 internal prototype to avoid an error.  */
13471 > #ifdef __cplusplus
13472 > extern "C"
13473 > #endif
13474 > /* We use char because int might match the return type of a gcc2
13475 >   builtin and then its argument prototype would still apply.  */
13476 > char MPI_Init ();
13477 > #ifdef FC_DUMMY_MAIN
13478 > #ifndef FC_DUMMY_MAIN_EQ_F77
13479 > #  ifdef __cplusplus
13480 >     extern "C"
13481 > #  endif
13482 >   int FC_DUMMY_MAIN() { return 1; }
13483 > #endif
13484 > #endif
13485 > int
13486 > main ()
13487 > {
13488 > MPI_Init ();
13489 >  ;
13490 >  return 0;
13491 > }
13492   _ACEOF
13493   rm -f conftest.$ac_objext conftest$ac_exeext
13494   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
# Line 7139 | Line 13512 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13512    ac_status=$?
13513    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13514    (exit $ac_status); }; }; then
13515 <  ac_cv_prog_lex_yytext_pointer=yes
13515 >  ac_cv_lib_mpi_MPI_Init=yes
13516   else
13517    echo "$as_me: failed program was:" >&5
13518   sed 's/^/| /' conftest.$ac_ext >&5
13519  
13520 + ac_cv_lib_mpi_MPI_Init=no
13521   fi
13522   rm -f conftest.err conftest.$ac_objext \
13523        conftest$ac_exeext conftest.$ac_ext
13524 < LIBS=$ac_save_LIBS
7151 < rm -f "${LEX_OUTPUT_ROOT}.c"
7152 <
13524 > LIBS=$ac_check_lib_save_LIBS
13525   fi
13526 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
13527 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
13528 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
13526 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13527 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13528 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13529 >  MPI_LIB="-lmpi -llam -lpthread"
13530 > else
13531  
13532 < cat >>confdefs.h <<\_ACEOF
13533 < #define YYTEXT_POINTER 1
13534 < _ACEOF
13532 >             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
13533 > echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
13534 >   { (exit 1); exit 1; }; }
13535 >             USE_MPI="no"
13536  
13537   fi
13538  
13539   fi
7165 – # Extract the first word of "ar", so it can be a program name with args.
7166 – set dummy ar; ac_word=$2
7167 – echo "$as_me:$LINENO: checking for $ac_word" >&5
7168 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7169 – if test "${ac_cv_prog_AR+set}" = set; then
7170 –  echo $ECHO_N "(cached) $ECHO_C" >&6
7171 – else
7172 –  if test -n "$AR"; then
7173 –  ac_cv_prog_AR="$AR" # Let the user override the test.
7174 – else
7175 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7176 – for as_dir in $PATH
7177 – do
7178 –  IFS=$as_save_IFS
7179 –  test -z "$as_dir" && as_dir=.
7180 –  for ac_exec_ext in '' $ac_executable_extensions; do
7181 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7182 –    ac_cv_prog_AR="ar"
7183 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7184 –    break 2
7185 –  fi
7186 – done
7187 – done
13540  
7189 –  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
7190 – fi
7191 – fi
7192 – AR=$ac_cv_prog_AR
7193 – if test -n "$AR"; then
7194 –  echo "$as_me:$LINENO: result: $AR" >&5
7195 – echo "${ECHO_T}$AR" >&6
7196 – else
7197 –  echo "$as_me:$LINENO: result: no" >&5
7198 – echo "${ECHO_T}no" >&6
7199 – fi
13541  
7201 – if test "$AR" = "NONE"; then
7202 –  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
7203 – echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7204 –   { (exit 1); exit 1; }; }
7205 –  cat >confcache <<\_ACEOF
7206 – # This file is a shell script that caches the results of configure
7207 – # tests run on this system so they can be shared between configure
7208 – # scripts and configure runs, see configure's option --config-cache.
7209 – # It is not useful on other systems.  If it contains results you don't
7210 – # want to keep, you may remove or edit it.
7211 – #
7212 – # config.status only pays attention to the cache file if you give it
7213 – # the --recheck option to rerun configure.
7214 – #
7215 – # `ac_cv_env_foo' variables (set or unset) will be overridden when
7216 – # loading this file, other *unset* `ac_cv_foo' will be assigned the
7217 – # following values.
13542  
13543 < _ACEOF
13544 <
13545 < # The following way of writing the cache mishandles newlines in values,
13546 < # but we know of no workaround that is simple, portable, and efficient.
13547 < # So, don't put newlines in cache variables' values.
13548 < # Ultrix sh set writes to stderr and can't be redirected directly,
13549 < # and sets the high bit in the cache file unless we assign to the vars.
7226 < {
7227 <  (set) 2>&1 |
7228 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
7229 <    *ac_space=\ *)
7230 <      # `set' does not quote correctly, so add quotes (double-quote
7231 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7232 <      sed -n \
7233 <        "s/'/'\\\\''/g;
7234 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7235 <      ;;
7236 <    *)
7237 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
7238 <      sed -n \
7239 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7240 <      ;;
7241 <    esac;
7242 < } |
7243 <  sed '
7244 <     t clear
7245 <     : clear
7246 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7247 <     t end
7248 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7249 <     : end' >>confcache
7250 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
7251 <  if test -w $cache_file; then
7252 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7253 <    cat confcache >$cache_file
7254 <  else
7255 <    echo "not updating unwritable cache $cache_file"
7256 <  fi
7257 < fi
7258 < rm -f confcache
7259 <  exit 1
7260 < fi
7261 <
7262 < # Extract the first word of "ps", so it can be a program name with args.
7263 < set dummy ps; ac_word=$2
7264 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7265 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7266 < if test "${ac_cv_path_PS+set}" = set; then
7267 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13543 > echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13544 > echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13545 > MPI_F90_LIB=""
13546 > if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
13547 >        MPI_F90_LIB="-lfmpich"
13548 > elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
13549 >        MPI_F90_LIB="-llamf77mpi"
13550   else
13551 <  case $PS in
7270 <  [\\/]* | ?:[\\/]*)
7271 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
7272 <  ;;
7273 <  *)
7274 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7275 < for as_dir in $PATH
7276 < do
7277 <  IFS=$as_save_IFS
7278 <  test -z "$as_dir" && as_dir=.
7279 <  for ac_exec_ext in '' $ac_executable_extensions; do
7280 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7281 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7282 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7283 <    break 2
7284 <  fi
7285 < done
7286 < done
7287 <
7288 <  ;;
7289 < esac
13551 >                        MPI_F90_LIB="  "
13552   fi
13553 < PS=$ac_cv_path_PS
13553 > echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
13554 > echo "${ECHO_T}found $MPI_F90_LIB" >&6
13555  
7293 – if test -n "$PS"; then
7294 –  echo "$as_me:$LINENO: result: $PS" >&5
7295 – echo "${ECHO_T}$PS" >&6
7296 – else
7297 –  echo "$as_me:$LINENO: result: no" >&5
7298 – echo "${ECHO_T}no" >&6
7299 – fi
13556  
7301 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
7302 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
7303 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
7304 –  echo $ECHO_N "(cached) $ECHO_C" >&6
7305 – else
7306 –
7307 –        if $PS ax -o rss > /dev/null 2>&1; then
7308 –                ac_cv_prog_ps_ax=yes
7309 –        else
7310 –                ac_cv_prog_ps_ax=no
7311 –        fi
7312 –        if $PS -ef -o rss > /dev/null 2>&1; then
7313 –                ac_cv_prog_ps_ef=yes
7314 –        else
7315 –                ac_cv_prog_ps_ef=no
7316 –        fi
7317 –        if test "$ac_cv_prog_ps_ax" = yes; then
7318 –                ac_cv_prog_ps_syntax=BSD
7319 –        else
7320 –                if test "$ac_cv_prog_ps_ef" = yes; then
7321 –                        ac_cv_prog_ps_syntax=POSIX
7322 –                else
7323 –                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7324 – echo "$as_me: error: Could not determine ps syntax" >&2;}
7325 –   { (exit 1); exit 1; }; }
7326 –                fi
7327 –        fi
7328 –
13557   fi
7330 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7331 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
13558  
13559  
7334 – cat >>confdefs.h <<_ACEOF
7335 – #define PSCOMMAND $PS
7336 – _ACEOF
13560  
13561 + acx_cgal_found=no
13562  
13563 < if test "$ac_cv_prog_ps_syntax" = BSD; then
13564 <  cat >>confdefs.h <<\_ACEOF
13565 < #define PSTYPE_IS_BSD 1
7342 < _ACEOF
13563 > # Check whether --with-cgalmakefile or --without-cgalmakefile was given.
13564 > if test "${with_cgalmakefile+set}" = set; then
13565 >  withval="$with_cgalmakefile"
13566  
7344 – else
7345 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
7346 –       cat >>confdefs.h <<\_ACEOF
7347 – #define PSTYPE_IS_POSIX 1
7348 – _ACEOF
7349 –
7350 –   else
7351 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
7352 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
7353 –   { (exit 1); exit 1; }; }
7354 –   fi
7355 – fi
7356 –
7357 –
7358 – # Check whether --with-mpi or --without-mpi was given.
7359 – if test "${with_mpi+set}" = set; then
7360 –  withval="$with_mpi"
7361 –  with_mpi=$withval
7362 – else
7363 –  with_mpi="no"
13567   fi;
13568 <
13569 < case "x$with_mpi" in
13570 <        xyes | "x")  USE_MPI=yes;;
13571 <        xno) USE_MPI=no ;;
13572 <        *) MPI="$with_mpi"; USE_MPI=yes ;;
13568 > case $with_cgalmakefile in
13569 >        yes | "") ;;
13570 >        no) acx_cgal_found=disable ;;
13571 >        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13572 >        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13573   esac
7371 – if test "$USE_MPI" = "yes" -a -z "$with_mpi"; then
7372 –        MPI="/usr/local"
7373 – fi
7374 – if test "$USE_MPI" = "yes"; then
13574  
13575 + if test "$acx_cgal_found" == no; then
13576 +    echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
13577 + echo $ECHO_N "checking CGAL_MAKEFILE... $ECHO_C" >&6
13578  
13579 < # Set variables...
7378 < MPI_LIB_DIR="$MPI/lib"
7379 < MPI_INC_DIR="$MPI/include"
13579 >    if test \! -z "$CGAL_MAKEFILE"; then
13580  
13581 +        if test -e "$CGAL_MAKEFILE"; then
13582 +            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
13583  
13584 + cat > $tname << _ACEOF
13585 + include $CGAL_MAKEFILE
13586  
13587 < echo "$as_me:$LINENO: checking for mpi.h" >&5
13588 < echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13589 < have_mpi_h=0
13590 < echo '#include <mpi.h>' > conftest.cc
13591 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13592 <        echo "$as_me:$LINENO: result: yes" >&5
13593 < echo "${ECHO_T}yes" >&6
13594 <        have_mpi_h=1
13595 < else
13596 <        echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13597 < echo "${ECHO_T}no! Check MPI include paths" >&6
13598 <        USE_MPI="no"
13587 > cppflags:
13588 >        @echo \$(CGAL_CXXFLAGS)
13589 >
13590 > cxxflags:
13591 >        @echo
13592 > ldflags:
13593 >        @echo \$(CGAL_LDFLAGS)
13594 > _ACEOF
13595 >            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
13596 >            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
13597 >            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
13598 >            for i in $CGAL_LDFLAGST; do
13599 >                if test `echo $i| grep -c ^-l`; then
13600 >                    CGAL_LIBS="$CGAL_LIBS $i"
13601 >                else
13602 >                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
13603 >                fi
13604 >            done
13605 >            rm -f $tname
13606 >            echo "$as_me:$LINENO: result: yes" >&5
13607 > echo "${ECHO_T}yes" >&6
13608 >            acx_cgal_found=yes
13609 >                                   else
13610 >            echo "$as_me:$LINENO: result: invalid" >&5
13611 > echo "${ECHO_T}invalid" >&6
13612 >            { { echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
13613 > echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
13614 >   { (exit 1); exit 1; }; }
13615 >        fi
13616 >    else
13617 >        echo "$as_me:$LINENO: result: not defined" >&5
13618 > echo "${ECHO_T}not defined" >&6
13619 >    fi
13620   fi
7396 – rm -f conftest*
7397 – if test "$have_mpi_h" = 1; then
13621  
13622 < cat >>confdefs.h <<\_ACEOF
13623 < #define HAVE_MPI_H 1
13622 > if test "$acx_cgal_found" == no; then
13623 >        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13624 >  echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13625 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13626 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13627 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13628 > fi
13629 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13630 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13631 > else
13632 >  # Is the header compilable?
13633 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
13634 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... $ECHO_C" >&6
13635 > cat >conftest.$ac_ext <<_ACEOF
13636 > /* confdefs.h.  */
13637   _ACEOF
13638 + cat confdefs.h >>conftest.$ac_ext
13639 + cat >>conftest.$ac_ext <<_ACEOF
13640 + /* end confdefs.h.  */
13641 + $ac_includes_default
13642 + #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13643 + _ACEOF
13644 + rm -f conftest.$ac_objext
13645 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13646 +  (eval $ac_compile) 2>conftest.er1
13647 +  ac_status=$?
13648 +  grep -v '^ *+' conftest.er1 >conftest.err
13649 +  rm -f conftest.er1
13650 +  cat conftest.err >&5
13651 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13652 +  (exit $ac_status); } &&
13653 +         { ac_try='test -z "$ac_c_werror_flag"
13654 +                         || test ! -s conftest.err'
13655 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13656 +  (eval $ac_try) 2>&5
13657 +  ac_status=$?
13658 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13659 +  (exit $ac_status); }; } &&
13660 +         { ac_try='test -s conftest.$ac_objext'
13661 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13662 +  (eval $ac_try) 2>&5
13663 +  ac_status=$?
13664 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13665 +  (exit $ac_status); }; }; then
13666 +  ac_header_compiler=yes
13667 + else
13668 +  echo "$as_me: failed program was:" >&5
13669 + sed 's/^/| /' conftest.$ac_ext >&5
13670  
13671 + ac_header_compiler=no
13672   fi
13673 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
13674 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13675 + echo "${ECHO_T}$ac_header_compiler" >&6
13676  
13677 < echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13678 < echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13679 < have_mpif_h=0
13680 < rm -f conftest*
13681 < cat >conftest.f90 <<EOF
13682 < program main
13683 <   include 'mpif.h'
13684 < end
13685 < EOF
13686 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13687 <        echo "$as_me:$LINENO: result: yes" >&5
13688 < echo "${ECHO_T}yes" >&6
13689 <        MPI_F90_INC="$MPI_INC_DIR"
13690 <        have_mpif_h=1
13677 > # Is the header present?
13678 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
13679 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... $ECHO_C" >&6
13680 > cat >conftest.$ac_ext <<_ACEOF
13681 > /* confdefs.h.  */
13682 > _ACEOF
13683 > cat confdefs.h >>conftest.$ac_ext
13684 > cat >>conftest.$ac_ext <<_ACEOF
13685 > /* end confdefs.h.  */
13686 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13687 > _ACEOF
13688 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13689 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
13690 >  ac_status=$?
13691 >  grep -v '^ *+' conftest.er1 >conftest.err
13692 >  rm -f conftest.er1
13693 >  cat conftest.err >&5
13694 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13695 >  (exit $ac_status); } >/dev/null; then
13696 >  if test -s conftest.err; then
13697 >    ac_cpp_err=$ac_c_preproc_warn_flag
13698 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13699 >  else
13700 >    ac_cpp_err=
13701 >  fi
13702   else
13703 <        if test -s conftest.out ; then
7421 <                cat conftest.out >> config.log
7422 <        fi
7423 <        echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
7424 < echo "${ECHO_T}no! Check MPI include paths" >&6
7425 <        USE_MPI="no"
13703 >  ac_cpp_err=yes
13704   fi
13705 < rm -f conftest*
13705 > if test -z "$ac_cpp_err"; then
13706 >  ac_header_preproc=yes
13707 > else
13708 >  echo "$as_me: failed program was:" >&5
13709 > sed 's/^/| /' conftest.$ac_ext >&5
13710  
13711 < if test "$have_mpif_h" = 1; then
13711 >  ac_header_preproc=no
13712 > fi
13713 > rm -f conftest.err conftest.$ac_ext
13714 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
13715 > echo "${ECHO_T}$ac_header_preproc" >&6
13716  
13717 < cat >>confdefs.h <<\_ACEOF
13718 < #define HAVE_MPIF_H 1
13719 < _ACEOF
13717 > # So?  What about this header?
13718 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13719 >  yes:no: )
13720 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
13721 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13722 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
13723 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
13724 >    ac_header_preproc=yes
13725 >    ;;
13726 >  no:yes:* )
13727 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
13728 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
13729 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
13730 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
13731 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
13732 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
13733 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
13734 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13735 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
13736 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
13737 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
13738 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
13739 >    (
13740 >      cat <<\_ASBOX
13741 > ## ------------------------------ ##
13742 > ## Report this to gezelter@nd.edu ##
13743 > ## ------------------------------ ##
13744 > _ASBOX
13745 >    ) |
13746 >      sed "s/^/$as_me: WARNING:     /" >&2
13747 >    ;;
13748 > esac
13749 > echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13750 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13751 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13752 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13753 > else
13754 >  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
13755 > fi
13756 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13757 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13758  
13759   fi
13760 + if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
13761 +  cgal_have_header=yes
13762 + else
13763 +  cgal_have_header=no
13764 + fi
13765  
7437 – ac_ext=c
7438 – ac_cpp='$CPP $CPPFLAGS'
7439 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7440 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7441 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
13766  
13767 < ac_save_LDFLAGS=$LDFLAGS
13768 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13769 <
13770 < if test x = x"$MPI_LIB"; then
7447 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
7448 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
7449 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13767 >        if test "$cgal_have_header" == yes; then
13768 >                echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
13769 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
13770 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
13771    echo $ECHO_N "(cached) $ECHO_C" >&6
13772   else
13773    ac_check_lib_save_LIBS=$LIBS
13774 < LIBS="-lmpich  $LIBS"
13774 > LIBS="-lCGAL  $LIBS"
13775   cat >conftest.$ac_ext <<_ACEOF
13776   /* confdefs.h.  */
13777   _ACEOF
13778   cat confdefs.h >>conftest.$ac_ext
13779   cat >>conftest.$ac_ext <<_ACEOF
13780   /* end confdefs.h.  */
13781 <
13782 < /* Override any gcc2 internal prototype to avoid an error.  */
13783 < #ifdef __cplusplus
13784 < extern "C"
13781 >
13782 >
13783 > #ifdef FC_DUMMY_MAIN
13784 > #ifndef FC_DUMMY_MAIN_EQ_F77
13785 > #  ifdef __cplusplus
13786 >     extern "C"
13787 > #  endif
13788 >   int FC_DUMMY_MAIN() { return 1; }
13789 > #endif
13790   #endif
7465 – /* We use char because int might match the return type of a gcc2
7466 –   builtin and then its argument prototype would still apply.  */
7467 – char MPI_Init ();
13791   int
13792   main ()
13793   {
13794 < MPI_Init ();
13794 > main ();
13795    ;
13796    return 0;
13797   }
# Line 7495 | Line 13818 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13818    ac_status=$?
13819    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13820    (exit $ac_status); }; }; then
13821 <  ac_cv_lib_mpich_MPI_Init=yes
13821 >  ac_cv_lib_CGAL_main=yes
13822   else
13823    echo "$as_me: failed program was:" >&5
13824   sed 's/^/| /' conftest.$ac_ext >&5
13825  
13826 < ac_cv_lib_mpich_MPI_Init=no
13826 > ac_cv_lib_CGAL_main=no
13827   fi
13828   rm -f conftest.err conftest.$ac_objext \
13829        conftest$ac_exeext conftest.$ac_ext
13830   LIBS=$ac_check_lib_save_LIBS
13831   fi
13832 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13833 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13834 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13835 <  MPI_LIB="-lmpich"
13832 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
13833 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
13834 > if test $ac_cv_lib_CGAL_main = yes; then
13835 >  cgal_have_lib=yes
13836 > else
13837 >  cgal_have_lib=no
13838   fi
13839  
13840 < fi
13841 < if test x = x"$MPI_LIB"; then
13842 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13843 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13844 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13840 >                if test "$cgal_have_lib" == no; then
13841 >                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
13842 >                        echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
13843 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
13844 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
13845    echo $ECHO_N "(cached) $ECHO_C" >&6
13846   else
13847    ac_check_lib_save_LIBS=$LIBS
13848 < LIBS="-lmpi  $LIBS"
13848 > LIBS="-lCGAL  $LIBS"
13849   cat >conftest.$ac_ext <<_ACEOF
13850   /* confdefs.h.  */
13851   _ACEOF
# Line 7528 | Line 13853 | cat >>conftest.$ac_ext <<_ACEOF
13853   cat >>conftest.$ac_ext <<_ACEOF
13854   /* end confdefs.h.  */
13855  
13856 < /* Override any gcc2 internal prototype to avoid an error.  */
13857 < #ifdef __cplusplus
13858 < extern "C"
13856 >
13857 > #ifdef FC_DUMMY_MAIN
13858 > #ifndef FC_DUMMY_MAIN_EQ_F77
13859 > #  ifdef __cplusplus
13860 >     extern "C"
13861 > #  endif
13862 >   int FC_DUMMY_MAIN() { return 1; }
13863   #endif
13864 < /* We use char because int might match the return type of a gcc2
7536 <   builtin and then its argument prototype would still apply.  */
7537 < char MPI_Init ();
13864 > #endif
13865   int
13866   main ()
13867   {
13868 < MPI_Init ();
13868 > main ();
13869    ;
13870    return 0;
13871   }
# Line 7565 | Line 13892 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13892    ac_status=$?
13893    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13894    (exit $ac_status); }; }; then
13895 <  ac_cv_lib_mpi_MPI_Init=yes
13895 >  ac_cv_lib_CGAL_main=yes
13896   else
13897    echo "$as_me: failed program was:" >&5
13898   sed 's/^/| /' conftest.$ac_ext >&5
13899  
13900 < ac_cv_lib_mpi_MPI_Init=no
13900 > ac_cv_lib_CGAL_main=no
13901   fi
13902   rm -f conftest.err conftest.$ac_objext \
13903        conftest$ac_exeext conftest.$ac_ext
13904   LIBS=$ac_check_lib_save_LIBS
13905   fi
13906 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13907 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13908 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13909 <  MPI_LIB="-lmpi"
13906 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
13907 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
13908 > if test $ac_cv_lib_CGAL_main = yes; then
13909 >  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
13910 >                                                  cgal_have_lib=yes
13911 > else
13912 >  cgal_have_lib=no
13913   fi
13914  
13915 < fi
13916 < $as_unset ac_cv_lib_mpi_MPI_Init
13917 < if test x = x"$MPI_LIB"; then
13918 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13919 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13920 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13915 >                        LIBS="$save_LIBS"
13916 >                else
13917 >                        CGAL_LIBS="-lCGAL"
13918 >                        echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
13919 > echo $ECHO_N "checking for main in -lmpfr... $ECHO_C" >&6
13920 > if test "${ac_cv_lib_mpfr_main+set}" = set; then
13921    echo $ECHO_N "(cached) $ECHO_C" >&6
13922   else
13923    ac_check_lib_save_LIBS=$LIBS
13924 < LIBS="-lmpi "-llam" $LIBS"
13924 > LIBS="-lmpfr  $LIBS"
13925   cat >conftest.$ac_ext <<_ACEOF
13926   /* confdefs.h.  */
13927   _ACEOF
# Line 7599 | Line 13929 | cat >>conftest.$ac_ext <<_ACEOF
13929   cat >>conftest.$ac_ext <<_ACEOF
13930   /* end confdefs.h.  */
13931  
13932 < /* Override any gcc2 internal prototype to avoid an error.  */
13933 < #ifdef __cplusplus
13934 < extern "C"
13932 >
13933 > #ifdef FC_DUMMY_MAIN
13934 > #ifndef FC_DUMMY_MAIN_EQ_F77
13935 > #  ifdef __cplusplus
13936 >     extern "C"
13937 > #  endif
13938 >   int FC_DUMMY_MAIN() { return 1; }
13939   #endif
13940 < /* We use char because int might match the return type of a gcc2
7607 <   builtin and then its argument prototype would still apply.  */
7608 < char MPI_Init ();
13940 > #endif
13941   int
13942   main ()
13943   {
13944 < MPI_Init ();
13944 > main ();
13945    ;
13946    return 0;
13947   }
# Line 7636 | Line 13968 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13968    ac_status=$?
13969    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13970    (exit $ac_status); }; }; then
13971 <  ac_cv_lib_mpi_MPI_Init=yes
13971 >  ac_cv_lib_mpfr_main=yes
13972   else
13973    echo "$as_me: failed program was:" >&5
13974   sed 's/^/| /' conftest.$ac_ext >&5
13975  
13976 < ac_cv_lib_mpi_MPI_Init=no
13976 > ac_cv_lib_mpfr_main=no
13977   fi
13978   rm -f conftest.err conftest.$ac_objext \
13979        conftest$ac_exeext conftest.$ac_ext
13980   LIBS=$ac_check_lib_save_LIBS
13981   fi
13982 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13983 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13984 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13985 <  MPI_LIB="-lmpi -llam"
13982 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
13983 > echo "${ECHO_T}$ac_cv_lib_mpfr_main" >&6
13984 > if test $ac_cv_lib_mpfr_main = yes; then
13985 >  CGAL_LIBS="$CGAL_LIBS -lmpfr"
13986   fi
13987  
13988 < fi
13989 < $as_unset ac_cv_lib_mpich_MPI_Init
13990 < if test x = x"$MPI_LIB"; then
7659 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
7660 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
7661 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13988 >                        echo "$as_me:$LINENO: checking for main in -lgmp" >&5
13989 > echo $ECHO_N "checking for main in -lgmp... $ECHO_C" >&6
13990 > if test "${ac_cv_lib_gmp_main+set}" = set; then
13991    echo $ECHO_N "(cached) $ECHO_C" >&6
13992   else
13993    ac_check_lib_save_LIBS=$LIBS
13994 < LIBS="-lmpich "-lpmpich" $LIBS"
13994 > LIBS="-lgmp  $LIBS"
13995   cat >conftest.$ac_ext <<_ACEOF
13996   /* confdefs.h.  */
13997   _ACEOF
# Line 7670 | Line 13999 | cat >>conftest.$ac_ext <<_ACEOF
13999   cat >>conftest.$ac_ext <<_ACEOF
14000   /* end confdefs.h.  */
14001  
14002 < /* Override any gcc2 internal prototype to avoid an error.  */
14003 < #ifdef __cplusplus
14004 < extern "C"
14002 >
14003 > #ifdef FC_DUMMY_MAIN
14004 > #ifndef FC_DUMMY_MAIN_EQ_F77
14005 > #  ifdef __cplusplus
14006 >     extern "C"
14007 > #  endif
14008 >   int FC_DUMMY_MAIN() { return 1; }
14009   #endif
14010 < /* We use char because int might match the return type of a gcc2
7678 <   builtin and then its argument prototype would still apply.  */
7679 < char MPI_Init ();
14010 > #endif
14011   int
14012   main ()
14013   {
14014 < MPI_Init ();
14014 > main ();
14015    ;
14016    return 0;
14017   }
# Line 7707 | Line 14038 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14038    ac_status=$?
14039    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14040    (exit $ac_status); }; }; then
14041 <  ac_cv_lib_mpich_MPI_Init=yes
14041 >  ac_cv_lib_gmp_main=yes
14042   else
14043    echo "$as_me: failed program was:" >&5
14044   sed 's/^/| /' conftest.$ac_ext >&5
14045  
14046 < ac_cv_lib_mpich_MPI_Init=no
14046 > ac_cv_lib_gmp_main=no
14047   fi
14048   rm -f conftest.err conftest.$ac_objext \
14049        conftest$ac_exeext conftest.$ac_ext
14050   LIBS=$ac_check_lib_save_LIBS
14051   fi
14052 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
14053 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
14054 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
14055 <  MPI_LIB="-lmpich -lpmpich"
14052 > echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
14053 > echo "${ECHO_T}$ac_cv_lib_gmp_main" >&6
14054 > if test $ac_cv_lib_gmp_main = yes; then
14055 >  CGAL_LIBS="$CGAL_LIBS -lgmp"
14056   fi
14057  
14058 < fi
14059 <
14060 < $as_unset ac_cv_lib_mpi_MPI_Init
7730 < if test x = x"$MPI_LIB"; then
7731 < echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
7732 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
7733 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
14058 >                        echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
14059 > echo $ECHO_N "checking for main in -lgmpxx... $ECHO_C" >&6
14060 > if test "${ac_cv_lib_gmpxx_main+set}" = set; then
14061    echo $ECHO_N "(cached) $ECHO_C" >&6
14062   else
14063    ac_check_lib_save_LIBS=$LIBS
14064 < LIBS="-lmpi -llam -lpthread $LIBS"
14064 > LIBS="-lgmpxx  $LIBS"
14065   cat >conftest.$ac_ext <<_ACEOF
14066   /* confdefs.h.  */
14067   _ACEOF
# Line 7742 | Line 14069 | cat >>conftest.$ac_ext <<_ACEOF
14069   cat >>conftest.$ac_ext <<_ACEOF
14070   /* end confdefs.h.  */
14071  
14072 < /* Override any gcc2 internal prototype to avoid an error.  */
14073 < #ifdef __cplusplus
14074 < extern "C"
14072 >
14073 > #ifdef FC_DUMMY_MAIN
14074 > #ifndef FC_DUMMY_MAIN_EQ_F77
14075 > #  ifdef __cplusplus
14076 >     extern "C"
14077 > #  endif
14078 >   int FC_DUMMY_MAIN() { return 1; }
14079   #endif
14080 < /* We use char because int might match the return type of a gcc2
7750 <   builtin and then its argument prototype would still apply.  */
7751 < char MPI_Init ();
14080 > #endif
14081   int
14082   main ()
14083   {
14084 < MPI_Init ();
14084 > main ();
14085    ;
14086    return 0;
14087   }
# Line 7779 | Line 14108 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14108    ac_status=$?
14109    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14110    (exit $ac_status); }; }; then
14111 <  ac_cv_lib_mpi_MPI_Init=yes
14111 >  ac_cv_lib_gmpxx_main=yes
14112   else
14113    echo "$as_me: failed program was:" >&5
14114   sed 's/^/| /' conftest.$ac_ext >&5
14115  
14116 < ac_cv_lib_mpi_MPI_Init=no
14116 > ac_cv_lib_gmpxx_main=no
14117   fi
14118   rm -f conftest.err conftest.$ac_objext \
14119        conftest$ac_exeext conftest.$ac_ext
14120   LIBS=$ac_check_lib_save_LIBS
14121   fi
14122 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
14123 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
14124 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
14125 <  MPI_LIB="-lmpi -llam -lpthread"
7797 < else
7798 <
7799 <             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7800 < echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7801 <   { (exit 1); exit 1; }; }
7802 <             USE_MPI="no"
7803 <
14122 > echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
14123 > echo "${ECHO_T}$ac_cv_lib_gmpxx_main" >&6
14124 > if test $ac_cv_lib_gmpxx_main = yes; then
14125 >  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
14126   fi
14127  
14128 < fi
7807 <
7808 <
7809 <
7810 < echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
7811 < echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
7812 < MPI_F90_LIB=""
7813 < if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7814 <        MPI_F90_LIB="-lfmpich"
7815 < elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7816 <        MPI_F90_LIB="-llamf77mpi"
7817 < else
7818 <                        MPI_F90_LIB="  "
7819 < fi
7820 < echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
7821 < echo "${ECHO_T}found $MPI_F90_LIB" >&6
7822 <
7823 <
7824 < fi
7825 <
7826 <
7827 <
7828 <
7829 < USE_CGAL=no
7830 < cgal_makefile=auto
7831 <
7832 < # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
7833 < if test "${with_cgal_makefile+set}" = set; then
7834 <  withval="$with_cgal_makefile"
7835 <  cgal_makefile="$withval"
7836 < fi;
7837 <
7838 < if test "x$cgal_makefile" != xno; then
7839 <
7840 <  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
7841 <    cgal_makefile="$CGAL_MAKEFILE"
7842 <  fi
7843 <
7844 <  echo "cgal_makefile      $cgal_makefile"
7845 <
7846 <  if test -f "$cgal_makefile"; then
7847 <
7848 <    cat >config.tmp.Makefile <<EOF
7849 < include $cgal_makefile
7850 < default:
7851 <        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
7852 <        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
7853 <        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
7854 <        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
7855 <        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
7856 <        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
7857 <        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
7858 <        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
7859 <        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
7860 <        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
7861 <        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
7862 <        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
7863 < EOF
7864 <
7865 <    make -s -f config.tmp.Makefile
7866 <    . config.tmp.cgalvariables
14128 >                fi
14129  
14130 <    rm -f config.tmp.Makefile config.tmp.cgalvariables
14131 <
14132 <    if test "x$CGAL_INCLDIR" = "x"; then
14133 <      CGAL_INCLDIR=""
14134 <    fi
14135 <
14136 <    if test "x$CGAL_LIBDIR" = "x"; then
14137 <      CGAL_LIBDIR=""
7876 <    fi
7877 <
7878 <    if test "x$CGAL_RLIBDIR" = "x"; then
7879 <      CGAL_RLIBDIR=""
7880 <    fi
7881 <
7882 <    if test "x$LEDA_INCLDIR" = "x"; then
7883 <      LEDA_INCLDIR=""
7884 <    fi
7885 <
7886 <    if test "x$LEDA_LIBDIR" = "x"; then
7887 <      LEDA_LIBDIR=""
7888 <    fi
7889 <
7890 <    if test "x$LEDA_RLIBDIR" = "x"; then
7891 <      LEDA_RLIBDIR=""
7892 <    fi
7893 <
7894 <    if test "x$GMP_INCLDIR" = "x"; then
7895 <      GMP_INCLDIR=""
7896 <    fi
7897 <
7898 <    if test "x$GMP_LIBDIR" = "x"; then
7899 <      GMP_LIBDIR=""
7900 <    fi
7901 <
7902 <    if test "x$GMP_RLIBDIR" = "x"; then
7903 <      GMP_RLIBDIR=""
7904 <    fi
7905 <
7906 <    echo "CGAL_OS_COMPILER   $CGAL_OS_COMPILER"
7907 <    echo "CGAL_INCLDIR       $CGAL_INCLDIR"
7908 <    echo "CGAL_INCLCONFDIR   $CGAL_INCLCONFDIR"
7909 <    echo "CGAL_LIBDIR        $CGAL_LIBDIR"
7910 <    echo "CGAL_CXXFLAGS      $CGAL_CXXFLAGS"
7911 <    echo "LEDA_INCLDIR       $LEDA_INCLDIR"
7912 <    echo "LEDA_LIBDIR        $LEDA_LIBDIR"
7913 <    echo "GMP_INCLDIR        $GMP_INCLDIR"
7914 <    echo "GMP_LIBDIR         $GMP_LIBDIR"
7915 <
7916 <    ac_ext=cc
7917 < ac_cpp='$CXXCPP $CPPFLAGS'
7918 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7919 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7920 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7921 <
7922 <    save_CXXFLAGS="$CXXFLAGS"
7923 <    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
7924 <
7925 < ac_ext=cc
7926 < ac_cpp='$CXXCPP $CPPFLAGS'
7927 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7928 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7929 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7930 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
7931 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
7932 < if test -z "$CXXCPP"; then
7933 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
14130 >                if test "$cgal_have_lib" == yes; then
14131 >                        acx_cgal_found=yes
14132 >                fi
14133 >        fi
14134 >        if test "$acx_cgal_found" == yes; then
14135 >                echo "$as_me:$LINENO: checking for main in -lCore" >&5
14136 > echo $ECHO_N "checking for main in -lCore... $ECHO_C" >&6
14137 > if test "${ac_cv_lib_Core_main+set}" = set; then
14138    echo $ECHO_N "(cached) $ECHO_C" >&6
14139   else
14140 <      # Double quotes because CXXCPP needs to be expanded
14141 <    for CXXCPP in "$CXX -E" "/lib/cpp"
7938 <    do
7939 <      ac_preproc_ok=false
7940 < for ac_cxx_preproc_warn_flag in '' yes
7941 < do
7942 <  # Use a header file that comes with gcc, so configuring glibc
7943 <  # with a fresh cross-compiler works.
7944 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7945 <  # <limits.h> exists even on freestanding compilers.
7946 <  # On the NeXT, cc -E runs the code through the compiler's parser,
7947 <  # not just through cpp. "Syntax error" is here to catch this case.
7948 <  cat >conftest.$ac_ext <<_ACEOF
7949 < /* confdefs.h.  */
7950 < _ACEOF
7951 < cat confdefs.h >>conftest.$ac_ext
7952 < cat >>conftest.$ac_ext <<_ACEOF
7953 < /* end confdefs.h.  */
7954 < #ifdef __STDC__
7955 < # include <limits.h>
7956 < #else
7957 < # include <assert.h>
7958 < #endif
7959 <                     Syntax error
7960 < _ACEOF
7961 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7962 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7963 <  ac_status=$?
7964 <  grep -v '^ *+' conftest.er1 >conftest.err
7965 <  rm -f conftest.er1
7966 <  cat conftest.err >&5
7967 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968 <  (exit $ac_status); } >/dev/null; then
7969 <  if test -s conftest.err; then
7970 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
7971 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7972 <  else
7973 <    ac_cpp_err=
7974 <  fi
7975 < else
7976 <  ac_cpp_err=yes
7977 < fi
7978 < if test -z "$ac_cpp_err"; then
7979 <  :
7980 < else
7981 <  echo "$as_me: failed program was:" >&5
7982 < sed 's/^/| /' conftest.$ac_ext >&5
7983 <
7984 <  # Broken: fails on valid input.
7985 < continue
7986 < fi
7987 < rm -f conftest.err conftest.$ac_ext
7988 <
7989 <  # OK, works on sane cases.  Now check whether non-existent headers
7990 <  # can be detected and how.
7991 <  cat >conftest.$ac_ext <<_ACEOF
7992 < /* confdefs.h.  */
7993 < _ACEOF
7994 < cat confdefs.h >>conftest.$ac_ext
7995 < cat >>conftest.$ac_ext <<_ACEOF
7996 < /* end confdefs.h.  */
7997 < #include <ac_nonexistent.h>
7998 < _ACEOF
7999 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8000 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8001 <  ac_status=$?
8002 <  grep -v '^ *+' conftest.er1 >conftest.err
8003 <  rm -f conftest.er1
8004 <  cat conftest.err >&5
8005 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8006 <  (exit $ac_status); } >/dev/null; then
8007 <  if test -s conftest.err; then
8008 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8009 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8010 <  else
8011 <    ac_cpp_err=
8012 <  fi
8013 < else
8014 <  ac_cpp_err=yes
8015 < fi
8016 < if test -z "$ac_cpp_err"; then
8017 <  # Broken: success on invalid input.
8018 < continue
8019 < else
8020 <  echo "$as_me: failed program was:" >&5
8021 < sed 's/^/| /' conftest.$ac_ext >&5
8022 <
8023 <  # Passes both tests.
8024 < ac_preproc_ok=:
8025 < break
8026 < fi
8027 < rm -f conftest.err conftest.$ac_ext
8028 <
8029 < done
8030 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8031 < rm -f conftest.err conftest.$ac_ext
8032 < if $ac_preproc_ok; then
8033 <  break
8034 < fi
8035 <
8036 <    done
8037 <    ac_cv_prog_CXXCPP=$CXXCPP
8038 <
8039 < fi
8040 <  CXXCPP=$ac_cv_prog_CXXCPP
8041 < else
8042 <  ac_cv_prog_CXXCPP=$CXXCPP
8043 < fi
8044 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
8045 < echo "${ECHO_T}$CXXCPP" >&6
8046 < ac_preproc_ok=false
8047 < for ac_cxx_preproc_warn_flag in '' yes
8048 < do
8049 <  # Use a header file that comes with gcc, so configuring glibc
8050 <  # with a fresh cross-compiler works.
8051 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8052 <  # <limits.h> exists even on freestanding compilers.
8053 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8054 <  # not just through cpp. "Syntax error" is here to catch this case.
8055 <  cat >conftest.$ac_ext <<_ACEOF
8056 < /* confdefs.h.  */
8057 < _ACEOF
8058 < cat confdefs.h >>conftest.$ac_ext
8059 < cat >>conftest.$ac_ext <<_ACEOF
8060 < /* end confdefs.h.  */
8061 < #ifdef __STDC__
8062 < # include <limits.h>
8063 < #else
8064 < # include <assert.h>
8065 < #endif
8066 <                     Syntax error
8067 < _ACEOF
8068 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8069 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8070 <  ac_status=$?
8071 <  grep -v '^ *+' conftest.er1 >conftest.err
8072 <  rm -f conftest.er1
8073 <  cat conftest.err >&5
8074 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8075 <  (exit $ac_status); } >/dev/null; then
8076 <  if test -s conftest.err; then
8077 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8078 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8079 <  else
8080 <    ac_cpp_err=
8081 <  fi
8082 < else
8083 <  ac_cpp_err=yes
8084 < fi
8085 < if test -z "$ac_cpp_err"; then
8086 <  :
8087 < else
8088 <  echo "$as_me: failed program was:" >&5
8089 < sed 's/^/| /' conftest.$ac_ext >&5
8090 <
8091 <  # Broken: fails on valid input.
8092 < continue
8093 < fi
8094 < rm -f conftest.err conftest.$ac_ext
8095 <
8096 <  # OK, works on sane cases.  Now check whether non-existent headers
8097 <  # can be detected and how.
8098 <  cat >conftest.$ac_ext <<_ACEOF
8099 < /* confdefs.h.  */
8100 < _ACEOF
8101 < cat confdefs.h >>conftest.$ac_ext
8102 < cat >>conftest.$ac_ext <<_ACEOF
8103 < /* end confdefs.h.  */
8104 < #include <ac_nonexistent.h>
8105 < _ACEOF
8106 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8107 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8108 <  ac_status=$?
8109 <  grep -v '^ *+' conftest.er1 >conftest.err
8110 <  rm -f conftest.er1
8111 <  cat conftest.err >&5
8112 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8113 <  (exit $ac_status); } >/dev/null; then
8114 <  if test -s conftest.err; then
8115 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8116 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8117 <  else
8118 <    ac_cpp_err=
8119 <  fi
8120 < else
8121 <  ac_cpp_err=yes
8122 < fi
8123 < if test -z "$ac_cpp_err"; then
8124 <  # Broken: success on invalid input.
8125 < continue
8126 < else
8127 <  echo "$as_me: failed program was:" >&5
8128 < sed 's/^/| /' conftest.$ac_ext >&5
8129 <
8130 <  # Passes both tests.
8131 < ac_preproc_ok=:
8132 < break
8133 < fi
8134 < rm -f conftest.err conftest.$ac_ext
8135 <
8136 < done
8137 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8138 < rm -f conftest.err conftest.$ac_ext
8139 < if $ac_preproc_ok; then
8140 <  :
8141 < else
8142 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8143 < See \`config.log' for more details." >&5
8144 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
8145 < See \`config.log' for more details." >&2;}
8146 <   { (exit 1); exit 1; }; }
8147 < fi
8148 <
8149 < ac_ext=cc
8150 < ac_cpp='$CXXCPP $CPPFLAGS'
8151 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8152 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8153 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8154 <
8155 <
8156 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
8157 <  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
8158 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
8159 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
8160 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8161 < fi
8162 < echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
8163 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
8164 < else
8165 <  # Is the header compilable?
8166 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
8167 < echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
14140 >  ac_check_lib_save_LIBS=$LIBS
14141 > LIBS="-lCore  $LIBS"
14142   cat >conftest.$ac_ext <<_ACEOF
14143   /* confdefs.h.  */
14144   _ACEOF
14145   cat confdefs.h >>conftest.$ac_ext
14146   cat >>conftest.$ac_ext <<_ACEOF
14147   /* end confdefs.h.  */
8174 – $ac_includes_default
8175 – #include <CGAL/Cartesian.h>
8176 – _ACEOF
8177 – rm -f conftest.$ac_objext
8178 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8179 –  (eval $ac_compile) 2>conftest.er1
8180 –  ac_status=$?
8181 –  grep -v '^ *+' conftest.er1 >conftest.err
8182 –  rm -f conftest.er1
8183 –  cat conftest.err >&5
8184 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8185 –  (exit $ac_status); } &&
8186 –         { ac_try='test -z "$ac_cxx_werror_flag"
8187 –                         || test ! -s conftest.err'
8188 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8189 –  (eval $ac_try) 2>&5
8190 –  ac_status=$?
8191 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8192 –  (exit $ac_status); }; } &&
8193 –         { ac_try='test -s conftest.$ac_objext'
8194 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8195 –  (eval $ac_try) 2>&5
8196 –  ac_status=$?
8197 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8198 –  (exit $ac_status); }; }; then
8199 –  ac_header_compiler=yes
8200 – else
8201 –  echo "$as_me: failed program was:" >&5
8202 – sed 's/^/| /' conftest.$ac_ext >&5
14148  
8204 – ac_header_compiler=no
8205 – fi
8206 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8207 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8208 – echo "${ECHO_T}$ac_header_compiler" >&6
14149  
14150 < # Is the header present?
14151 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
14152 < echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
14153 < cat >conftest.$ac_ext <<_ACEOF
14154 < /* confdefs.h.  */
14155 < _ACEOF
14156 < cat confdefs.h >>conftest.$ac_ext
14157 < cat >>conftest.$ac_ext <<_ACEOF
8218 < /* end confdefs.h.  */
8219 < #include <CGAL/Cartesian.h>
8220 < _ACEOF
8221 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8222 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8223 <  ac_status=$?
8224 <  grep -v '^ *+' conftest.er1 >conftest.err
8225 <  rm -f conftest.er1
8226 <  cat conftest.err >&5
8227 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8228 <  (exit $ac_status); } >/dev/null; then
8229 <  if test -s conftest.err; then
8230 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
8231 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
8232 <  else
8233 <    ac_cpp_err=
8234 <  fi
8235 < else
8236 <  ac_cpp_err=yes
8237 < fi
8238 < if test -z "$ac_cpp_err"; then
8239 <  ac_header_preproc=yes
8240 < else
8241 <  echo "$as_me: failed program was:" >&5
8242 < sed 's/^/| /' conftest.$ac_ext >&5
8243 <
8244 <  ac_header_preproc=no
8245 < fi
8246 < rm -f conftest.err conftest.$ac_ext
8247 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8248 < echo "${ECHO_T}$ac_header_preproc" >&6
8249 <
8250 < # So?  What about this header?
8251 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
8252 <  yes:no: )
8253 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
8254 < echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8255 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
8256 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
8257 <    ac_header_preproc=yes
8258 <    ;;
8259 <  no:yes:* )
8260 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
8261 < echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
8262 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
8263 < echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
8264 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
8265 < echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
8266 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
8267 < echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8268 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
8269 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
8270 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
8271 < echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
8272 <    (
8273 <      cat <<\_ASBOX
8274 < ## ------------------------------ ##
8275 < ## Report this to gezelter@nd.edu ##
8276 < ## ------------------------------ ##
8277 < _ASBOX
8278 <    ) |
8279 <      sed "s/^/$as_me: WARNING:     /" >&2
8280 <    ;;
8281 < esac
8282 < echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
8283 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
8284 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
8285 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8286 < else
8287 <  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
8288 < fi
8289 < echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
8290 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
8291 <
8292 < fi
8293 < if test $ac_cv_header_CGAL_Cartesian_h = yes; then
8294 <  cgal=yes
8295 < else
8296 <  cgal=no
8297 < fi
8298 <
8299 <
8300 <    CXXFLAGS="$save_CXXFLAGS"
8301 <
8302 <    if test "x$cgal" = xyes; then
8303 <      echo "$as_me:$LINENO: checking for CGAL version" >&5
8304 < echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
8305 <      LOCATION=${CGAL_INCLDIR}
8306 <      LOCATION=${LOCATION:-/usr/include}
8307 <      if test -f $LOCATION/CGAL/version.h; then
8308 <        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
8309 <      else
8310 <        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
8311 <      fi
8312 <      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
8313 <        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
8314 < echo "${ECHO_T}($CGAL_VERSION) yes" >&6
8315 <      else
8316 <        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
8317 < echo "${ECHO_T}($CGAL_VERSION) no" >&6
8318 <        cgal=no
8319 <      fi
8320 <    fi
8321 <
8322 <    if test "x$cgal" = xyes; then
8323 <      CGAL_LIBS="-lCGAL"
8324 <      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
8325 < echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
8326 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
8327 <        CGAL_USES_LEDA=yes
8328 <        echo "$as_me:$LINENO: result: yes" >&5
8329 < echo "${ECHO_T}yes" >&6
8330 <        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
8331 <      else
8332 <        echo "$as_me:$LINENO: result: no" >&5
8333 < echo "${ECHO_T}no" >&6
8334 <        CGAL_USES_LEDA=no
8335 <      fi
8336 <
8337 <      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
8338 < echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
8339 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
8340 <        CGAL_USES_GMP=yes
8341 <        echo "$as_me:$LINENO: result: yes" >&5
8342 < echo "${ECHO_T}yes" >&6
8343 <        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
8344 <      else
8345 <        echo "$as_me:$LINENO: result: no" >&5
8346 < echo "${ECHO_T}no" >&6
8347 <        CGAL_USES_GMP=no
8348 <      fi
8349 <
8350 <      CGAL_LIBS="$CGAL_LIBS -lm"
8351 <
8352 <      CGAL_CXXFLAGS="-ftemplate-depth-50"
8353 <
8354 <      echo "CGAL_USES_LEDA     $CGAL_USES_LEDA"
8355 <      echo "CGAL_USES_GMP      $CGAL_USES_GMP"
8356 <      echo "CGAL_INCLDIR       $CGAL_INCLDIR"
8357 <      echo "CGAL_LIBDIR        $CGAL_LIBDIR"
8358 <      echo "CGAL_DEFINES       $CGAL_DEFINES"
8359 <      echo "CGAL_CXXFLAGS      $CGAL_CXXFLAGS"
8360 <      echo "CGAL_LIBS          $CGAL_LIBS"
8361 <    fi
8362 <
8363 <    if test "x$cgal" = xyes; then
8364 <      save_LIBS="$LIBS"
8365 <      LIBS="$LIBS -L$CGAL_LIBDIR"
8366 <      if test "x$CGAL_USES_LEDA" = xyes; then
8367 <        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
8368 <      fi
8369 <      # if test "x$CGAL_USES_GMP" = xyes; then
8370 <      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
8371 <      # fi
8372 <      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
8373 < echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
8374 < save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
8375 < CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
8376 < save_LIBS_CHECK_CXX_LIB="$LIBS"
8377 < LIBS="-lCGAL  $LIBS"
8378 < cat >conftest.$ac_ext <<_ACEOF
8379 < /* confdefs.h.  */
8380 < _ACEOF
8381 < cat confdefs.h >>conftest.$ac_ext
8382 < cat >>conftest.$ac_ext <<_ACEOF
8383 < /* end confdefs.h.  */
8384 < #include <CGAL/Cartesian.h>
14150 > #ifdef FC_DUMMY_MAIN
14151 > #ifndef FC_DUMMY_MAIN_EQ_F77
14152 > #  ifdef __cplusplus
14153 >     extern "C"
14154 > #  endif
14155 >   int FC_DUMMY_MAIN() { return 1; }
14156 > #endif
14157 > #endif
14158   int
14159   main ()
14160   {
14161 < ::CGAL::Cartesian<int>::Point_2 P
14161 > main ();
14162    ;
14163    return 0;
14164   }
# Line 8399 | Line 14172 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14172    cat conftest.err >&5
14173    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14174    (exit $ac_status); } &&
14175 <         { ac_try='test -z "$ac_cxx_werror_flag"
14175 >         { ac_try='test -z "$ac_c_werror_flag"
14176                           || test ! -s conftest.err'
14177    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14178    (eval $ac_try) 2>&5
# Line 8412 | Line 14185 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14185    ac_status=$?
14186    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14187    (exit $ac_status); }; }; then
14188 <  echo "$as_me:$LINENO: result: yes" >&5
8416 < echo "${ECHO_T}yes" >&6
8417 < cgal=yes
14188 >  ac_cv_lib_Core_main=yes
14189   else
14190    echo "$as_me: failed program was:" >&5
14191   sed 's/^/| /' conftest.$ac_ext >&5
14192  
14193 < echo "$as_me:$LINENO: result: no" >&5
8423 < echo "${ECHO_T}no" >&6
8424 < cgal=no
14193 > ac_cv_lib_Core_main=no
14194   fi
14195   rm -f conftest.err conftest.$ac_objext \
14196        conftest$ac_exeext conftest.$ac_ext
14197 < CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
14198 < LIBS="$save_LIBS_CHECK_CXX_LIB"
14199 <      LIBS="$save_LIBS"
14200 <    fi
14197 > LIBS=$ac_check_lib_save_LIBS
14198 > fi
14199 > echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
14200 > echo "${ECHO_T}$ac_cv_lib_Core_main" >&6
14201 > if test $ac_cv_lib_Core_main = yes; then
14202 >  CGAL_LIBS="$CGAL_LIBS -lCore"
14203 > fi
14204  
14205 <  fi
8434 <  ac_ext=c
8435 < ac_cpp='$CPP $CPPFLAGS'
8436 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8437 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8438 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8439 <
8440 <
14205 >        fi
14206   fi
14207  
8443 – if test "x$cgal" = xyes; then
8444 –  USE_CGAL=yes
14208  
8446 – cat >>confdefs.h <<\_ACEOF
8447 – #define HAVE_CGAL 1
8448 – _ACEOF
14209  
14210 + echo "$as_me:$LINENO: checking CGAL" >&5
14211 + echo $ECHO_N "checking CGAL... $ECHO_C" >&6
14212 + if test "$acx_cgal_found" == yes; then
14213 +        echo "$as_me:$LINENO: result: yes" >&5
14214 + echo "${ECHO_T}yes" >&6;
14215  
14216 < cat >>confdefs.h <<_ACEOF
14217 < #define CGAL_VERSION $CGAL_VERSION
14218 < _ACEOF
14216 > else
14217 >        echo "$as_me:$LINENO: result: no" >&5
14218 > echo "${ECHO_T}no" >&6
14219  
8455 –  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
8456 –    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
8457 – echo "$as_me: WARNING: *****************************************************" >&2;}
8458 –    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
8459 – echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
8460 –    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
8461 – echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
8462 –    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
8463 – echo "$as_me: WARNING: *****************************************************" >&2;}
8464 –  fi
8465 – else
8466 –   if test "x$cgal_makefile" != xno; then
8467 –    { echo "$as_me:$LINENO: WARNING: *********************************************************" >&5
8468 – echo "$as_me: WARNING: *********************************************************" >&2;}
8469 –    { echo "$as_me:$LINENO: WARNING: *** Warning: CGAL was not found.                      ***" >&5
8470 – echo "$as_me: WARNING: *** Warning: CGAL was not found.                      ***" >&2;}
8471 –    { echo "$as_me:$LINENO: WARNING: *** Run \"configure\" with the appropriate options.     ***" >&5
8472 – echo "$as_me: WARNING: *** Run \"configure\" with the appropriate options.     ***" >&2;}
8473 –    { echo "$as_me:$LINENO: WARNING: *** CGAL support will be disabled.                    ***" >&5
8474 – echo "$as_me: WARNING: *** CGAL support will be disabled.                    ***" >&2;}
8475 –    { echo "$as_me:$LINENO: WARNING: *********************************************************" >&5
8476 – echo "$as_me: WARNING: *********************************************************" >&2;}
8477 –  fi
8478 –  CGAL_INCLDIR=
8479 –  CGAL_LIBDIR=
8480 –  CGAL_RLIBDIR=
8481 –  CGAL_DEFINES=
8482 –  CGAL_CXXFLAGS=
8483 –  CGAL_LIBS=
14220   fi
14221  
14222 + if test "$acx_cgal_found" == yes; then
14223 +        USE_CGAL=yes
14224  
14225 < CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
14225 > cat >>confdefs.h <<\_ACEOF
14226 > #define HAVE_CGAL 1
14227 > _ACEOF
14228  
8489 – CGAL_LIB_DIR=${CGAL_LIBDIR}
14229  
8491 – CGAL_RLIB_DIR=${CGAL_RLIBDIR}
14230  
14231  
14232  
14233  
14234 + fi
14235  
14236  
14237  
# Line 8637 | Line 14376 | fi
14376  
14377  
14378  
8640 – OBJEXT=".$OBJEXT"
14379  
8642 – OOPSE=oopse
14380  
8644 – if test "x${prefix}" = "xNONE"
8645 – then
8646 –  OOPSE_HOME=${ac_default_prefix}/oopse
8647 – else
8648 –  OOPSE_HOME=${prefix}/oopse
8649 – fi
8650 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
8651 – if test "${enable_oopse_home+set}" = set; then
8652 –  enableval="$enable_oopse_home"
8653 –  OOPSE_HOME="${enableval}"
8654 – fi;
14381  
8656 – case "x$INSTALL" in
8657 –   x/*) ;;
8658 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
8659 – esac
14382  
8661 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14383  
8663 – CFLAGS=${CFLAGS-""}
8664 – CXXFLAGS=${CXXFLAGS-""}
8665 – CPPFLAGS=${CPPFLAGS-""}
8666 – FFLAGS=${FFLAGS-""}
8667 – F90FLAGS=${F90FLAGS-""}
8668 – LDFLAGS=${LDFLAGS-""}
8669 – DEBUG=${DEBUG-"-g"}
14384  
8671 – case $debug in
8672 –  1)
8673 –     FFLAGS="$DEBUG $FFLAGS"
8674 –     F90FLAGS="$DEBUG $F90FLAGS"
8675 –     ;;
8676 –  *)
8677 –     ;;
8678 – esac
8679 –
8680 –
8681 –
8682 –
8683 –
8684 –
8685 –
8686 –
8687 –
8688 –
8689 –
14385  
14386  
14387  
14388  
14389  
14390  
14391 <
8697 <          ac_config_headers="$ac_config_headers src/config.h"
8698 <
8699 <                              ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile"
14391 >                                                  ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/applications/staticProps/Makefile scripts/filepp"
14392  
14393  
14394   cat >confcache <<\_ACEOF
# Line 9061 | Line 14753 | cat >&5 <<_CSEOF
14753   } >&5
14754   cat >&5 <<_CSEOF
14755  
14756 < This file was extended by OOPSE $as_me 2.0, which was
14756 > This file was extended by OOPSE $as_me 4.0, which was
14757   generated by GNU Autoconf 2.59.  Invocation command line was
14758  
14759    CONFIG_FILES    = $CONFIG_FILES
# Line 9124 | Line 14816 | ac_cs_version="\\
14816  
14817   cat >>$CONFIG_STATUS <<_ACEOF
14818   ac_cs_version="\\
14819 < OOPSE config.status 2.0
14819 > OOPSE config.status 4.0
14820   configured by $0, generated by GNU Autoconf 2.59,
14821    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14822  
# Line 9229 | Line 14921 | do
14921    # Handling of arguments.
14922    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14923    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14924 <  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14924 >  "src/math/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
14925 >  "src/applications/staticProps/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/staticProps/Makefile" ;;
14926 >  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14927    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14928    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14929    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
# Line 9317 | Line 15011 | s,@LIBS@,$LIBS,;t t
15011   s,@ECHO_N@,$ECHO_N,;t t
15012   s,@ECHO_T@,$ECHO_T,;t t
15013   s,@LIBS@,$LIBS,;t t
9320 – s,@PROGNAME@,$PROGNAME,;t t
9321 – s,@debug@,$debug,;t t
15014   s,@build@,$build,;t t
15015   s,@build_cpu@,$build_cpu,;t t
15016   s,@build_vendor@,$build_vendor,;t t
# Line 9327 | Line 15019 | s,@host_os@,$host_os,;t t
15019   s,@host_cpu@,$host_cpu,;t t
15020   s,@host_vendor@,$host_vendor,;t t
15021   s,@host_os@,$host_os,;t t
15022 < s,@CC@,$CC,;t t
15023 < s,@CFLAGS@,$CFLAGS,;t t
15022 > s,@PROGNAME@,$PROGNAME,;t t
15023 > s,@debug@,$debug,;t t
15024 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
15025 > s,@CXX@,$CXX,;t t
15026 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15027   s,@LDFLAGS@,$LDFLAGS,;t t
15028   s,@CPPFLAGS@,$CPPFLAGS,;t t
15029 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15029 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15030   s,@EXEEXT@,$EXEEXT,;t t
15031   s,@OBJEXT@,$OBJEXT,;t t
15032 < s,@CXX@,$CXX,;t t
15033 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15034 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15035 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15036 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15037 < s,@F90@,$F90,;t t
9343 < s,@F90FLAGS@,$F90FLAGS,;t t
9344 < s,@ac_ct_F90@,$ac_ct_F90,;t t
9345 < s,@PREPFLAG@,$PREPFLAG,;t t
9346 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
9347 < s,@F90LIBS@,$F90LIBS,;t t
9348 < s,@F90_FUNC@,$F90_FUNC,;t t
9349 < s,@F90_FUNC_@,$F90_FUNC_,;t t
9350 < s,@MOD@,$MOD,;t t
9351 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
9352 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
9353 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
9354 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15032 > s,@CC@,$CC,;t t
15033 > s,@CFLAGS@,$CFLAGS,;t t
15034 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15035 > s,@FC@,$FC,;t t
15036 > s,@FCFLAGS@,$FCFLAGS,;t t
15037 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15038   s,@CPP@,$CPP,;t t
15039   s,@EGREP@,$EGREP,;t t
9357 – s,@LIBOBJS@,$LIBOBJS,;t t
9358 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
9359 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
9360 – s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15040   s,@LN_S@,$LN_S,;t t
15041   s,@SET_MAKE@,$SET_MAKE,;t t
15042   s,@RANLIB@,$RANLIB,;t t
15043   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
15044 < s,@YACC@,$YACC,;t t
15045 < s,@LEX@,$LEX,;t t
15046 < s,@LEXLIB@,$LEXLIB,;t t
15047 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15044 > s,@PERLINTERP@,$PERLINTERP,;t t
15045 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15046 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15047 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15048 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15049   s,@AR@,$AR,;t t
15050   s,@PS@,$PS,;t t
15051 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15052 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15053 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15054 + s,@FCLIBS@,$FCLIBS,;t t
15055 + s,@FC_FUNC@,$FC_FUNC,;t t
15056 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15057 + s,@MOD@,$MOD,;t t
15058 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15059 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15060 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15061 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15062 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
15063 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
15064 + s,@ZLIB@,$ZLIB,;t t
15065 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
15066 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
15067 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
15068 + s,@LIBOBJS@,$LIBOBJS,;t t
15069 + s,@POW_LIB@,$POW_LIB,;t t
15070 + s,@CXXCPP@,$CXXCPP,;t t
15071 + s,@__func__@,$__func__,;t t
15072   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15073   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15074   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
15075   s,@MPI_LIB@,$MPI_LIB,;t t
15076   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15077   s,@USE_MPI@,$USE_MPI,;t t
9377 – s,@CXXCPP@,$CXXCPP,;t t
15078   s,@USE_CGAL@,$USE_CGAL,;t t
15079 < s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
15080 < s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
15081 < s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
9382 < s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
9383 < s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15079 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15080 > s,@CGAL_LDFLAGS@,$CGAL_LDFLAGS,;t t
15081 > s,@CGAL_CPPFLAGS@,$CGAL_CPPFLAGS,;t t
15082   s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15083   s,@DOXYGEN@,$DOXYGEN,;t t
15084   s,@DOT@,$DOT,;t t
# Line 9393 | Line 15091 | s,@SUBDIRS@,$SUBDIRS,;t t
15091   s,@OOPSE@,$OOPSE,;t t
15092   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15093   s,@SUBDIRS@,$SUBDIRS,;t t
9396 – s,@FFLAGS@,$FFLAGS,;t t
15094   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15095   CEOF
15096  
# Line 9631 | Line 15328 | s,@INSTALL@,$ac_INSTALL,;t t
15328      rm -f $tmp/out
15329    fi
15330  
15331 +  # Run the commands associated with the file.
15332 +  case $ac_file in
15333 +    make/Makefile ) chmod 0755 scripts/* ;;
15334 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15335 +    src/math/Makefile ) chmod 0755 scripts/* ;;
15336 +    src/applications/staticProps/Makefile ) chmod 0755 scripts/* ;;
15337 +    scripts/filepp ) chmod 0755 scripts/* ;;
15338 +  esac
15339   done
15340   _ACEOF
15341   cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines