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 768 by chuckv, Tue Nov 29 22:54:21 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 CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI 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)
882 –  --with-zlib=DIR root directory path of zlib installation defaults to
883 –                    /usr/local or /usr if not found in /usr/local
884 –  --without-zlib to disable zlib usage completely
884    --with-perl-shebang     override what perl thinks is the way for the kernel
885                            to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891 <  --with-cgal-makefile=FILE  CGAL makefile that should be used
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 993 | Line 997 | esac
997      else
998        echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
999      fi
1000 <    cd "$ac_popdir"
1000 >    cd $ac_popdir
1001    done
1002   fi
1003  
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 1014 | 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 1376 | 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 -*-
1380 < # Programming languages support.
1381 < # Copyright 2000, 2001
1382 < # Free Software Foundation, Inc.
1383 < #
1384 < # This program is free software; you can redistribute it and/or modify
1385 < # it under the terms of the GNU General Public License as published by
1386 < # the Free Software Foundation; either version 2, or (at your option)
1387 < # any later version.
1388 < #
1389 < # This program is distributed in the hope that it will be useful,
1390 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 < # GNU General Public License for more details.
1393 < #
1394 < # You should have received a copy of the GNU General Public License
1395 < # along with this program; if not, write to the Free Software
1396 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 < # 02111-1307, USA.
1398 < #
1399 < # As a special exception, the Free Software Foundation gives unlimited
1400 < # permission to copy, distribute and modify the configure scripts that
1401 < # are the output of Autoconf.  You need not follow the terms of the GNU
1402 < # General Public License when using or distributing such scripts, even
1403 < # though portions of the text of Autoconf appear in them.  The GNU
1404 < # General Public License (GPL) does govern all other use of the material
1405 < # that constitutes the Autoconf program.
1406 < #
1407 < # Certain portions of the Autoconf source text are designed to be copied
1408 < # (in certain cases, depending on the input) into the output of
1409 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 < # source text consists of comments plus executable code that decides which
1411 < # of the data portions to output in any given case.  We call these
1412 < # comments and executable code the "non-data" portions.  Autoconf never
1413 < # copies any of the non-data portions into its output.
1414 < #
1415 < # This special exception to the GPL applies to versions of Autoconf
1416 < # released by the Free Software Foundation.  When you make and
1417 < # distribute a modified version of Autoconf, you may extend this special
1418 < # exception to the GPL to apply to your modified version as well, *unless*
1419 < # your modified version has the potential to copy into its output some
1420 < # of the text that was the non-data portion of the version that you started
1421 < # with.  (In other words, unless your change moves or copies text from
1422 < # the non-data portions to the data portions.)  If your modification has
1423 < # such potential, you must delete any notice of this special exception
1424 < # to the GPL from your modified version.
1425 < #
1426 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 < # many others).
1383 >          ac_config_headers="$ac_config_headers src/config.h"
1384  
1385  
1430 – # Table of Contents:
1431 – #
1432 – # 1. Language selection
1433 – #    and routines to produce programs in a given language.
1434 – #  a. Fortran 77 (to be moved from aclang.m4)
1435 – #  b. Fortran 90
1436 – #  c. Fortran 95
1437 – #
1438 – # 2. Producing programs in a given language.
1439 – #  a. Fortran 77 (to be moved from aclang.m4)
1440 – #  b. Fortran 90
1441 – #  c. Fortran 95
1442 – #
1443 – # 3. Looking for a compiler
1444 – #    And possibly the associated preprocessor.
1445 – #  a. Fortran 77 (to be moved from aclang.m4)
1446 – #  b. Fortran 90
1447 – #  c. Fortran 95
1448 – #
1449 – # 4. Compilers' characteristics.
1450 – #  a. Fortran 77 (to be moved from aclang.m4)
1451 – #  b. Fortran 90
1452 – #  c. Fortran 95
1386  
1454 – # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 – # ---------------------------------------------------------------------------
1456 – #
1457 – # Processing the elements of a list is tedious in shell programming,
1458 – # as lists tend to be implemented as space delimited strings.
1459 – #
1460 – # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 – # if ELEMENT is a member of LIST, otherwise it executes
1462 – # ACTION-IF-NOT-FOUND.
1463 – # _AC_LIST_MEMBER_IF
1387  
1388  
1389  
1467 – # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 – # -------------------------------------------------
1469 – #
1470 – # Specifying options to the compiler (whether it be the C, C++ or
1471 – # Fortran 77 compiler) that are meant for the linker is compiler
1472 – # dependent.  This macro lets you give options to the compiler that
1473 – # are meant for the linker in a portable, compiler-independent way.
1474 – #
1475 – # This macro take two arguments, a list of linker options that the
1476 – # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 – # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 – # appended to the shell variable in a compiler-dependent way.
1479 – #
1480 – # For example, if the selected language is C, then this:
1481 – #
1482 – #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 – #
1484 – # will expand into this if the selected C compiler is gcc:
1485 – #
1486 – #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 – #
1488 – # otherwise, it will expand into this:
1489 – #
1490 – #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 – #
1492 – # You are encouraged to add support for compilers that this macro
1493 – # doesn't currently support.
1494 – # FIXME: Get rid of this macro.
1495 – # _AC_LINKER_OPTION
1390  
1391  
1392  
1499 – ## ----------------------- ##
1500 – ## 1. Language selection.  ##
1501 – ## ----------------------- ##
1393  
1503 – # ----------------------------- #
1504 – # 1b. The Fortran 90 language.  #
1505 – # ----------------------------- #
1394  
1507 – # AC_LANG(Fortran 90)
1508 – # -------------------
1395  
1396  
1397  
1512 – # _AC_LANG_ABBREV(Fortran 90)
1513 – # ---------------------------
1398  
1399  
1400  
1517 – # ----------------------------- #
1518 – # 1c. The Fortran 95 language.  #
1519 – # ----------------------------- #
1401  
1521 – # AC_LANG(Fortran 95)
1522 – # -------------------
1402  
1403  
1404  
1526 – # _AC_LANG_ABBREV(Fortran 95)
1527 – # ---------------------------
1405  
1406  
1407  
1531 – ## ---------------------- ##
1532 – ## 2.Producing programs.  ##
1533 – ## ---------------------- ##
1408  
1535 – # ------------------------ #
1536 – # 2b. Fortran 90 sources.  #
1537 – # ------------------------ #
1409  
1539 – # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 – # --------------------------------
1410  
1411  
1412  
1544 – # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 – # -----------------------------------------------
1413  
1414  
1548 – # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 – # --------------------------------------------
1415  
1416  
1417  
1553 – # ------------------------ #
1554 – # 2c. Fortran 95 sources.  #
1555 – # ------------------------ #
1418  
1557 – # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 – # --------------------------------
1419  
1420  
1561 – # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 – # -----------------------------------------------
1421  
1422  
1565 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 – # --------------------------------------------
1423  
1424  
1425  
1570 – ## -------------------------------------------- ##
1571 – ## 3. Looking for Compilers and Preprocessors.  ##
1572 – ## -------------------------------------------- ##
1426  
1574 – # ----------------------------- #
1575 – # 3b. The Fortran 90 compiler.  #
1576 – # ----------------------------- #
1427  
1428 + #
1429 + #
1430 + #
1431  
1579 – # AC_LANG_PREPROC(Fortran 90)
1580 – # ---------------------------
1581 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1432  
1433  
1434  
1585 – # AC_LANG_COMPILER(Fortran 90)
1586 – # ----------------------------
1587 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 – # AC_REQUIRE'able.
1435  
1436  
1437 <
1438 < # AC_PROG_F90([COMPILERS...])
1593 < # ---------------------------
1594 < # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 < # for.
1437 > # AC_F90_MODULE_NAMES
1438 > # -------------------
1439   #
1440 < # Compilers are ordered by
1598 < #  1. F90, F95
1599 < #  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.
1602 < # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1603 < # lf95 is the Lahey-Fujitsu compiler.
1604 < # epcf90 is the "Edinburgh Portable Compiler" F90.
1605 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1606 < # AC_PROG_F90
1442 > # AC_F90_MODULE_NAMES
1443  
1444  
1609 – # ----------------------------- #
1610 – # 3c. The Fortran 95 compiler.  #
1611 – # ----------------------------- #
1445  
1446  
1614 – # AC_LANG_PREPROC(Fortran 95)
1615 – # ---------------------------
1616 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1447  
1448  
1449  
1620 – # AC_LANG_COMPILER(Fortran 95)
1621 – # ----------------------------
1622 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 – # AC_REQUIRE'able.
1450  
1451  
1452  
1627 – # AC_PROG_F95([COMPILERS...])
1628 – # ---------------------------
1629 – # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 – # for.
1631 – #
1632 – # Compilers are ordered by
1633 – #  1. Good/tested native compilers, bad/untested native compilers
1634 – #
1635 – # xlf95 is the IBM (AIX) F95 compiler.
1636 – # lf95 is the Lahey-Fujitsu compiler.
1637 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1638 – # AC_PROG_F95
1453  
1454  
1641 – ## ------------------------------- ##
1642 – ## 4. Compilers' characteristics.  ##
1643 – ## ------------------------------- ##
1455  
1456  
1646 – # ---------------------------------------- #
1647 – # 4b. Fortan 90 compiler characteristics.  #
1648 – # ---------------------------------------- #
1457  
1458  
1651 – # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1652 – # -------------------------------------------------
1653 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1654 – # (which default value, $ac_cv_prog_f90_v, is computed by
1655 – # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1656 – # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1657 – # so that any link flags that are echoed by the compiler appear as
1658 – # space-separated items.
1659 – # _AC_PROG_F90_V_OUTPUT
1459  
1460  
1662 – # _AC_PROG_F90_V
1663 – # --------------
1664 – #
1665 – # Determine the flag that causes the Fortran 90 compiler to print
1666 – # information of library and object files (normally -v)
1667 – # Needed for AC_F90_LIBRARY_FLAGS
1668 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1669 – # _AC_PROG_F90_V
1461  
1462  
1672 – # AC_F90_LIBRARY_LDFLAGS
1673 – # ----------------------
1674 – #
1675 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 – # intrinsic and run-time libraries that are required to successfully
1677 – # link a Fortran 90 program or shared library.  The output variable
1678 – # F90LIBS is set to these flags.
1679 – #
1680 – # This macro is intended to be used in those situations when it is
1681 – # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 – # program or shared library.
1683 – #
1684 – # For example, if object files from a C++ and Fortran 90 compiler must
1685 – # be linked together, then the C++ compiler/linker must be used for
1686 – # linking (since special C++-ish things need to happen at link time
1687 – # like calling global constructors, instantiating templates, enabling
1688 – # exception support, etc.).
1689 – #
1690 – # However, the Fortran 90 intrinsic and run-time libraries must be
1691 – # linked in as well, but the C++ compiler/linker doesn't know how to
1692 – # add these Fortran 90 libraries.  Hence, the macro
1693 – # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 – # libraries.
1695 – #
1696 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 – # AC_F90_LIBRARY_LDFLAGS
1463  
1464  
1700 – # _AC_F90_NAME_MANGLING
1701 – # ---------------------
1702 – # Test for the name mangling scheme used by the Fortran 90 compiler.
1703 – #
1704 – # Sets ac_cv_f90_mangling. The value contains three fields, separated
1705 – # by commas:
1706 – #
1707 – # lower case / upper case:
1708 – #    case translation of the Fortan 90 symbols
1709 – # underscore / no underscore:
1710 – #    whether the compiler appends "_" to symbol names
1711 – # extra underscore / no extra underscore:
1712 – #    whether the compiler appends an extra "_" to symbol names already
1713 – #    containing at least one underscore
1714 – #
1715 – # _AC_F90_NAME_MANGLING
1465  
1717 – # The replacement is empty.
1466  
1467  
1468  
1721 – # AC_F90_WRAPPERS
1722 – # ---------------
1723 – # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1724 – # properly mangle the names of C identifiers, and C identifiers with
1725 – # underscores, respectively, so that they match the name mangling
1726 – # scheme used by the Fortran 90 compiler.
1727 – # AC_F90_WRAPPERS
1469  
1470  
1730 – # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1731 – # ------------------------------------
1732 – # For a Fortran subroutine of given NAME, define a shell variable
1733 – # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1734 – # argument is not supplied, it defaults to NAME.
1735 – # AC_F90_FUNC
1471  
1472  
1738 – # ---------------------------------------- #
1739 – # 4c. Fortan 95 compiler characteristics.  #
1740 – # ---------------------------------------- #
1473  
1474  
1743 – # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1744 – # -------------------------------------------------
1745 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1746 – # (which default value, $ac_cv_prog_f95_v, is computed by
1747 – # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1748 – # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1749 – # so that any link flags that are echoed by the compiler appear as
1750 – # space-separated items.
1751 – # _AC_PROG_F95_V_OUTPUT
1475  
1476  
1754 – # _AC_PROG_F95_V
1755 – # --------------
1756 – #
1757 – # Determine the flag that causes the Fortran 95 compiler to print
1758 – # information of library and object files (normally -v)
1759 – # Needed for AC_F95_LIBRARY_FLAGS
1760 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 – # _AC_PROG_F95_V
1477  
1478  
1764 – # AC_F95_LIBRARY_LDFLAGS
1765 – # ----------------------
1766 – #
1767 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 – # intrinsic and run-time libraries that are required to successfully
1769 – # link a Fortran 95 program or shared library.  The output variable
1770 – # F95LIBS is set to these flags.
1771 – #
1772 – # This macro is intended to be used in those situations when it is
1773 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 – # program or shared library.
1775 – #
1776 – # For example, if object files from a C++ and Fortran 95 compiler must
1777 – # be linked together, then the C++ compiler/linker must be used for
1778 – # linking (since special C++-ish things need to happen at link time
1779 – # like calling global constructors, instantiating templates, enabling
1780 – # exception support, etc.).
1781 – #
1782 – # However, the Fortran 95 intrinsic and run-time libraries must be
1783 – # linked in as well, but the C++ compiler/linker doesn't know how to
1784 – # add these Fortran 95 libraries.  Hence, the macro
1785 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 – # libraries.
1787 – #
1788 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 – # AC_F95_LIBRARY_LDFLAGS
1479  
1480  
1792 – # _AC_F95_NAME_MANGLING
1793 – # ---------------------
1794 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 – #
1796 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 – # by commas:
1798 – #
1799 – # lower case / upper case:
1800 – #    case translation of the Fortan 95 symbols
1801 – # underscore / no underscore:
1802 – #    whether the compiler appends "_" to symbol names
1803 – # extra underscore / no extra underscore:
1804 – #    whether the compiler appends an extra "_" to symbol names already
1805 – #    containing at least one underscore
1806 – #
1807 – # _AC_F95_NAME_MANGLING
1481  
1809 – # The replacement is empty.
1482  
1483  
1484  
1813 – # AC_F95_WRAPPERS
1814 – # ---------------
1815 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816 – # properly mangle the names of C identifiers, and C identifiers with
1817 – # underscores, respectively, so that they match the name mangling
1818 – # scheme used by the Fortran 95 compiler.
1819 – # AC_F95_WRAPPERS
1485  
1486  
1822 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823 – # ------------------------------------
1824 – # For a Fortran subroutine of given NAME, define a shell variable
1825 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826 – # argument is not supplied, it defaults to NAME.
1827 – # AC_F95_FUNC
1487  
1829 – # AC_F90_MODULE_NAMES
1830 – # -------------------
1831 – #
1832 – # Figure out how the Fortran 90 compiler constructs module file names
1833 – #
1834 – # AC_F90_MODULE_NAMES
1488  
1489  
1490  
# Line 1885 | Line 1538 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1538  
1539  
1540  
1888 – #
1889 – #
1890 – #
1541  
1542  
1543  
# Line 1896 | Line 1546 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1546  
1547  
1548  
1899 – # set program name
1900 – PROGNAME="oopse"
1549  
1550  
1903 – # there are two ways to do debugging.  One with the --enable-debug flag
1904 – # and one using the DEBUG environment variable
1551  
1552 < debug=0
1553 < # Check whether --enable-debug or --disable-debug was given.
1554 < if test "${enable_debug+set}" = set; then
1909 <  enableval="$enable_debug"
1910 <  debug=1
1911 < fi;
1912 < if test "${DEBUG}"; then
1552 > # This is taken from http://autoqt.sourceforge.net/
1553 > # Copyright (c) 2002, Geoffrey Wossum
1554 > # All rights reserved.
1555  
1556 < cat >>confdefs.h <<\_ACEOF
1557 < #define debug 1
1558 < _ACEOF
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 <  msg="$msg, debug mode"
1561 < fi
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 1977 | 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 2002 | 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 2011 | 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 2044 | 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 2053 | 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  
2072 – test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2073 – See \`config.log' for more details." >&5
2074 – echo "$as_me: error: no acceptable C compiler found in \$PATH
2075 – See \`config.log' for more details." >&2;}
2076 –   { (exit 1); exit 1; }; }
2077 –
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 2115 | 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 2159 | 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 2172 | 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 2188 | 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 2296 | 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 2328 | 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"                   || test ! -s conftest.err'
2057 >         { ac_try='test -z "$ac_cxx_werror_flag"
2058 >                         || test ! -s conftest.err'
2059    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2060    (eval $ac_try) 2>&5
2061    ac_status=$?
# Line 2348 | 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 2386 | 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"                   || test ! -s conftest.err'
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
2120    ac_status=$?
# Line 2398 | 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
2428 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2429 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2430 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2431 < else
2432 <  ac_cv_prog_cc_stdc=no
2433 < ac_save_CC=$CC
2434 < cat >conftest.$ac_ext <<_ACEOF
2435 < /* confdefs.h.  */
2436 < _ACEOF
2437 < cat confdefs.h >>conftest.$ac_ext
2438 < cat >>conftest.$ac_ext <<_ACEOF
2439 < /* end confdefs.h.  */
2440 < #include <stdarg.h>
2441 < #include <stdio.h>
2442 < #include <sys/types.h>
2443 < #include <sys/stat.h>
2444 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2445 < struct buf { int x; };
2446 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2447 < static char *e (p, i)
2448 <     char **p;
2449 <     int i;
2450 < {
2451 <  return p[i];
2452 < }
2453 < static char *f (char * (*g) (char **, int), char **p, ...)
2454 < {
2455 <  char *s;
2456 <  va_list v;
2457 <  va_start (v,p);
2458 <  s = g (p, va_arg (v,int));
2459 <  va_end (v);
2460 <  return s;
2461 < }
2462 <
2463 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2464 <   function prototypes and stuff, but not '\xHH' hex character constants.
2465 <   These don't provoke an error unfortunately, instead are silently treated
2466 <   as 'x'.  The following induces an error, until -std1 is added to get
2467 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2468 <   array size at least.  It's necessary to write '\x00'==0 to get something
2469 <   that's true only with -std1.  */
2470 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2471 <
2472 < int test (int i, double x);
2473 < struct s1 {int (*f) (int a);};
2474 < struct s2 {int (*f) (double a);};
2475 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2476 < int argc;
2477 < char **argv;
2478 < int
2479 < main ()
2480 < {
2481 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2482 <  ;
2483 <  return 0;
2484 < }
2485 < _ACEOF
2486 < # Don't try gcc -ansi; that turns off useful extensions and
2487 < # breaks some systems' header files.
2488 < # AIX                   -qlanglvl=ansi
2489 < # Ultrix and OSF/1      -std1
2490 < # HP-UX 10.20 and later -Ae
2491 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2492 < # SVR4                  -Xc -D__EXTENSIONS__
2493 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2494 < do
2495 <  CC="$ac_save_CC $ac_arg"
2496 <  rm -f conftest.$ac_objext
2497 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2498 <  (eval $ac_compile) 2>conftest.er1
2499 <  ac_status=$?
2500 <  grep -v '^ *+' conftest.er1 >conftest.err
2501 <  rm -f conftest.er1
2502 <  cat conftest.err >&5
2503 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2504 <  (exit $ac_status); } &&
2505 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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); }; } &&
2511 <         { ac_try='test -s conftest.$ac_objext'
2512 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2513 <  (eval $ac_try) 2>&5
2514 <  ac_status=$?
2515 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2516 <  (exit $ac_status); }; }; then
2517 <  ac_cv_prog_cc_stdc=$ac_arg
2518 < break
2519 < else
2520 <  echo "$as_me: failed program was:" >&5
2521 < sed 's/^/| /' conftest.$ac_ext >&5
2522 <
2523 < fi
2524 < rm -f conftest.err conftest.$ac_objext
2525 < done
2526 < rm -f conftest.$ac_ext conftest.$ac_objext
2527 < CC=$ac_save_CC
2528 <
2529 < fi
2530 <
2531 < case "x$ac_cv_prog_cc_stdc" in
2532 <  x|xno)
2533 <    echo "$as_me:$LINENO: result: none needed" >&5
2534 < echo "${ECHO_T}none needed" >&6 ;;
2535 <  *)
2536 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2537 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2538 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2539 < esac
2540 <
2541 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2542 < # in C++ we need to declare it.  In case someone uses the same compiler
2543 < # for both compiling C and C++ we need to have the C++ compiler decide
2544 < # the declaration of exit, since it's the most demanding environment.
2545 < cat >conftest.$ac_ext <<_ACEOF
2546 < #ifndef __cplusplus
2547 <  choke me
2548 < #endif
2549 < _ACEOF
2550 < rm -f conftest.$ac_objext
2551 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2552 <  (eval $ac_compile) 2>conftest.er1
2553 <  ac_status=$?
2554 <  grep -v '^ *+' conftest.er1 >conftest.err
2555 <  rm -f conftest.er1
2556 <  cat conftest.err >&5
2557 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2558 <  (exit $ac_status); } &&
2559 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2560 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2561 <  (eval $ac_try) 2>&5
2562 <  ac_status=$?
2563 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2564 <  (exit $ac_status); }; } &&
2565 <         { ac_try='test -s conftest.$ac_objext'
2566 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2567 <  (eval $ac_try) 2>&5
2568 <  ac_status=$?
2569 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2570 <  (exit $ac_status); }; }; then
2571 <  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 2601 | 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"                   || test ! -s conftest.err'
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
2192    ac_status=$?
# Line 2645 | 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"                   || test ! -s conftest.err'
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
2237    ac_status=$?
# Line 2672 | Line 2258 | fi
2258    echo '#endif'             >>confdefs.h
2259   fi
2260  
2675 – else
2676 –  echo "$as_me: failed program was:" >&5
2677 – sed 's/^/| /' conftest.$ac_ext >&5
2678 –
2679 – fi
2680 – 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'
2692 < 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 2710 | 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 2719 | 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 2752 | 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 2761 | 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
2775 – 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 2798 | 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 2830 | 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"                         || test ! -s conftest.err'
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
2421    ac_status=$?
# Line 2850 | 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 2888 | 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"                         || test ! -s conftest.err'
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
2480    ac_status=$?
# Line 2900 | 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
2937 <  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 ()
2532 < {
2533 < exit (42);
2534 <  ;
2535 <  return 0;
2536 < }
2537 < _ACEOF
2538 < rm -f conftest.$ac_objext
2539 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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 >  return p[i];
2540 > }
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 2959 | 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"                         || test ! -s conftest.err'
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
2597    ac_status=$?
# 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"                         || test ! -s conftest.err'
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
2743    ac_status=$?
# Line 3030 | 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
3043 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3044 <  echo 'void f(){}' > conftest.cc
3045 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3046 <    echo "$as_me:$LINENO: result: yes" >&5
3047 < echo "${ECHO_T}yes" >&6
3048 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3049 <  else
3050 <    echo "$as_me:$LINENO: result: no" >&5
3051 < echo "${ECHO_T}no" >&6
3052 <  fi
3053 <  rm -f conftest*
3054 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3055 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3056 <  echo 'void f(){}' > conftest.cc
3057 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3058 <    echo "$as_me:$LINENO: result: yes" >&5
3059 < echo "${ECHO_T}yes" >&6
3060 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3061 <  else
3062 <    echo "$as_me:$LINENO: result: no" >&5
3063 < echo "${ECHO_T}no" >&6
3064 <  fi
3065 <  rm -f conftest*
3066 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3067 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3068 <  echo 'void f(){}' > conftest.cc
3069 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3070 <    echo "$as_me:$LINENO: result: yes" >&5
3071 < echo "${ECHO_T}yes" >&6
3072 <    OOPSE_TEMPLATE_FLAGS="-pto"
3073 <  else
3074 <    echo "$as_me:$LINENO: result: no" >&5
3075 < echo "${ECHO_T}no" >&6
3076 <  fi
3077 <  rm -f conftest*
3078 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3079 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3080 <  echo 'void f(){}' > conftest.cc
3081 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3082 <    echo "$as_me:$LINENO: result: yes" >&5
3083 < echo "${ECHO_T}yes" >&6
3084 <
3085 <
3086 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3087 <  else
3088 <    echo "$as_me:$LINENO: result: no" >&5
3089 < echo "${ECHO_T}no" >&6
3090 <  fi
3091 < fi
3092 <
3093 <
3094 <
3095 <
3096 < ac_ext=f90
3097 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3098 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3099 < 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 3117 | 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 3126 | 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 3159 | 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 3168 | 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 <
3198 < program main
3199 <
2901 >      program main
2902   #ifndef __GNUC__
2903         choke me
2904   #endif
2905  
2906 < end program main
3205 <
2906 >      end
2907   _ACEOF
2908   rm -f conftest.$ac_objext
2909   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3213 | 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"                         || test ! -s conftest.err'
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
2921    ac_status=$?
# Line 3233 | 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 <
3250 <
3251 <
3252 <
3253 < # Try to determine native compiler flags that allow us to use F90 suffix
3254 < # for preprocessed f90 source.
3255 <
3256 < if test "$ac_test_PREPFLAG" != "set"; then
3257 <  PREPFLAG=""
3258 <  case "${host_cpu}-${host_os}" in
3259 <
3260 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3261 <                    PREPFLAG="-fpp1 "
3262 <                fi;;
3263 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3264 <                    PREPFLAG="-qsuffix=cpp=F90 "
3265 <                fi;;
3266 <  *darwin*)
3267 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3268 <                PREPFLAG="-qsuffix=cpp=F90 "
3269 <        fi;;
3270 <  esac
3271 <
3272 <  if test -z "$PREPFLAG"; then
3273 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3274 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3275 <        PREPFLAG=""
3276 <  fi
3277 <
3278 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3279 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3280 <
3281 <
3282 <  ac_ext=f90
3283 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3284 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3285 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3286 <
3287 <  ac_save_ext=$ac_ext
3288 <  ac_ext=F90
3289 <  ac_save_F90FLAGS=$F90FLAGS
3290 <
3291 <  if test "$PREPFLAG"; then
3292 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3293 < fi
3294 <
3295 <    cat >conftest.$ac_ext <<_ACEOF
3296 <
3297 <
3298 < program main
3299 <
3300 <  integer :: i
3301 <  i = 1
3302 <
3303 <
3304 < end program main
3305 <
2956 >      end
2957   _ACEOF
2958   rm -f conftest.$ac_objext
2959   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3313 | 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"                         || test ! -s conftest.err'
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
2971    ac_status=$?
# Line 3325 | 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
3352 < echo "${ECHO_T}no" >&6
3353 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3354 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3355 <   { (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 <
3123 <
3124 <
3125 < # Try to determine native compiler flags that allow us to use F90 suffix
3126 < # for preprocessed f90 source with -D type defines
3365 <
3366 < if test "$ac_test_PREPDEFFLAG" != "set"; then
3367 <  PREPDEFFLAG=""
3368 <  case "${host_cpu}-${host_os}" in
3369 <
3370 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3371 <                    PREPDEFFLAG=" "
3372 <                fi;;
3373 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3374 <                    PREPDEFFLAG="-WF,"
3375 <                fi;;
3376 <  *darwin*)
3377 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3378 <                PREPDEFFLAG="-WF,"
3379 <        fi;;
3380 <  esac
3381 <
3382 <  if test -z "$PREPDEFFLAG"; then
3383 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3384 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3385 <        PREPDEFFLAG=" "
3386 <  fi
3387 <
3388 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3389 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3390 <
3391 <
3392 <  ac_ext=f90
3393 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3394 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3395 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3396 <
3397 <  ac_save_ext=$ac_ext
3398 <  ac_ext=F90
3399 <  ac_save_F90FLAGS=$F90FLAGS
3400 <
3401 <  if test "$PREPDEFFLAG"; then
3402 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
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 <    cat >conftest.$ac_ext <<_ACEOF
3129 >    done
3130 >    ac_cv_prog_CPP=$CPP
3131  
3132 <
3133 < program main
3134 <
3135 <  integer :: i
3136 < #ifdef TEST
3137 <  i = 1
3132 > fi
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"                         || test ! -s conftest.err'
3208 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3209 <  (eval $ac_try) 2>&5
3210 <  ac_status=$?
3211 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3212 <  (exit $ac_status); }; } &&
3436 <         { ac_try='test -s conftest.$ac_objext'
3437 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3438 <  (eval $ac_try) 2>&5
3439 <  ac_status=$?
3440 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3441 <  (exit $ac_status); }; }; then
3442 <  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
3469 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3470 <   { (exit 1); exit 1; }; }
3471 <  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
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  
3479 –
3480 –
3481 – ac_ext=f90
3482 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3483 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3484 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3485 – echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3486 – echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3487 – if test "${ac_cv_prog_f90_v+set}" = set; then
3488 –  echo $ECHO_N "(cached) $ECHO_C" >&6
3489 – else
3490 –
3491 – cat >conftest.$ac_ext <<_ACEOF
3492 –
3493 – program main
3494 –
3495 –
3496 – end program main
3497 –
3498 – _ACEOF
3499 – rm -f conftest.$ac_objext
3500 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3501 –  (eval $ac_compile) 2>conftest.er1
3502 –  ac_status=$?
3503 –  grep -v '^ *+' conftest.er1 >conftest.err
3504 –  rm -f conftest.er1
3505 –  cat conftest.err >&5
3506 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3507 –  (exit $ac_status); } &&
3508 –         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3509 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3510 –  (eval $ac_try) 2>&5
3511 –  ac_status=$?
3512 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513 –  (exit $ac_status); }; } &&
3514 –         { ac_try='test -s conftest.$ac_objext'
3515 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3516 –  (eval $ac_try) 2>&5
3517 –  ac_status=$?
3518 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3519 –  (exit $ac_status); }; }; then
3520 –  ac_cv_prog_f90_v=
3521 – # Try some options frequently used verbose output
3522 – for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3523 –  ac_ext=f90
3524 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3525 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3526 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3527 –
3528 – cat >conftest.$ac_ext <<_ACEOF
3529 –
3530 – program main
3531 –
3532 –
3533 – end program main
3534 –
3535 – _ACEOF
3536 –
3537 – # Compile and link our simple test program by passing a flag (argument
3538 – # 1 to this macro) to the Fortran 90 compiler in order to get
3539 – # "verbose" output that we can then parse for the Fortran 90 linker
3540 – # flags.
3541 – ac_save_F90FLAGS=$F90FLAGS
3542 – F90FLAGS="$F90FLAGS $ac_verb"
3543 –
3544 – (eval echo $as_me:3544: \"$ac_link\") >&5
3545 – ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3546 – echo "$ac_f90_v_output" >&5
3547 – F90FLAGS=$ac_save_F90FLAGS
3548 –
3549 – rm -f conftest.*
3550 – ac_ext=f90
3551 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3552 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3553 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3554 –
3555 – # If we are using xlf then replace all the commas with spaces.
3556 – if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3557 –  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3328   fi
3559 –
3560 – # If we are using Cray Fortran then delete quotes.
3561 – # Use "\"" instead of '"' for font-lock-mode.
3562 – # FIXME: a more general fix for quoted arguments with spaces?
3563 – if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3564 –  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3329   fi
3330 <  # look for -l* and *.a constructs in the output
3331 <  for ac_arg in $ac_f90_v_output; do
3332 <     case $ac_arg in
3333 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3570 <          ac_cv_prog_f90_v=$ac_verb
3571 <          break 2 ;;
3572 <     esac
3573 <  done
3574 < done
3575 < if test -z "$ac_cv_prog_f90_v"; then
3576 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3577 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3578 < 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 <  echo "$as_me: failed program was:" >&5
3336 < sed 's/^/| /' conftest.$ac_ext >&5
3582 <
3583 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3584 < echo "$as_me: WARNING: compilation failed" >&2;}
3335 >  echo "$as_me:$LINENO: result: no" >&5
3336 > echo "${ECHO_T}no" >&6
3337   fi
3586 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3338  
3339   fi
3340 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3341 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3342 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3343 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3344 < if test "${ac_cv_flibs+set}" = set; then
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 "x$F90LIBS" != "x"; then
3350 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
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 + done
3365  
3366 < ac_ext=f90
3367 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3368 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3369 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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:$LINENO: result: no" >&5
3375 > echo "${ECHO_T}no" >&6
3376 > fi
3377  
3378 < cat >conftest.$ac_ext <<_ACEOF
3378 >  RANLIB=$ac_ct_RANLIB
3379 > else
3380 >  RANLIB="$ac_cv_prog_RANLIB"
3381 > fi
3382  
3607 – program main
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 +  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 < end program main
3411 <
3412 < _ACEOF
3613 <
3614 < # Compile and link our simple test program by passing a flag (argument
3615 < # 1 to this macro) to the Fortran 90 compiler in order to get
3616 < # "verbose" output that we can then parse for the Fortran 90 linker
3617 < # flags.
3618 < ac_save_F90FLAGS=$F90FLAGS
3619 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3620 <
3621 < (eval echo $as_me:3621: \"$ac_link\") >&5
3622 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3623 < echo "$ac_f90_v_output" >&5
3624 < F90FLAGS=$ac_save_F90FLAGS
3625 <
3626 < rm -f conftest.*
3627 < ac_ext=f90
3628 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3629 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3630 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3631 <
3632 < # If we are using xlf then replace all the commas with spaces.
3633 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3634 <  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  
3427 +
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_f90_v_output
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_f90libs; do
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
# Line 3663 | 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 3681 | 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"
3706 –
4292                  shift; shift
4293                  set X $ac_arg "$@"
4294                  ;;
# Line 3712 | 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 3723 | 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 3740 | 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 3755 | 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 &&
3761 –
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  
3778 – ac_ext=f90
3779 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3780 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3781 – 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
3793 < cat >conftest.$ac_ext <<_ACEOF
3794 < subroutine foobar()
3795 < return
3796 < end
3797 < subroutine foo_bar()
3798 < return
3799 < end
3800 < _ACEOF
3801 < rm -f conftest.$ac_objext
3802 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3803 <  (eval $ac_compile) 2>conftest.er1
3804 <  ac_status=$?
3805 <  grep -v '^ *+' conftest.er1 >conftest.err
3806 <  rm -f conftest.er1
3807 <  cat conftest.err >&5
3808 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3809 <  (exit $ac_status); } &&
3810 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3811 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3812 <  (eval $ac_try) 2>&5
3813 <  ac_status=$?
3814 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815 <  (exit $ac_status); }; } &&
3816 <         { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3822 <  mv conftest.$ac_objext cf90_test.$ac_objext
3823 <
3824 <  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"
3832 <
3833 <  ac_success=no
3834 <  for ac_foobar in foobar FOOBAR; do
3835 <    for ac_underscore in "" "_"; do
3836 <      ac_func="$ac_foobar$ac_underscore"
3837 <      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
3849 <   builtin and then its argument prototype would still apply.  */
3850 < char $ac_func ();
4403 > #endif
4404   int
4405   main ()
4406   {
4407 < $ac_func ();
4407 >
4408    ;
4409    return 0;
4410   }
# Line 3865 | Line 4418 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4418    cat conftest.err >&5
4419    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4420    (exit $ac_status); } &&
4421 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4421 >         { ac_try='test -z "$ac_c_werror_flag"
4422 >                         || test ! -s conftest.err'
4423    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4424    (eval $ac_try) 2>&5
4425    ac_status=$?
# Line 3877 | 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
3888 –    done
3889 –  done
4443  
4444 <  if test "$ac_success" = "yes"; then
4445 <     case $ac_foobar in
4446 <        foobar)
3894 <           ac_case=lower
3895 <           ac_foo_bar=foo_bar
3896 <           ;;
3897 <        FOOBAR)
3898 <           ac_case=upper
3899 <           ac_foo_bar=FOO_BAR
3900 <           ;;
3901 <     esac
3902 <
3903 <     ac_success_extra=no
3904 <     for ac_extra in "" "_"; do
3905 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3906 <
3907 <        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
3919 <   builtin and then its argument prototype would still apply.  */
3920 < char $ac_func ();
4460 > #endif
4461   int
4462   main ()
4463   {
4464 < $ac_func ();
4464 >
4465    ;
4466    return 0;
4467   }
# Line 3935 | Line 4475 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4475    cat conftest.err >&5
4476    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4477    (exit $ac_status); } &&
4478 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4478 >         { ac_try='test -z "$ac_c_werror_flag"
4479 >                         || test ! -s conftest.err'
4480    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4481    (eval $ac_try) 2>&5
4482    ac_status=$?
# Line 3947 | 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 3955 | 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"
3970 <        else
3971 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3972 <        fi
3973 <      else
3974 <        ac_cv_f90_mangling="unknown"
3975 <      fi
3976 <  else
3977 <     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 <  LIBS=$ac_save_LIBS
4523 <  ac_ext=f90
4524 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4525 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4526 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4527 <  rm -f cf90_test* conftest*
4528 < else
4529 <  echo "$as_me: failed program was:" >&5
4530 < sed 's/^/| /' conftest.$ac_ext >&5
4531 <
4532 < fi
4533 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4534 < ac_ext=f90
4535 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4536 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4537 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4538 <
4539 < fi
4540 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4541 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4542 <
4543 <
4544 <
4545 < case $ac_cv_f90_mangling in
4546 <  "lower case, no underscore, no extra underscore")
4547 <          cat >>confdefs.h <<\_ACEOF
4548 < #define F90_FUNC(name,NAME) name
4549 < _ACEOF
4550 <
4551 <          cat >>confdefs.h <<\_ACEOF
4552 < #define F90_FUNC_(name,NAME) name
4553 < _ACEOF
4554 < ;;
4555 <  "lower case, no underscore, extra underscore")
4556 <          cat >>confdefs.h <<\_ACEOF
4557 < #define F90_FUNC(name,NAME) name
4558 < _ACEOF
4559 <
4560 <          cat >>confdefs.h <<\_ACEOF
4561 < #define F90_FUNC_(name,NAME) name ## _
4562 < _ACEOF
4563 < ;;
4564 <  "lower case, underscore, no extra underscore")
4565 <          cat >>confdefs.h <<\_ACEOF
4566 < #define F90_FUNC(name,NAME) name ## _
4567 < _ACEOF
4568 <
4569 <          cat >>confdefs.h <<\_ACEOF
4570 < #define F90_FUNC_(name,NAME) name ## _
4571 < _ACEOF
4572 < ;;
4573 <  "lower case, underscore, extra underscore")
4574 <          cat >>confdefs.h <<\_ACEOF
4575 < #define F90_FUNC(name,NAME) name ## _
4576 < _ACEOF
4577 <
4578 <          cat >>confdefs.h <<\_ACEOF
4579 < #define F90_FUNC_(name,NAME) name ## __
4580 < _ACEOF
4581 < ;;
4582 <  "upper case, no underscore, no extra underscore")
4583 <          cat >>confdefs.h <<\_ACEOF
4584 < #define F90_FUNC(name,NAME) NAME
4585 < _ACEOF
4586 <
4587 <          cat >>confdefs.h <<\_ACEOF
4588 < #define F90_FUNC_(name,NAME) NAME
4589 < _ACEOF
4590 < ;;
4591 <  "upper case, no underscore, extra underscore")
4592 <          cat >>confdefs.h <<\_ACEOF
4593 < #define F90_FUNC(name,NAME) NAME
4594 < _ACEOF
4595 <
4596 <          cat >>confdefs.h <<\_ACEOF
4597 < #define F90_FUNC_(name,NAME) NAME ## _
4598 < _ACEOF
4599 < ;;
4600 <  "upper case, underscore, no extra underscore")
4601 <          cat >>confdefs.h <<\_ACEOF
4602 < #define F90_FUNC(name,NAME) NAME ## _
4603 < _ACEOF
4604 <
4605 <          cat >>confdefs.h <<\_ACEOF
4606 < #define F90_FUNC_(name,NAME) NAME ## _
4607 < _ACEOF
4608 < ;;
4609 <  "upper case, underscore, extra underscore")
4610 <          cat >>confdefs.h <<\_ACEOF
4611 < #define F90_FUNC(name,NAME) NAME ## _
4612 < _ACEOF
4613 <
4614 <          cat >>confdefs.h <<\_ACEOF
4615 < #define F90_FUNC_(name,NAME) NAME ## __
4616 < _ACEOF
4617 < ;;
4618 <  *)
4619 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4620 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4621 <          ;;
4622 < esac
4623 <
4624 <
4625 <
4626 <
4627 <
4628 < echo "$as_me:$LINENO: checking for module suffix" >&5
4629 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4630 < rm -f conftest*
4631 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4632 < rm -f work*
4633 < cat >conftest.f90 <<EOF
4634 <        module conftest
4635 <        integer n
4636 <        parameter (n=1)
4637 <        end module conftest
4638 < EOF
4639 < # SGI and absoft compilers generates module name in upper case!
4640 < testname="conftest"
4641 < modcase="lower"
4642 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4643 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4644 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4645 <    if test -z "$MOD" ; then
4646 <        MOD=`ls CONFTEST* 2>/dev/null \
4647 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4648 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4649 <        if test -n "$MOD" ; then
4650 <            testname="CONFTEST"
4651 <            modcase="upper"
4652 <        fi
4653 <    fi
4654 <    if test -z "$MOD" ; then
4655 <        echo "$as_me:$LINENO: result: unknown" >&5
4656 < echo "${ECHO_T}unknown" >&6
4657 <        # Use mod if we can't figure it out
4658 <        MOD="mod"
4659 <    else
4660 <        echo "$as_me:$LINENO: result: $MOD" >&5
4661 < echo "${ECHO_T}$MOD" >&6
4662 <    fi
4663 <    if test -s work.pcl ; then
4664 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4665 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4666 <    fi
4667 < else
4668 <    echo "$as_me:$LINENO: result: unknown" >&5
4669 < echo "${ECHO_T}unknown" >&6
4670 < fi
4671 <
4672 <
4673 <
4674 <
4675 <
4676 < # Check for module include path (some use -I, some (Solaris) use -M, some
4677 < # (absoft) use -p).
4678 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4679 < # specified, work.pcl and work.pc are created.  However, if you specify
4680 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4681 < # Use the module made above
4682 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4683 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4684 < rm -f conftest*
4685 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4686 < rm -f work*
4687 < cat >conftest.f90 <<EOF
4688 <        module conftest
4689 <        integer n
4690 <        parameter (n=1)
4691 <        end module conftest
4692 < EOF
4693 < # SGI and absoft compilers generates module name in upper case!
4694 < testname="conftest"
4695 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4696 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4697 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4698 <   if test -n "$mod" ; then
4699 <      testname="CONFTEST"
4700 <   fi
4701 <   madedir=0
4702 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4703 <   cp $testname.$MOD conf
4704 <   rm -f conftest* CONFTEST*
4705 <   cat >conftest1.f90 <<EOF
4706 <        program main
4707 <        use conftest
4708 <        print *, n
4709 <        end
4710 < EOF
4711 <   F90_WORK_FILES_ARG=""
4712 <   F90MODINCSPEC=""
4713 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4714 <       MODDIRFLAG="-I"
4715 <       F90MODINCSPEC="-I<dir>"
4716 <       echo "$as_me:$LINENO: result: -I" >&5
4717 < echo "${ECHO_T}-I" >&6
4718 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4719 <       MODDIRFLAG="-M"
4720 <       F90MODINCSPEC="-M<dir>"
4721 <       echo "$as_me:$LINENO: result: -M" >&5
4722 < echo "${ECHO_T}-M" >&6
4723 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4724 <       MODDIRFLAG="-p"
4725 <       F90MODINCSPEC="-p<dir>"
4726 <       echo "$as_me:$LINENO: result: -p" >&5
4727 < echo "${ECHO_T}-p" >&6
4728 <   elif test -s work.pc ; then
4729 <        cp work.pc conf/mpimod.pc
4730 <        echo "mpimod.pc" > conf/mpimod.pcl
4731 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4732 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4733 <            MODDIRFLAG='-cl,mpimod.pcl'
4734 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4735 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4736 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4737 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4738 <
4739 <        else
4740 <            # The version of the Intel compiler that I have refuses to let
4741 <            # you put the "work catalog" list anywhere but the current
4742 <            # directory. For example, you cannot in
4743 <         :
4744 <        fi
4745 <   fi
4746 <   if test -z "MODDIRFLAG" ; then
4747 <       echo "$as_me:$LINENO: result: unknown" >&5
4748 < echo "${ECHO_T}unknown" >&6
4749 <   fi
4750 <
4751 <
4752 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4753 <   if test $madedir = 1 ; then rmdir conf ; fi
4754 < fi
4755 <
4756 <
4757 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4758 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4759 < if test "${ac_cv_f90_module_names+set}" = set; then
4760 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4761 < else
4762 <  ac_ext=f90
4763 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4764 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4765 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4766 <
4767 < # carry out the test in a new directory, so that we don't miss anything
4768 < mkdir conftest
4769 < cd conftest
4770 < cat >conftest.$ac_ext <<_ACEOF
4771 < MODULE Bar
4772 < END MODULE Bar
4773 < _ACEOF
4774 < rm -f conftest.$ac_objext
4775 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4776 <  (eval $ac_compile) 2>conftest.er1
4777 <  ac_status=$?
4778 <  grep -v '^ *+' conftest.er1 >conftest.err
4779 <  rm -f conftest.er1
4780 <  cat conftest.err >&5
4781 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4782 <  (exit $ac_status); } &&
4783 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
4784 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4785 <  (eval $ac_try) 2>&5
4786 <  ac_status=$?
4787 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4788 <  (exit $ac_status); }; } &&
4789 <         { ac_try='test -s conftest.$ac_objext'
4790 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4791 <  (eval $ac_try) 2>&5
4792 <  ac_status=$?
4793 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4794 <  (exit $ac_status); }; }; then
4795 <  ac_cv_f90_module_names=
4796 < ac_file_list=*
4797 < for ac_file in $ac_file_list; do
4798 <   case $ac_file in
4799 <      # don't care for original source and object files
4800 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4801 <          :
4802 <          ;;
4803 <      # look for new files derived from the file name
4804 <      *conftest*)
4805 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4806 <            ac_exists=false
4807 <  for ac_i in $ac_cv_f90_module_names; do
4808 <    if test x"$ac_pat" = x"$ac_i"; then
4809 <      ac_exists=true
4810 <      break
4811 <    fi
4812 <  done
4813 <
4814 <  if test x"$ac_exists" = xtrue; then
4815 <  :
4816 < else
4817 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4818 < fi
4819 <
4820 <          ;;
4821 <      # look for new files derived from the module name,
4822 <      # with different case translation schemes
4823 <      *Bar*)
4824 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4825 <            ac_exists=false
4826 <  for ac_i in $ac_cv_f90_module_names; do
4827 <    if test x"$ac_pat" = x"$ac_i"; then
4828 <      ac_exists=true
4829 <      break
4830 <    fi
4831 <  done
4832 <
4833 <  if test x"$ac_exists" = xtrue; then
4834 <  :
4835 < else
4836 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4837 < fi
4838 <
4839 <          ;;
4840 <      *bar*)
4841 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4842 <            ac_exists=false
4843 <  for ac_i in $ac_cv_f90_module_names; do
4844 <    if test x"$ac_pat" = x"$ac_i"; then
4845 <      ac_exists=true
4846 <      break
4847 <    fi
4848 <  done
4849 <
4850 <  if test x"$ac_exists" = xtrue; then
4851 <  :
4852 < else
4853 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4854 < fi
4855 <
4856 <          ;;
4857 <      *BAR*)
4858 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4859 <            ac_exists=false
4860 <  for ac_i in $ac_cv_f90_module_names; do
4861 <    if test x"$ac_pat" = x"$ac_i"; then
4862 <      ac_exists=true
4863 <      break
4864 <    fi
4865 <  done
4866 <
4867 <  if test x"$ac_exists" = xtrue; then
4868 <  :
4869 < else
4870 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4871 < fi
4872 <
4873 <          ;;
4874 <       # Other files - we have no idea how they are generated
4875 <       *)
4876 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4877 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4878 <          ;;
4879 <   esac
4880 < done
4881 < if test "x$ac_cv_f90_module_names" = "x"; then
4882 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4883 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4884 < fi
4885 <
4886 < else
4887 <  echo "$as_me: failed program was:" >&5
4888 < sed 's/^/| /' conftest.$ac_ext >&5
4889 <
4890 < ac_cv_f90_module_names=
4891 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4892 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4893 < fi
4894 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4895 < cd ..
4896 < # cleanup
4897 < rm -rf conftest
4898 < ac_ext=f90
4899 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4900 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4901 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4902 <
4903 < fi
4904 < echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4905 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
4906 <
4907 < # We now generate a shell script that will help us to figure out the correct
4908 < # module file names, using the value of ac_cv_f90_module_names
4909 <
4910 < echo "Generating shell script modnam"
4911 <
4912 < cat > scripts/modnam << EOF
4913 < #! /bin/sh
4914 < # This script is auto-generated by configure
4915 < #
4916 < usage="\\
4917 < Usage: \$0 [FILES]
4918 <
4919 < [FILES] are Fortran 90 source files.
4920 < The output is a list of module file names that the Fortran 90 compiler
4921 < generates when compiling [FILES]."
4922 <
4923 < list=
4924 < empty=
4925 <
4926 < if test \$# -eq 0; then
4927 <   echo "\$usage"; exit 0
4928 < fi
4929 <
4930 < while test \$# != 0; do
4931 <
4932 <  file=\$1
4933 <  shift
4934 <
4935 < # strip suffix
4936 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4937 <
4938 <  test ! -f \$file && continue
4939 <
4940 < # Look for module definitions and transform them to upper / lower case
4941 <  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4942 <  upper=\`echo \$mods | tr a-z A-Z\`
4943 <  lower=\`echo \$mods | tr A-Z a-z\`
4944 <
4945 < # Here, the patterns for generating module file names were inserted by configure
4946 <  for trans in $ac_cv_f90_module_names; do
4947 <
4948 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4949 <    var=empty
4950 <    case \$pat in
4951 <       %MODULE%)
4952 <          var=upper ;;
4953 <       %Module%)
4954 <          var=mods ;;
4955 <       %module%)
4956 <          var=lower ;;
4957 <       %FILE%)
4958 <          test -n "\$mods" && var=base ;;
4959 <    esac
4960 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4961 <    list="\$list \$new"
4962 <  done
4963 < done
4964 <
4965 < echo \$list
4966 < # end of configure-generated script
4967 < EOF
4968 < chmod 755 scripts/modnam
4969 <
4970 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4971 < F90_MODULE_NAMES=empty
4972 < case $pat in
4973 <       %MODULE%)
4974 <          F90_MODULE_NAMES=UPPER ;;
4975 <       %Module%)
4976 <          F90_MODULE_NAMES=Mixed ;;
4977 <       %module%)
4978 <          F90_MODULE_NAMES=lower ;;
4979 <       *)
4980 <          F90_MODULE_NAMES=unknown ;;
4981 < esac
4982 <
4983 < ac_ext=c
4984 < ac_cpp='$CPP $CPPFLAGS'
4985 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4986 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4987 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4988 <
4989 <
4990 < ac_ext=cc
4991 < ac_cpp='$CXXCPP $CPPFLAGS'
4992 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4993 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4994 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4995 <
4996 <
4997 <
4998 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
4999 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5000 < if test "${ac_cv_lib_m_asin+set}" = set; then
5001 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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 >  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
4780 >
4781 > fi
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 >
4796 > case $ac_cv_fc_mangling in
4797 >  "lower case, no underscore, no extra underscore")
4798 >          cat >>confdefs.h <<\_ACEOF
4799 > #define FC_FUNC(name,NAME) name
4800 > _ACEOF
4801 >
4802 >          cat >>confdefs.h <<\_ACEOF
4803 > #define FC_FUNC_(name,NAME) name
4804 > _ACEOF
4805 > ;;
4806 >  "lower case, no underscore, extra underscore")
4807 >          cat >>confdefs.h <<\_ACEOF
4808 > #define FC_FUNC(name,NAME) name
4809 > _ACEOF
4810 >
4811 >          cat >>confdefs.h <<\_ACEOF
4812 > #define FC_FUNC_(name,NAME) name ## _
4813 > _ACEOF
4814 > ;;
4815 >  "lower case, underscore, no extra underscore")
4816 >          cat >>confdefs.h <<\_ACEOF
4817 > #define FC_FUNC(name,NAME) name ## _
4818 > _ACEOF
4819 >
4820 >          cat >>confdefs.h <<\_ACEOF
4821 > #define FC_FUNC_(name,NAME) name ## _
4822 > _ACEOF
4823 > ;;
4824 >  "lower case, underscore, extra underscore")
4825 >          cat >>confdefs.h <<\_ACEOF
4826 > #define FC_FUNC(name,NAME) name ## _
4827 > _ACEOF
4828 >
4829 >          cat >>confdefs.h <<\_ACEOF
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 FC_FUNC(name,NAME) NAME
4836 > _ACEOF
4837 >
4838 >          cat >>confdefs.h <<\_ACEOF
4839 > #define FC_FUNC_(name,NAME) NAME
4840 > _ACEOF
4841 > ;;
4842 >  "upper case, no underscore, extra underscore")
4843 >          cat >>confdefs.h <<\_ACEOF
4844 > #define FC_FUNC(name,NAME) NAME
4845 > _ACEOF
4846 >
4847 >          cat >>confdefs.h <<\_ACEOF
4848 > #define FC_FUNC_(name,NAME) NAME ## _
4849 > _ACEOF
4850 > ;;
4851 >  "upper case, underscore, no extra underscore")
4852 >          cat >>confdefs.h <<\_ACEOF
4853 > #define FC_FUNC(name,NAME) NAME ## _
4854 > _ACEOF
4855 >
4856 >          cat >>confdefs.h <<\_ACEOF
4857 > #define FC_FUNC_(name,NAME) NAME ## _
4858 > _ACEOF
4859 > ;;
4860 >  "upper case, underscore, extra underscore")
4861 >          cat >>confdefs.h <<\_ACEOF
4862 > #define FC_FUNC(name,NAME) NAME ## _
4863 > _ACEOF
4864 >
4865 >          cat >>confdefs.h <<\_ACEOF
4866 > #define FC_FUNC_(name,NAME) NAME ## __
4867 > _ACEOF
4868 > ;;
4869 >  *)
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.$ac_ext <<EOF
5190 >        module conftest
5191 >        integer n
5192 >        parameter (n=1)
5193 >        end module conftest
5194 > EOF
5195 > # SGI and absoft compilers generates module name in upper case!
5196 > testname="conftest"
5197 > modcase="lower"
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.$ac_ext | grep -v CONFTEST.o`
5204 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5205 >        if test -n "$MOD" ; then
5206 >            testname="CONFTEST"
5207 >            modcase="upper"
5208 >        fi
5209 >    fi
5210 >    if test -z "$MOD" ; then
5211 >        echo "$as_me:$LINENO: result: unknown" >&5
5212 > echo "${ECHO_T}unknown" >&6
5213 >        # Use mod if we can't figure it out
5214 >        MOD="mod"
5215 >    else
5216 >        echo "$as_me:$LINENO: result: $MOD" >&5
5217 > echo "${ECHO_T}$MOD" >&6
5218 >    fi
5219 >    if test -s work.pcl ; then
5220 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5221 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5222 >    fi
5223 > else
5224 >    echo "$as_me:$LINENO: result: unknown" >&5
5225 > echo "${ECHO_T}unknown" >&6
5226 > fi
5227 >
5228 >
5229 >
5230 >
5231 >
5232 > # Check for module include path (some use -I, some (Solaris) use -M, some
5233 > # (absoft) use -p).
5234 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5235 > # specified, work.pcl and work.pc are created.  However, if you specify
5236 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5237 > # Use the module made above
5238 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5239 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
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.$ac_ext <<EOF
5244 >        module conftest
5245 >        integer n
5246 >        parameter (n=1)
5247 >        end module conftest
5248 > EOF
5249 > # SGI and absoft compilers generates module name in upper case!
5250 > testname="conftest"
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"
5256 >   fi
5257 >   madedir=0
5258 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5259 >   cp $testname.$MOD conf
5260 >   rm -f conftest* CONFTEST*
5261 >   cat >conftest1.$ac_ext <<EOF
5262 >        program main
5263 >        use conftest
5264 >        print *, n
5265 >        end
5266 > EOF
5267 >   F90_WORK_FILES_ARG=""
5268 >   F90MODINCSPEC=""
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 $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 $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
5283 > echo "${ECHO_T}-p" >&6
5284 >   elif test -s work.pc ; then
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 $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
5292 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5293 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5294 >
5295 >        else
5296 >            # The version of the Intel compiler that I have refuses to let
5297 >            # you put the "work catalog" list anywhere but the current
5298 >            # directory. For example, you cannot in
5299 >         :
5300 >        fi
5301 >   fi
5302 >   if test -z "MODDIRFLAG" ; then
5303 >       echo "$as_me:$LINENO: result: unknown" >&5
5304 > echo "${ECHO_T}unknown" >&6
5305 >   fi
5306 >
5307 >
5308 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5309 >   if test $madedir = 1 ; then rmdir conf ; fi
5310 > fi
5311 >
5312 >
5313 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5314 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5315 > if test "${ac_cv_f90_module_names+set}" = set; then
5316 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5317 > else
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
5325 > cd conftest
5326 > cat >conftest.$ac_ext <<_ACEOF
5327 > MODULE Bar
5328 > END MODULE Bar
5329 > _ACEOF
5330 > rm -f conftest.$ac_objext
5331 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5332 >  (eval $ac_compile) 2>conftest.er1
5333 >  ac_status=$?
5334 >  grep -v '^ *+' conftest.er1 >conftest.err
5335 >  rm -f conftest.er1
5336 >  cat conftest.err >&5
5337 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5338 >  (exit $ac_status); } &&
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
5343 >  ac_status=$?
5344 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5345 >  (exit $ac_status); }; } &&
5346 >         { ac_try='test -s conftest.$ac_objext'
5347 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5348 >  (eval $ac_try) 2>&5
5349 >  ac_status=$?
5350 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5351 >  (exit $ac_status); }; }; then
5352 >  ac_cv_f90_module_names=
5353 > ac_file_list=*
5354 > for ac_file in $ac_file_list; do
5355 >   case $ac_file in
5356 >      # don't care for original source and object files
5357 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5358 >          :
5359 >          ;;
5360 >      # look for new files derived from the file name
5361 >      *conftest*)
5362 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5363 >            ac_exists=false
5364 >  for ac_i in $ac_cv_f90_module_names; do
5365 >    if test x"$ac_pat" = x"$ac_i"; then
5366 >      ac_exists=true
5367 >      break
5368 >    fi
5369 >  done
5370 >
5371 >  if test x"$ac_exists" = xtrue; then
5372 >  :
5373 > else
5374 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5375 > fi
5376 >
5377 >          ;;
5378 >      # look for new files derived from the module name,
5379 >      # with different case translation schemes
5380 >      *Bar*)
5381 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5382 >            ac_exists=false
5383 >  for ac_i in $ac_cv_f90_module_names; do
5384 >    if test x"$ac_pat" = x"$ac_i"; then
5385 >      ac_exists=true
5386 >      break
5387 >    fi
5388 >  done
5389 >
5390 >  if test x"$ac_exists" = xtrue; then
5391 >  :
5392 > else
5393 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5394 > fi
5395 >
5396 >          ;;
5397 >      *bar*)
5398 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5399 >            ac_exists=false
5400 >  for ac_i in $ac_cv_f90_module_names; do
5401 >    if test x"$ac_pat" = x"$ac_i"; then
5402 >      ac_exists=true
5403 >      break
5404 >    fi
5405 >  done
5406 >
5407 >  if test x"$ac_exists" = xtrue; then
5408 >  :
5409 > else
5410 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5411 > fi
5412 >
5413 >          ;;
5414 >      *BAR*)
5415 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5416 >            ac_exists=false
5417 >  for ac_i in $ac_cv_f90_module_names; do
5418 >    if test x"$ac_pat" = x"$ac_i"; then
5419 >      ac_exists=true
5420 >      break
5421 >    fi
5422 >  done
5423 >
5424 >  if test x"$ac_exists" = xtrue; then
5425 >  :
5426 > else
5427 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5428 > fi
5429 >
5430 >          ;;
5431 >       # Other files - we have no idea how they are generated
5432 >       *)
5433 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5434 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5435 >          ;;
5436 >   esac
5437 > done
5438 > if test "x$ac_cv_f90_module_names" = "x"; then
5439 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5440 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5441 > fi
5442 >
5443 > else
5444 >  echo "$as_me: failed program was:" >&5
5445 > sed 's/^/| /' conftest.$ac_ext >&5
5446 >
5447 > ac_cv_f90_module_names=
5448 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5449 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5450 > fi
5451 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5452 > cd ..
5453 > # cleanup
5454 > rm -rf conftest
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
5462 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5463 >
5464 > # We now generate a shell script that will help us to figure out the correct
5465 > # module file names, using the value of ac_cv_f90_module_names
5466 >
5467 > echo "Generating shell script modnam"
5468 >
5469 > cat > scripts/modnam << EOF
5470 > #! /bin/sh
5471 > # This script is auto-generated by configure
5472 > #
5473 > usage="\\
5474 > Usage: \$0 [FILES]
5475 >
5476 > [FILES] are Fortran 90 source files.
5477 > The output is a list of module file names that the Fortran 90 compiler
5478 > generates when compiling [FILES]."
5479 >
5480 > list=
5481 > empty=
5482 >
5483 > if test \$# -eq 0; then
5484 >   echo "\$usage"; exit 0
5485 > fi
5486 >
5487 > while test \$# != 0; do
5488 >
5489 >  file=\$1
5490 >  shift
5491 >
5492 > # strip suffix
5493 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5494 >
5495 >  test ! -f \$file && continue
5496 >
5497 > # Look for module definitions and transform them to upper / lower case
5498 >  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
5499 >  upper=\`echo \$mods | tr a-z A-Z\`
5500 >  lower=\`echo \$mods | tr A-Z a-z\`
5501 >
5502 > # Here, the patterns for generating module file names were inserted by configure
5503 >  for trans in $ac_cv_f90_module_names; do
5504 >
5505 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5506 >    var=empty
5507 >    case \$pat in
5508 >       %MODULE%)
5509 >          var=upper ;;
5510 >       %Module%)
5511 >          var=mods ;;
5512 >       %module%)
5513 >          var=lower ;;
5514 >       %FILE%)
5515 >          test -n "\$mods" && var=base ;;
5516 >    esac
5517 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5518 >    list="\$list \$new"
5519 >  done
5520 > done
5521 >
5522 > echo \$list
5523 > # end of configure-generated script
5524 > EOF
5525 > chmod 755 scripts/modnam
5526 >
5527 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5528 > F90_MODULE_NAMES=empty
5529 > case $pat in
5530 >       %MODULE%)
5531 >          F90_MODULE_NAMES=UPPER ;;
5532 >       %Module%)
5533 >          F90_MODULE_NAMES=Mixed ;;
5534 >       %module%)
5535 >          F90_MODULE_NAMES=lower ;;
5536 >       *)
5537 >          F90_MODULE_NAMES=unknown ;;
5538 > esac
5539 >
5540 > ac_ext=c
5541 > ac_cpp='$CPP $CPPFLAGS'
5542 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5543 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5544 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5545 >
5546 >
5547 > ac_ext=c
5548 > ac_cpp='$CPP $CPPFLAGS'
5549 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
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 >
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 >  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 >
5569 > /* Override any gcc2 internal prototype to avoid an error.  */
5570 > #ifdef __cplusplus
5571 > extern "C"
5572 > #endif
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 > 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); } &&
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=$?
5606 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
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 > ac_cv_lib_m_asin=no
5620 > fi
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 > 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
5631 >
5632 >  LIBS="-lm $LIBS"
5633 >
5634 > else
5635 >  exit
5636 > fi
5637 >
5638 >
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
5642 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5643 > else
5644 >  cat >conftest.$ac_ext <<_ACEOF
5645 > /* confdefs.h.  */
5646 > _ACEOF
5647 > cat confdefs.h >>conftest.$ac_ext
5648 > cat >>conftest.$ac_ext <<_ACEOF
5649 > /* end confdefs.h.  */
5650 > #include <stdlib.h>
5651 > #include <stdarg.h>
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 > {
5666 >
5667 >  ;
5668 >  return 0;
5669 > }
5670 > _ACEOF
5671 > rm -f conftest.$ac_objext
5672 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5673 >  (eval $ac_compile) 2>conftest.er1
5674 >  ac_status=$?
5675 >  grep -v '^ *+' conftest.er1 >conftest.err
5676 >  rm -f conftest.er1
5677 >  cat conftest.err >&5
5678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5679 >  (exit $ac_status); } &&
5680 >         { ac_try='test -z "$ac_c_werror_flag"
5681 >                         || test ! -s conftest.err'
5682 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5683 >  (eval $ac_try) 2>&5
5684 >  ac_status=$?
5685 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5686 >  (exit $ac_status); }; } &&
5687 >         { ac_try='test -s conftest.$ac_objext'
5688 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5689 >  (eval $ac_try) 2>&5
5690 >  ac_status=$?
5691 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5692 >  (exit $ac_status); }; }; then
5693 >  ac_cv_header_stdc=yes
5694 > else
5695 >  echo "$as_me: failed program was:" >&5
5696 > sed 's/^/| /' conftest.$ac_ext >&5
5697 >
5698 > ac_cv_header_stdc=no
5699 > fi
5700 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5701 >
5702 > if test $ac_cv_header_stdc = yes; then
5703 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5704 >  cat >conftest.$ac_ext <<_ACEOF
5705 > /* confdefs.h.  */
5706 > _ACEOF
5707 > cat confdefs.h >>conftest.$ac_ext
5708 > cat >>conftest.$ac_ext <<_ACEOF
5709 > /* end confdefs.h.  */
5710 > #include <string.h>
5711 >
5712 > _ACEOF
5713 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5714 >  $EGREP "memchr" >/dev/null 2>&1; then
5715 >  :
5716 > else
5717 >  ac_cv_header_stdc=no
5718 > fi
5719 > rm -f conftest*
5720 >
5721 > fi
5722 >
5723 > if test $ac_cv_header_stdc = yes; then
5724 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5725 >  cat >conftest.$ac_ext <<_ACEOF
5726 > /* confdefs.h.  */
5727 > _ACEOF
5728 > cat confdefs.h >>conftest.$ac_ext
5729 > cat >>conftest.$ac_ext <<_ACEOF
5730 > /* end confdefs.h.  */
5731 > #include <stdlib.h>
5732 >
5733 > _ACEOF
5734 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5735 >  $EGREP "free" >/dev/null 2>&1; then
5736 >  :
5737 > else
5738 >  ac_cv_header_stdc=no
5739 > fi
5740 > rm -f conftest*
5741 >
5742 > fi
5743 >
5744 > if test $ac_cv_header_stdc = yes; then
5745 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5746 >  if test "$cross_compiling" = yes; then
5747 >  :
5748 > else
5749 >  cat >conftest.$ac_ext <<_ACEOF
5750 > /* confdefs.h.  */
5751 > _ACEOF
5752 > cat confdefs.h >>conftest.$ac_ext
5753 > cat >>conftest.$ac_ext <<_ACEOF
5754 > /* end confdefs.h.  */
5755 > #include <ctype.h>
5756 > #if ((' ' & 0x0FF) == 0x020)
5757 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5758 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5759 > #else
5760 > # define ISLOWER(c) \
5761 >                   (('a' <= (c) && (c) <= 'i') \
5762 >                     || ('j' <= (c) && (c) <= 'r') \
5763 >                     || ('s' <= (c) && (c) <= 'z'))
5764 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5765 > #endif
5766 >
5767 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5768 > int
5769 > main ()
5770 > {
5771 >  int i;
5772 >  for (i = 0; i < 256; i++)
5773 >    if (XOR (islower (i), ISLOWER (i))
5774 >        || toupper (i) != TOUPPER (i))
5775 >      exit(2);
5776 >  exit (0);
5777 > }
5778 > _ACEOF
5779 > rm -f conftest$ac_exeext
5780 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5781 >  (eval $ac_link) 2>&5
5782 >  ac_status=$?
5783 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5784 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5785 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5786 >  (eval $ac_try) 2>&5
5787 >  ac_status=$?
5788 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5789 >  (exit $ac_status); }; }; then
5790 >  :
5791 > else
5792 >  echo "$as_me: program exited with status $ac_status" >&5
5793 > echo "$as_me: failed program was:" >&5
5794 > sed 's/^/| /' conftest.$ac_ext >&5
5795 >
5796 > ( exit $ac_status )
5797 > ac_cv_header_stdc=no
5798 > fi
5799 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5800 > fi
5801 > fi
5802 > fi
5803 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5804 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5805 > if test $ac_cv_header_stdc = yes; then
5806 >
5807 > cat >>confdefs.h <<\_ACEOF
5808 > #define STDC_HEADERS 1
5809 > _ACEOF
5810 >
5811 > fi
5812 >
5813 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5814 >
5815 >
5816 >
5817 >
5818 >
5819 >
5820 >
5821 >
5822 >
5823 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5824 >                  inttypes.h stdint.h unistd.h
5825 > do
5826 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5827 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5828 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5829 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5830 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5831 > else
5832 >  cat >conftest.$ac_ext <<_ACEOF
5833 > /* confdefs.h.  */
5834 > _ACEOF
5835 > cat confdefs.h >>conftest.$ac_ext
5836 > cat >>conftest.$ac_ext <<_ACEOF
5837 > /* end confdefs.h.  */
5838 > $ac_includes_default
5839 >
5840 > #include <$ac_header>
5841 > _ACEOF
5842 > rm -f conftest.$ac_objext
5843 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5844 >  (eval $ac_compile) 2>conftest.er1
5845 >  ac_status=$?
5846 >  grep -v '^ *+' conftest.er1 >conftest.err
5847 >  rm -f conftest.er1
5848 >  cat conftest.err >&5
5849 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5850 >  (exit $ac_status); } &&
5851 >         { ac_try='test -z "$ac_c_werror_flag"
5852 >                         || test ! -s conftest.err'
5853 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5854 >  (eval $ac_try) 2>&5
5855 >  ac_status=$?
5856 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5857 >  (exit $ac_status); }; } &&
5858 >         { ac_try='test -s conftest.$ac_objext'
5859 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5860 >  (eval $ac_try) 2>&5
5861 >  ac_status=$?
5862 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5863 >  (exit $ac_status); }; }; then
5864 >  eval "$as_ac_Header=yes"
5865 > else
5866 >  echo "$as_me: failed program was:" >&5
5867 > sed 's/^/| /' conftest.$ac_ext >&5
5868 >
5869 > eval "$as_ac_Header=no"
5870 > fi
5871 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5872 > fi
5873 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5874 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5875 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5876 >  cat >>confdefs.h <<_ACEOF
5877 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5878 > _ACEOF
5879 >
5880 > fi
5881 >
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 > 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 >        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
5935 > else
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 >
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
6055 > sed 's/^/| /' conftest.$ac_ext >&5
6056 >
6057 > ac_header_compiler=no
6058 > fi
6059 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6060 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6061 > echo "${ECHO_T}$ac_header_compiler" >&6
6062 >
6063 > # Is the header present?
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 <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
6076 >  ac_status=$?
6077 >  grep -v '^ *+' conftest.er1 >conftest.err
6078 >  rm -f conftest.er1
6079 >  cat conftest.err >&5
6080 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6081 >  (exit $ac_status); } >/dev/null; then
6082 >  if test -s conftest.err; then
6083 >    ac_cpp_err=$ac_c_preproc_warn_flag
6084 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6085 >  else
6086 >    ac_cpp_err=
6087 >  fi
6088 > else
6089 >  ac_cpp_err=yes
6090 > fi
6091 > if test -z "$ac_cpp_err"; then
6092 >  ac_header_preproc=yes
6093 > else
6094 >  echo "$as_me: failed program was:" >&5
6095 > sed 's/^/| /' conftest.$ac_ext >&5
6096 >
6097 >  ac_header_preproc=no
6098 > fi
6099 > rm -f conftest.err conftest.$ac_ext
6100 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6101 > echo "${ECHO_T}$ac_header_preproc" >&6
6102 >
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: 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: 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 > ## ------------------------------ ##
6128 > ## Report this to gezelter@nd.edu ##
6129 > ## ------------------------------ ##
6130 > _ASBOX
6131 >    ) |
6132 >      sed "s/^/$as_me: WARNING:     /" >&2
6133 >    ;;
6134 > esac
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 >  ac_cv_header_zlib_h=$ac_header_preproc
6141 > fi
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 $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 >
6166 >
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 > # 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 >  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.  */
6253 >
6254 > /* Override any gcc2 internal prototype to avoid an error.  */
6255 > #ifdef __cplusplus
6256 > extern "C"
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 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
6268 > #endif
6269 > int
6270 > main ()
6271 > {
6272 > fftw_execute ();
6273 >  ;
6274 >  return 0;
6275 > }
6276 > _ACEOF
6277 > rm -f conftest.$ac_objext conftest$ac_exeext
6278 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6279 >  (eval $ac_link) 2>conftest.er1
6280 >  ac_status=$?
6281 >  grep -v '^ *+' conftest.er1 >conftest.err
6282 >  rm -f conftest.er1
6283 >  cat conftest.err >&5
6284 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6285 >  (exit $ac_status); } &&
6286 >         { ac_try='test -z "$ac_c_werror_flag"
6287 >                         || test ! -s conftest.err'
6288 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6289 >  (eval $ac_try) 2>&5
6290 >  ac_status=$?
6291 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6292 >  (exit $ac_status); }; } &&
6293 >         { ac_try='test -s conftest$ac_exeext'
6294 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6295 >  (eval $ac_try) 2>&5
6296 >  ac_status=$?
6297 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6298 >  (exit $ac_status); }; }; then
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 > 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: $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 > 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 > # 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 <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 > fftwnd_one ();
6496 >  ;
6497 >  return 0;
6498 > }
6499 > _ACEOF
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
6506 >  cat conftest.err >&5
6507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508 >  (exit $ac_status); } &&
6509 >         { ac_try='test -z "$ac_c_werror_flag"
6510 >                         || test ! -s conftest.err'
6511 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6512 >  (eval $ac_try) 2>&5
6513 >  ac_status=$?
6514 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6515 >  (exit $ac_status); }; } &&
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 >  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 > ac_cv_lib_fftw_fftwnd_one=no
6528 > fi
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 >        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: $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 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
6556 > cat confdefs.h >>conftest.$ac_ext
6557 > cat >>conftest.$ac_ext <<_ACEOF
6558 > /* end confdefs.h.  */
6559 > $ac_includes_default
6560 > #include <fftw.h>
6561 > _ACEOF
6562 > rm -f conftest.$ac_objext
6563 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6564 >  (eval $ac_compile) 2>conftest.er1
6565 >  ac_status=$?
6566 >  grep -v '^ *+' conftest.er1 >conftest.err
6567 >  rm -f conftest.er1
6568 >  cat conftest.err >&5
6569 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6570 >  (exit $ac_status); } &&
6571 >         { ac_try='test -z "$ac_c_werror_flag"
6572 >                         || test ! -s conftest.err'
6573 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6574 >  (eval $ac_try) 2>&5
6575 >  ac_status=$?
6576 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6577 >  (exit $ac_status); }; } &&
6578 >         { ac_try='test -s conftest.$ac_objext'
6579 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6580 >  (eval $ac_try) 2>&5
6581 >  ac_status=$?
6582 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6583 >  (exit $ac_status); }; }; then
6584 >  ac_header_compiler=yes
6585 > else
6586 >  echo "$as_me: failed program was:" >&5
6587 > sed 's/^/| /' conftest.$ac_ext >&5
6588 >
6589 > ac_header_compiler=no
6590 > fi
6591 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6592 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6593 > echo "${ECHO_T}$ac_header_compiler" >&6
6594 >
6595 > # Is the header present?
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 <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
6608 >  ac_status=$?
6609 >  grep -v '^ *+' conftest.er1 >conftest.err
6610 >  rm -f conftest.er1
6611 >  cat conftest.err >&5
6612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6613 >  (exit $ac_status); } >/dev/null; then
6614 >  if test -s conftest.err; then
6615 >    ac_cpp_err=$ac_c_preproc_warn_flag
6616 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6617 >  else
6618 >    ac_cpp_err=
6619 >  fi
6620 > else
6621 >  ac_cpp_err=yes
6622 > fi
6623 > if test -z "$ac_cpp_err"; then
6624 >  ac_header_preproc=yes
6625 > else
6626 >  echo "$as_me: failed program was:" >&5
6627 > sed 's/^/| /' conftest.$ac_ext >&5
6628 >
6629 >  ac_header_preproc=no
6630 > fi
6631 > rm -f conftest.err conftest.$ac_ext
6632 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6633 > echo "${ECHO_T}$ac_header_preproc" >&6
6634 >
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: 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: 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 > ## ------------------------------ ##
6660 > ## Report this to gezelter@nd.edu ##
6661 > ## ------------------------------ ##
6662 > _ASBOX
6663 >    ) |
6664 >      sed "s/^/$as_me: WARNING:     /" >&2
6665 >    ;;
6666 > esac
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 >  ac_cv_header_fftw_h=$ac_header_preproc
6673 > fi
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 $ac_cv_header_fftw_h = yes; then
6679 >  fftw_cv_fftw_h=yes
6680 > else
6681 >  fftw_cv_fftw_h=no
6682 > fi
6683 >
6684 >
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 >  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.  */
6699 >
6700 > /* Override any gcc2 internal prototype to avoid an error.  */
6701 > #ifdef __cplusplus
6702 > extern "C"
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 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
6714 > #endif
6715 > int
6716 > main ()
6717 > {
6718 > fftwnd_one ();
6719 >  ;
6720 >  return 0;
6721 > }
6722 > _ACEOF
6723 > rm -f conftest.$ac_objext conftest$ac_exeext
6724 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6725 >  (eval $ac_link) 2>conftest.er1
6726 >  ac_status=$?
6727 >  grep -v '^ *+' conftest.er1 >conftest.err
6728 >  rm -f conftest.er1
6729 >  cat conftest.err >&5
6730 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6731 >  (exit $ac_status); } &&
6732 >         { ac_try='test -z "$ac_c_werror_flag"
6733 >                         || test ! -s conftest.err'
6734 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6735 >  (eval $ac_try) 2>&5
6736 >  ac_status=$?
6737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738 >  (exit $ac_status); }; } &&
6739 >         { ac_try='test -s conftest$ac_exeext'
6740 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6741 >  (eval $ac_try) 2>&5
6742 >  ac_status=$?
6743 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6744 >  (exit $ac_status); }; }; then
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 > 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: $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 >  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 >  # 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 > $ac_includes_default
6783 > #include <dfftw.h>
6784 > _ACEOF
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
6791 >  cat conftest.err >&5
6792 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6793 >  (exit $ac_status); } &&
6794 >         { ac_try='test -z "$ac_c_werror_flag"
6795 >                         || test ! -s conftest.err'
6796 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6797 >  (eval $ac_try) 2>&5
6798 >  ac_status=$?
6799 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800 >  (exit $ac_status); }; } &&
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_header_compiler=yes
6808 > else
6809 >  echo "$as_me: failed program was:" >&5
6810 > sed 's/^/| /' conftest.$ac_ext >&5
6811 >
6812 > ac_header_compiler=no
6813 > fi
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 >  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 >  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 >
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 >          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 > #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 > #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); }; } &&
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 >  echo "$as_me: failed program was:" >&5
7035 > sed 's/^/| /' conftest.$ac_ext >&5
7036 >
7037 > ac_cv_header_stdc=no
7038 > fi
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 >  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 > _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 > fi
7082 >
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 <  ac_check_lib_save_LIBS=$LIBS
8742 < LIBS="-lm  $LIBS"
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 <
8751 < /* Override any gcc2 internal prototype to avoid an error.  */
4472 < #ifdef __cplusplus
4473 < extern "C"
4474 < #endif
4475 < /* We use char because int might match the return type of a gcc2
4476 <   builtin and then its argument prototype would still apply.  */
4477 < char asin ();
4478 < int
4479 < main ()
4480 < {
4481 < asin ();
4482 <  ;
4483 <  return 0;
4484 < }
8750 > $ac_includes_default
8751 > #include <$ac_header>
8752   _ACEOF
8753 < rm -f conftest.$ac_objext conftest$ac_exeext
8754 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8755 <  (eval $ac_link) 2>conftest.er1
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_cxx_werror_flag"                         || test ! -s conftest.err'
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_exeext'
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_cv_lib_m_asin=yes
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_cv_lib_m_asin=no
8780 > ac_header_compiler=no
8781   fi
8782 < rm -f conftest.err conftest.$ac_objext \
8783 <      conftest$ac_exeext conftest.$ac_ext
8784 < LIBS=$ac_check_lib_save_LIBS
4517 < fi
4518 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
4519 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
4520 < if test $ac_cv_lib_m_asin = yes; then
4521 <  cat >>confdefs.h <<_ACEOF
4522 < #define HAVE_LIBM 1
4523 < _ACEOF
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 <  LIBS="-lm $LIBS"
8787 <
8788 < else
8789 <  exit
4529 < fi
4530 <
4531 <
4532 < ac_ext=c
4533 < ac_cpp='$CPP $CPPFLAGS'
4534 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4535 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4536 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4537 <
4538 < ac_ext=c
4539 < ac_cpp='$CPP $CPPFLAGS'
4540 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4541 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4542 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4543 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4544 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4545 < # On Suns, sometimes $CPP names a directory.
4546 < if test -n "$CPP" && test -d "$CPP"; then
4547 <  CPP=
4548 < fi
4549 < if test -z "$CPP"; then
4550 <  if test "${ac_cv_prog_CPP+set}" = set; then
4551 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4552 < else
4553 <      # Double quotes because CPP needs to be expanded
4554 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4555 <    do
4556 <      ac_preproc_ok=false
4557 < for ac_c_preproc_warn_flag in '' yes
4558 < do
4559 <  # Use a header file that comes with gcc, so configuring glibc
4560 <  # with a fresh cross-compiler works.
4561 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4562 <  # <limits.h> exists even on freestanding compilers.
4563 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4564 <  # not just through cpp. "Syntax error" is here to catch this case.
4565 <  cat >conftest.$ac_ext <<_ACEOF
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 < #ifdef __STDC__
4572 < # include <limits.h>
4573 < #else
4574 < # include <assert.h>
4575 < #endif
4576 <                     Syntax error
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
# Line 4593 | Line 8812 | if test -z "$ac_cpp_err"; then
8812    ac_cpp_err=yes
8813   fi
8814   if test -z "$ac_cpp_err"; then
8815 <  :
8815 >  ac_header_preproc=yes
8816   else
8817    echo "$as_me: failed program was:" >&5
8818   sed 's/^/| /' conftest.$ac_ext >&5
8819  
8820 <  # Broken: fails on valid input.
4602 < continue
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 <  # OK, works on sane cases.  Now check whether non-existent headers
8827 <  # can be detected and how.
8828 <  cat >conftest.$ac_ext <<_ACEOF
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 < #include <ac_nonexistent.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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8919 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
8927 <  if test -s conftest.err; then
8928 <    ac_cpp_err=$ac_c_preproc_warn_flag
8929 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8930 <  else
8931 <    ac_cpp_err=
8932 <  fi
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
4631 –  ac_cpp_err=yes
4632 – fi
4633 – if test -z "$ac_cpp_err"; then
4634 –  # Broken: success on invalid input.
4635 – continue
4636 – else
8942    echo "$as_me: failed program was:" >&5
8943   sed 's/^/| /' conftest.$ac_ext >&5
8944  
4640 –  # Passes both tests.
4641 – ac_preproc_ok=:
4642 – break
8945   fi
8946 < rm -f conftest.err conftest.$ac_ext
8947 <
8946 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8947 >  done
8948 > done
8949   done
8950 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8951 < rm -f conftest.err conftest.$ac_ext
8952 < if $ac_preproc_ok; then
4650 <  break
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 <    done
8962 <    ac_cv_prog_CPP=$CPP
8961 > cat >>confdefs.h <<_ACEOF
8962 > #define SELECT_TYPE_ARG1 $1
8963 > _ACEOF
8964  
8965 < fi
8966 <  CPP=$ac_cv_prog_CPP
8967 < else
8968 <  ac_cv_prog_CPP=$CPP
8969 < fi
8970 < echo "$as_me:$LINENO: result: $CPP" >&5
8971 < echo "${ECHO_T}$CPP" >&6
8972 < ac_preproc_ok=false
8973 < for ac_c_preproc_warn_flag in '' yes
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 <  # Use a header file that comes with gcc, so configuring glibc
8981 <  # with a fresh cross-compiler works.
8982 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8983 <  # <limits.h> exists even on freestanding compilers.
8984 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8985 <  # not just through cpp. "Syntax error" is here to catch this case.
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
4683 –                     Syntax error
4684 – _ACEOF
4685 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4686 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4687 –  ac_status=$?
4688 –  grep -v '^ *+' conftest.er1 >conftest.err
4689 –  rm -f conftest.er1
4690 –  cat conftest.err >&5
4691 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4692 –  (exit $ac_status); } >/dev/null; then
4693 –  if test -s conftest.err; then
4694 –    ac_cpp_err=$ac_c_preproc_warn_flag
4695 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
4696 –  else
4697 –    ac_cpp_err=
4698 –  fi
4699 – else
4700 –  ac_cpp_err=yes
4701 – fi
4702 – if test -z "$ac_cpp_err"; then
4703 –  :
4704 – else
4705 –  echo "$as_me: failed program was:" >&5
4706 – sed 's/^/| /' conftest.$ac_ext >&5
9006  
9007 <  # Broken: fails on valid input.
4709 < continue
4710 < fi
4711 < rm -f conftest.err conftest.$ac_ext
9007 > #undef $ac_func
9008  
9009 <  # OK, works on sane cases.  Now check whether non-existent headers
9010 <  # can be detected and how.
9011 <  cat >conftest.$ac_ext <<_ACEOF
9012 < /* confdefs.h.  */
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 < cat confdefs.h >>conftest.$ac_ext
9046 < cat >>conftest.$ac_ext <<_ACEOF
9047 < /* end confdefs.h.  */
4721 < #include <ac_nonexistent.h>
4722 < _ACEOF
4723 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4724 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
9054 <  if test -s conftest.err; then
9055 <    ac_cpp_err=$ac_c_preproc_warn_flag
9056 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9057 <  else
9058 <    ac_cpp_err=
9059 <  fi
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
4738 –  ac_cpp_err=yes
4739 – fi
4740 – if test -z "$ac_cpp_err"; then
4741 –  # Broken: success on invalid input.
4742 – continue
4743 – else
9069    echo "$as_me: failed program was:" >&5
9070   sed 's/^/| /' conftest.$ac_ext >&5
9071  
9072 <  # Passes both tests.
4748 < ac_preproc_ok=:
4749 < break
9072 > eval "$as_ac_var=no"
9073   fi
9074 < rm -f conftest.err conftest.$ac_ext
9075 <
4753 < done
4754 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4755 < rm -f conftest.err conftest.$ac_ext
4756 < if $ac_preproc_ok; then
4757 <  :
4758 < else
4759 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4760 < See \`config.log' for more details." >&5
4761 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4762 < See \`config.log' for more details." >&2;}
4763 <   { (exit 1); exit 1; }; }
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  
4766 – ac_ext=c
4767 – ac_cpp='$CPP $CPPFLAGS'
4768 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4769 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4770 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
4771 –
4772 –
4773 – echo "$as_me:$LINENO: checking for egrep" >&5
4774 – echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4775 – if test "${ac_cv_prog_egrep+set}" = set; then
4776 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9084   else
9085 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
9086 <    then ac_cv_prog_egrep='grep -E'
9087 <    else ac_cv_prog_egrep='egrep'
9088 <    fi
4782 < fi
4783 < echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4784 < echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4785 < EGREP=$ac_cv_prog_egrep
4786 <
4787 <
4788 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
4789 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
4790 < if test "${ac_cv_header_stdc+set}" = set; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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.  */
4799 – #include <stdlib.h>
4800 – #include <stdarg.h>
4801 – #include <string.h>
4802 – #include <float.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 <
9118 > strftime ();
9119    ;
9120    return 0;
9121   }
9122   _ACEOF
9123 < rm -f conftest.$ac_objext
9124 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9125 <  (eval $ac_compile) 2>conftest.er1
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"                   || test ! -s conftest.err'
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_objext'
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_header_stdc=yes
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_header_stdc=no
9150 > ac_cv_lib_intl_strftime=no
9151   fi
9152 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9153 <
9154 < if test $ac_cv_header_stdc = yes; then
4843 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4844 <  cat >conftest.$ac_ext <<_ACEOF
4845 < /* confdefs.h.  */
4846 < _ACEOF
4847 < cat confdefs.h >>conftest.$ac_ext
4848 < cat >>conftest.$ac_ext <<_ACEOF
4849 < /* end confdefs.h.  */
4850 < #include <string.h>
4851 <
4852 < _ACEOF
4853 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4854 <  $EGREP "memchr" >/dev/null 2>&1; then
4855 <  :
4856 < else
4857 <  ac_cv_header_stdc=no
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 < rm -f conftest*
9157 <
9158 < fi
9159 <
9160 < if test $ac_cv_header_stdc = yes; then
4864 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
4865 <  cat >conftest.$ac_ext <<_ACEOF
4866 < /* confdefs.h.  */
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
4868 – cat confdefs.h >>conftest.$ac_ext
4869 – cat >>conftest.$ac_ext <<_ACEOF
4870 – /* end confdefs.h.  */
4871 – #include <stdlib.h>
9162  
9163 < _ACEOF
4874 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4875 <  $EGREP "free" >/dev/null 2>&1; then
4876 <  :
4877 < else
4878 <  ac_cv_header_stdc=no
9163 > LIBS="-lintl $LIBS"
9164   fi
4880 – rm -f conftest*
9165  
9166   fi
9167 + done
9168  
9169 < if test $ac_cv_header_stdc = yes; then
9170 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
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 <  :
9175 >  ac_cv_func_strtod=no
9176   else
9177    cat >conftest.$ac_ext <<_ACEOF
9178   /* confdefs.h.  */
# Line 4892 | Line 9180 | cat >>conftest.$ac_ext <<_ACEOF
9180   cat confdefs.h >>conftest.$ac_ext
9181   cat >>conftest.$ac_ext <<_ACEOF
9182   /* end confdefs.h.  */
4895 – #include <ctype.h>
4896 – #if ((' ' & 0x0FF) == 0x020)
4897 – # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4898 – # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4899 – #else
4900 – # define ISLOWER(c) \
4901 –                   (('a' <= (c) && (c) <= 'i') \
4902 –                     || ('j' <= (c) && (c) <= 'r') \
4903 –                     || ('s' <= (c) && (c) <= 'z'))
4904 – # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4905 – #endif
9183  
9184 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
9184 > double strtod ();
9185   int
9186 < main ()
9186 > main()
9187   {
9188 <  int i;
9189 <  for (i = 0; i < 256; i++)
9190 <    if (XOR (islower (i), ISLOWER (i))
9191 <        || toupper (i) != TOUPPER (i))
9192 <      exit(2);
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
# Line 4927 | Line 9219 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9219    ac_status=$?
9220    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9221    (exit $ac_status); }; }; then
9222 <  :
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_header_stdc=no
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 < fi
9235 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
9236 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
9237 < if test $ac_cv_header_stdc = yes; then
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 < cat >>confdefs.h <<\_ACEOF
9246 < #define STDC_HEADERS 1
9247 < _ACEOF
4950 <
4951 < fi
4952 <
4953 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
4954 <
4955 <
4956 <
4957 <
4958 <
4959 <
4960 <
4961 <
4962 <
4963 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4964 <                  inttypes.h stdint.h unistd.h
4965 < do
4966 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4967 < echo "$as_me:$LINENO: checking for $ac_header" >&5
4968 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4969 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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
# Line 4975 | Line 9253 | cat >>conftest.$ac_ext <<_ACEOF
9253   cat confdefs.h >>conftest.$ac_ext
9254   cat >>conftest.$ac_ext <<_ACEOF
9255   /* end confdefs.h.  */
9256 < $ac_includes_default
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 < #include <$ac_header>
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
9310 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9311 <  (eval $ac_compile) 2>conftest.er1
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"                   || test ! -s conftest.err'
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_objext'
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 <  eval "$as_ac_Header=yes"
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 < eval "$as_ac_Header=no"
9336 > ac_cv_func_pow=no
9337   fi
9338 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9338 > rm -f conftest.err conftest.$ac_objext \
9339 >      conftest$ac_exeext conftest.$ac_ext
9340   fi
9341 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9342 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5014 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5015 <  cat >>confdefs.h <<_ACEOF
5016 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5017 < _ACEOF
9341 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9342 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9343  
9344 < fi
9345 <
9346 < done
9347 <
5023 <
5024 < #
5025 < # Handle user hints
5026 < #
5027 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5028 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5029 <
5030 < # Check whether --with-zlib or --without-zlib was given.
5031 < if test "${with_zlib+set}" = set; then
5032 <  withval="$with_zlib"
5033 <  if test "$withval" != no ; then
5034 <  echo "$as_me:$LINENO: result: yes" >&5
5035 < echo "${ECHO_T}yes" >&6
5036 <  if test -d "$withval"
5037 <  then
5038 <    ZLIB_HOME="$withval"
5039 <  else
5040 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5041 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5042 <  fi
5043 < else
5044 <  echo "$as_me:$LINENO: result: no" >&5
5045 < echo "${ECHO_T}no" >&6
5046 < fi
5047 < fi;
5048 <
5049 < ZLIB_HOME=/usr/local
5050 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
5051 < then
5052 <        ZLIB_HOME=/usr
5053 < fi
5054 <
5055 < #
5056 < # Locate zlib, if wanted
5057 < #
5058 < if test -n "${ZLIB_HOME}"
5059 < then
5060 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
5061 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5062 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5063 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5064 <
5065 <
5066 <        ac_ext=c
5067 < ac_cpp='$CPP $CPPFLAGS'
5068 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5069 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5070 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5071 <
5072 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5073 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5074 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
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="-lz  $LIBS"
9351 > LIBS="-lm  $LIBS"
9352   cat >conftest.$ac_ext <<_ACEOF
9353   /* confdefs.h.  */
9354   _ACEOF
# Line 5089 | Line 9362 | 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 inflateEnd ();
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 < inflateEnd ();
9377 > pow ();
9378    ;
9379    return 0;
9380   }
# Line 5107 | Line 9388 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
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"                   || test ! -s conftest.err'
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=$?
# Line 5119 | Line 9401 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9401    ac_status=$?
9402    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9403    (exit $ac_status); }; }; then
9404 <  ac_cv_lib_z_inflateEnd=yes
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_z_inflateEnd=no
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_z_inflateEnd" >&5
9416 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
9417 < if test $ac_cv_lib_z_inflateEnd = yes; then
9418 <  zlib_cv_libz=yes
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 <  zlib_cv_libz=no
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  
5141 –        if test "${ac_cv_header_zlib_h+set}" = set; then
5142 –  echo "$as_me:$LINENO: checking for zlib.h" >&5
5143 – echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5144 – if test "${ac_cv_header_zlib_h+set}" = set; then
5145 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9424   fi
5147 – echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5148 – echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5149 – else
5150 –  # Is the header compilable?
5151 – echo "$as_me:$LINENO: checking zlib.h usability" >&5
5152 – echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5153 – cat >conftest.$ac_ext <<_ACEOF
5154 – /* confdefs.h.  */
5155 – _ACEOF
5156 – cat confdefs.h >>conftest.$ac_ext
5157 – cat >>conftest.$ac_ext <<_ACEOF
5158 – /* end confdefs.h.  */
5159 – $ac_includes_default
5160 – #include <zlib.h>
5161 – _ACEOF
5162 – rm -f conftest.$ac_objext
5163 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5164 –  (eval $ac_compile) 2>conftest.er1
5165 –  ac_status=$?
5166 –  grep -v '^ *+' conftest.er1 >conftest.err
5167 –  rm -f conftest.er1
5168 –  cat conftest.err >&5
5169 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5170 –  (exit $ac_status); } &&
5171 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5172 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5173 –  (eval $ac_try) 2>&5
5174 –  ac_status=$?
5175 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5176 –  (exit $ac_status); }; } &&
5177 –         { ac_try='test -s conftest.$ac_objext'
5178 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5179 –  (eval $ac_try) 2>&5
5180 –  ac_status=$?
5181 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5182 –  (exit $ac_status); }; }; then
5183 –  ac_header_compiler=yes
5184 – else
5185 –  echo "$as_me: failed program was:" >&5
5186 – sed 's/^/| /' conftest.$ac_ext >&5
9425  
5188 – ac_header_compiler=no
9426   fi
5190 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5191 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5192 – echo "${ECHO_T}$ac_header_compiler" >&6
9427  
5194 – # Is the header present?
5195 – echo "$as_me:$LINENO: checking zlib.h presence" >&5
5196 – echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5197 – cat >conftest.$ac_ext <<_ACEOF
5198 – /* confdefs.h.  */
5199 – _ACEOF
5200 – cat confdefs.h >>conftest.$ac_ext
5201 – cat >>conftest.$ac_ext <<_ACEOF
5202 – /* end confdefs.h.  */
5203 – #include <zlib.h>
5204 – _ACEOF
5205 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5206 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5207 –  ac_status=$?
5208 –  grep -v '^ *+' conftest.er1 >conftest.err
5209 –  rm -f conftest.er1
5210 –  cat conftest.err >&5
5211 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5212 –  (exit $ac_status); } >/dev/null; then
5213 –  if test -s conftest.err; then
5214 –    ac_cpp_err=$ac_c_preproc_warn_flag
5215 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5216 –  else
5217 –    ac_cpp_err=
5218 –  fi
5219 – else
5220 –  ac_cpp_err=yes
5221 – fi
5222 – if test -z "$ac_cpp_err"; then
5223 –  ac_header_preproc=yes
5224 – else
5225 –  echo "$as_me: failed program was:" >&5
5226 – sed 's/^/| /' conftest.$ac_ext >&5
9428  
5228 –  ac_header_preproc=no
5229 – fi
5230 – rm -f conftest.err conftest.$ac_ext
5231 – echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5232 – echo "${ECHO_T}$ac_header_preproc" >&6
9429  
9430 < # So?  What about this header?
9431 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9432 <  yes:no: )
9433 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
9434 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9435 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
9436 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
9437 <    ac_header_preproc=yes
9438 <    ;;
9439 <  no:yes:* )
9440 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
9441 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
9442 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
9443 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
9444 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
9445 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
9446 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
9447 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9448 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
9449 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
9450 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
9451 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5256 <    (
5257 <      cat <<\_ASBOX
5258 < ## ------------------------------ ##
5259 < ## Report this to gezelter@nd.edu ##
5260 < ## ------------------------------ ##
5261 < _ASBOX
5262 <    ) |
5263 <      sed "s/^/$as_me: WARNING:     /" >&2
5264 <    ;;
5265 < esac
5266 < echo "$as_me:$LINENO: checking for zlib.h" >&5
5267 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5268 < if test "${ac_cv_header_zlib_h+set}" = set; then
5269 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5270 < else
5271 <  ac_cv_header_zlib_h=$ac_header_preproc
5272 < fi
5273 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5274 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
9430 >
9431 >
9432 >
9433 >
9434 >
9435 >
9436 >
9437 >
9438 >
9439 >
9440 >
9441 >
9442 >
9443 >
9444 >
9445 >
9446 >
9447 >
9448 >
9449 >
9450 >
9451 >
9452  
5276 – fi
5277 – if test $ac_cv_header_zlib_h = yes; then
5278 –  zlib_cv_zlib_h=yes
5279 – else
5280 –  zlib_cv_zlib_h=no
5281 – fi
9453  
9454  
9455 <        ac_ext=c
9456 < ac_cpp='$CPP $CPPFLAGS'
9457 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9458 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9459 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9460 <
5290 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
5291 <        then
5292 <                #
5293 <                # If both library and header were found, use them
5294 <                #
5295 <
5296 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5297 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5298 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
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 <  ac_check_lib_save_LIBS=$LIBS
5302 < LIBS="-lz  $LIBS"
5303 < cat >conftest.$ac_ext <<_ACEOF
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 inflateEnd ();
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 < inflateEnd ();
9517 > return f != $ac_func;
9518    ;
9519    return 0;
9520   }
# Line 5331 | Line 9528 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
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"                   || test ! -s conftest.err'
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=$?
# Line 5343 | Line 9541 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9541    ac_status=$?
9542    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9543    (exit $ac_status); }; }; then
9544 <  ac_cv_lib_z_inflateEnd=yes
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 < ac_cv_lib_z_inflateEnd=no
9549 > eval "$as_ac_var=no"
9550   fi
9551   rm -f conftest.err conftest.$ac_objext \
9552        conftest$ac_exeext conftest.$ac_ext
5355 – LIBS=$ac_check_lib_save_LIBS
9553   fi
9554 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
9555 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
9556 < if test $ac_cv_lib_z_inflateEnd = yes; then
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 HAVE_LIBZ 1
9558 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9559   _ACEOF
9560  
5364 –  LIBS="-lz $LIBS"
5365 –
9561   fi
9562 + done
9563  
5368 –                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5369 – echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5370 –                echo "$as_me:$LINENO: result: ok" >&5
5371 – echo "${ECHO_T}ok" >&6
5372 –        else
5373 –                #
5374 –                # If either header or library was not found, revert and bomb
5375 –                #
5376 –                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5377 – echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5378 –                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5379 –                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5380 –                echo "$as_me:$LINENO: result: failed" >&5
5381 – echo "${ECHO_T}failed" >&6
5382 –                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5383 – echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5384 –   { (exit 1); exit 1; }; }
5385 –        fi
5386 – fi
9564  
9565 <
9566 <
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 sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
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
# Line 5425 | Line 9664 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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"                   || test ! -s conftest.err'
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=$?
# Line 5541 | Line 9781 | done
9781   done
9782  
9783  
9784 <
5545 <
5546 <
5547 <
5548 < for ac_header in strstream.h iostream.h fstream.h math.h time.h
9784 > for ac_func in getopt_long
9785   do
9786 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9787 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
9788 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
9789 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5554 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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
5556 – fi
5557 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5558 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9791   else
9792 <  # Is the header compilable?
5561 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5562 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5563 < cat >conftest.$ac_ext <<_ACEOF
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 < $ac_includes_default
9799 < #include <$ac_header>
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
9852 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9853 <  (eval $ac_compile) 2>conftest.er1
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"                   || test ! -s conftest.err'
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_objext'
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 <  ac_header_compiler=yes
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 < ac_header_compiler=no
9878 > eval "$as_ac_var=no"
9879   fi
9880 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9881 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9882 < echo "${ECHO_T}$ac_header_compiler" >&6
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 < # Is the header present?
9891 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
9892 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 < #include <$ac_header>
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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9930 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
9938 <  if test -s conftest.err; then
9939 <    ac_cpp_err=$ac_c_preproc_warn_flag
9940 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9941 <  else
9942 <    ac_cpp_err=
9943 <  fi
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
5630 –  ac_cpp_err=yes
5631 – fi
5632 – if test -z "$ac_cpp_err"; then
5633 –  ac_header_preproc=yes
5634 – else
9953    echo "$as_me: failed program was:" >&5
9954   sed 's/^/| /' conftest.$ac_ext >&5
9955  
9956 <  ac_header_preproc=no
9956 > ac_cv_lib_gnugetopt_getopt_long=no
9957   fi
9958 < rm -f conftest.err conftest.$ac_ext
9959 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9960 < echo "${ECHO_T}$ac_header_preproc" >&6
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  
5644 – # So?  What about this header?
5645 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5646 –  yes:no: )
5647 –    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5648 – echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5649 –    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5650 – echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5651 –    ac_header_preproc=yes
5652 –    ;;
5653 –  no:yes:* )
5654 –    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5655 – echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5656 –    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5657 – echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5658 –    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5659 – echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5660 –    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5661 – echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5662 –    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5663 – echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5664 –    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5665 – echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5666 –    (
5667 –      cat <<\_ASBOX
5668 – ## ------------------------------ ##
5669 – ## Report this to gezelter@nd.edu ##
5670 – ## ------------------------------ ##
5671 – _ASBOX
5672 –    ) |
5673 –      sed "s/^/$as_me: WARNING:     /" >&2
5674 –    ;;
5675 – esac
5676 – echo "$as_me:$LINENO: checking for $ac_header" >&5
5677 – echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5678 – if eval "test \"\${$as_ac_Header+set}\" = set"; then
5679 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9969   else
9970 <  eval "$as_ac_Header=\$ac_header_preproc"
9971 < fi
9972 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9973 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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 < fi
9980 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
9981 <  cat >>confdefs.h <<_ACEOF
9982 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9983 < _ACEOF
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'
# Line 5924 | Line 10308 | ac_ext=cc
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 < for ac_header in ctype.h iostream fstream sstream strstream
10410 < do
10411 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10412 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5942 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5943 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5944 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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: `eval echo '${'$as_ac_Header'}'`" >&5
10416 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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 $ac_header usability" >&5
10420 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
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
# Line 5957 | Line 10425 | $ac_includes_default
10425   cat >>conftest.$ac_ext <<_ACEOF
10426   /* end confdefs.h.  */
10427   $ac_includes_default
10428 < #include <$ac_header>
10428 > #include <iostream>
10429   _ACEOF
10430   rm -f conftest.$ac_objext
10431   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5968 | Line 10436 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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"                         || test ! -s conftest.err'
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=$?
# Line 5992 | Line 10461 | echo "${ECHO_T}$ac_header_compiler" >&6
10461   echo "${ECHO_T}$ac_header_compiler" >&6
10462  
10463   # Is the header present?
10464 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
10465 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 <$ac_header>
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
# Line 6034 | Line 10503 | case $ac_header_compiler:$ac_header_preproc:$ac_cxx_pr
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: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10507 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10508 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10509 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
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: $ac_header: present but cannot be compiled" >&5
10514 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10515 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10516 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10517 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10518 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10519 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10520 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10521 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10522 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10523 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10524 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 6063 | Line 10532 | esac
10532        sed "s/^/$as_me: WARNING:     /" >&2
10533      ;;
10534   esac
10535 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10536 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10537 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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 <  eval "$as_ac_Header=\$ac_header_preproc"
10540 >  ac_cv_header_iostream=$ac_header_preproc
10541   fi
10542 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10543 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6075 <
6076 < fi
6077 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6078 <  cat >>confdefs.h <<_ACEOF
6079 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6080 < _ACEOF
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  
6084 – done
10548  
10549 < ac_ext=c
10550 < ac_cpp='$CPP $CPPFLAGS'
10551 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6089 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6090 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10549 > cat >>confdefs.h <<\_ACEOF
10550 > #define HAVE_IOSTREAM 1
10551 > _ACEOF
10552  
10553  
10554 + else
10555  
10556  
10557 < for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
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
# Line 6125 | Line 10587 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10587    cat conftest.err >&5
10588    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589    (exit $ac_status); } &&
10590 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 6168 | Line 10631 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
10635 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 6189 | Line 10652 | echo "${ECHO_T}$ac_header_preproc" >&6
10652   echo "${ECHO_T}$ac_header_preproc" >&6
10653  
10654   # So?  What about this header?
10655 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
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;}
# Line 6241 | Line 10704 | done
10704   done
10705  
10706  
10707 + fi
10708  
10709  
10710  
10711 < for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
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
# Line 6277 | Line 10890 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10890    cat conftest.err >&5
10891    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10892    (exit $ac_status); } &&
10893 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 6320 | Line 10934 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
10938 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 6341 | Line 10955 | echo "${ECHO_T}$ac_header_preproc" >&6
10955   echo "${ECHO_T}$ac_header_preproc" >&6
10956  
10957   # So?  What about this header?
10958 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
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;}
# Line 6393 | Line 11007 | done
11007   done
11008  
11009  
11010 < for ac_header in machine/hal_sysinfo.h
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
# Line 6426 | Line 11045 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11045    cat conftest.err >&5
11046    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11047    (exit $ac_status); } &&
11048 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 6469 | Line 11089 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
11093 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 6490 | Line 11110 | echo "${ECHO_T}$ac_header_preproc" >&6
11110   echo "${ECHO_T}$ac_header_preproc" >&6
11111  
11112   # So?  What about this header?
11113 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
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;}
# Line 6535 | Line 11155 | if test `eval echo '${'$as_ac_Header'}'` = yes; then
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
6538 – _ACEOF
6539 –
6540 – fi
6541 –
6542 – done
6543 –
6544 –
6545 –
6546 –
6547 –
6548 – for ac_func in rint snprintf sranddev strncasecmp
6549 – do
6550 – as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6551 – echo "$as_me:$LINENO: checking for $ac_func" >&5
6552 – echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6553 – if eval "test \"\${$as_ac_var+set}\" = set"; then
6554 –  echo $ECHO_N "(cached) $ECHO_C" >&6
6555 – else
6556 –  cat >conftest.$ac_ext <<_ACEOF
6557 – /* confdefs.h.  */
6558 – _ACEOF
6559 – cat confdefs.h >>conftest.$ac_ext
6560 – cat >>conftest.$ac_ext <<_ACEOF
6561 – /* end confdefs.h.  */
6562 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6563 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6564 – #define $ac_func innocuous_$ac_func
6565 –
6566 – /* System header to define __stub macros and hopefully few prototypes,
6567 –    which can conflict with char $ac_func (); below.
6568 –    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6569 –    <limits.h> exists even on freestanding compilers.  */
6570 –
6571 – #ifdef __STDC__
6572 – # include <limits.h>
6573 – #else
6574 – # include <assert.h>
6575 – #endif
6576 –
6577 – #undef $ac_func
6578 –
6579 – /* Override any gcc2 internal prototype to avoid an error.  */
6580 – #ifdef __cplusplus
6581 – extern "C"
6582 – {
6583 – #endif
6584 – /* We use char because int might match the return type of a gcc2
6585 –   builtin and then its argument prototype would still apply.  */
6586 – char $ac_func ();
6587 – /* The GNU C library defines this for functions which it implements
6588 –    to always fail with ENOSYS.  Some functions are actually named
6589 –    something starting with __ and the normal name is an alias.  */
6590 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6591 – choke me
6592 – #else
6593 – char (*f) () = $ac_func;
6594 – #endif
6595 – #ifdef __cplusplus
6596 – }
6597 – #endif
6598 –
6599 – int
6600 – main ()
6601 – {
6602 – return f != $ac_func;
6603 –  ;
6604 –  return 0;
6605 – }
6606 – _ACEOF
6607 – rm -f conftest.$ac_objext conftest$ac_exeext
6608 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6609 –  (eval $ac_link) 2>conftest.er1
6610 –  ac_status=$?
6611 –  grep -v '^ *+' conftest.er1 >conftest.err
6612 –  rm -f conftest.er1
6613 –  cat conftest.err >&5
6614 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6615 –  (exit $ac_status); } &&
6616 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6617 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6618 –  (eval $ac_try) 2>&5
6619 –  ac_status=$?
6620 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6621 –  (exit $ac_status); }; } &&
6622 –         { ac_try='test -s conftest$ac_exeext'
6623 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6624 –  (eval $ac_try) 2>&5
6625 –  ac_status=$?
6626 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6627 –  (exit $ac_status); }; }; then
6628 –  eval "$as_ac_var=yes"
6629 – else
6630 –  echo "$as_me: failed program was:" >&5
6631 – sed 's/^/| /' conftest.$ac_ext >&5
6632 –
6633 – eval "$as_ac_var=no"
6634 – fi
6635 – rm -f conftest.err conftest.$ac_objext \
6636 –      conftest$ac_exeext conftest.$ac_ext
6637 – fi
6638 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6639 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6640 – if test `eval echo '${'$as_ac_var'}'` = yes; then
6641 –  cat >>confdefs.h <<_ACEOF
6642 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11158   _ACEOF
11159  
11160   fi
11161 +
11162   done
11163  
11164  
11165  
11166  
11167 <
11168 <
11169 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6654 < do
6655 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6656 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6657 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6658 < if eval "test \"\${$as_ac_var+set}\" = set"; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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.  */
6667 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6668 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6669 – #define $ac_func innocuous_$ac_func
11190  
11191 < /* System header to define __stub macros and hopefully few prototypes,
11192 <    which can conflict with char $ac_func (); below.
6673 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6674 <    <limits.h> exists even on freestanding compilers.  */
6675 <
6676 < #ifdef __STDC__
6677 < # include <limits.h>
11191 > #ifdef HAVE_IOSTREAM
11192 > #include <iostream>
11193   #else
11194 < # include <assert.h>
11194 > #include <iostream.h>
11195   #endif
11196  
11197 < #undef $ac_func
11198 <
11199 < /* Override any gcc2 internal prototype to avoid an error.  */
11200 < #ifdef __cplusplus
11201 < extern "C"
11202 < {
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
6689 – /* We use char because int might match the return type of a gcc2
6690 –   builtin and then its argument prototype would still apply.  */
6691 – char $ac_func ();
6692 – /* The GNU C library defines this for functions which it implements
6693 –    to always fail with ENOSYS.  Some functions are actually named
6694 –    something starting with __ and the normal name is an alias.  */
6695 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6696 – choke me
6697 – #else
6698 – char (*f) () = $ac_func;
11204   #endif
6700 – #ifdef __cplusplus
6701 – }
6702 – #endif
6703 –
11205   int
11206   main ()
11207   {
11208 < return f != $ac_func;
11208 > std::cout<<"Hello World"<<std::endl;return 0;
11209    ;
11210    return 0;
11211   }
11212   _ACEOF
11213 < rm -f conftest.$ac_objext conftest$ac_exeext
11214 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11215 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"                   || test ! -s conftest.err'
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_exeext'
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 <  eval "$as_ac_var=yes"
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  
6738 – eval "$as_ac_var=no"
11240   fi
11241 < rm -f conftest.err conftest.$ac_objext \
11242 <      conftest$ac_exeext conftest.$ac_ext
6742 < fi
6743 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6744 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6745 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6746 <  cat >>confdefs.h <<_ACEOF
6747 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6748 < _ACEOF
6749 <
6750 < fi
6751 < done
6752 <
6753 < # special check for _system_configuration because AIX <4.3.2 do not
6754 < # contain the `physmem' member.
6755 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6756 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6757 < cat >conftest.$ac_ext <<_ACEOF
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 < #include <sys/systemcfg.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 < double x = _system_configuration.physmem;
11267 > std::cout<<"Hello World"<<std::endl;return 0;
11268    ;
11269    return 0;
11270   }
# Line 6778 | Line 11278 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11278    cat conftest.err >&5
11279    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11280    (exit $ac_status); } &&
11281 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 6790 | Line 11291 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11291    ac_status=$?
11292    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11293    (exit $ac_status); }; }; then
11294 <  echo "$as_me:$LINENO: result: yes" >&5
6794 < echo "${ECHO_T}yes" >&6
6795 <
6796 < cat >>confdefs.h <<\_ACEOF
6797 < #define HAVE__SYSTEM_CONFIGURATION 1
6798 < _ACEOF
6799 <
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 < echo "$as_me:$LINENO: result: no" >&5
6805 < echo "${ECHO_T}no" >&6
6806 < fi
11299 > fi
11300   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11301 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11302 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
11303 < if test "${ac_cv_header_time+set}" = set; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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 <sys/types.h>
6820 < #include <sys/time.h>
6821 < #include <time.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 < if ((struct tm *) 0)
6827 < return 0;
11365 > std::list<int> foo;return 0;
11366    ;
11367    return 0;
11368   }
# Line 6838 | Line 11376 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11376    cat conftest.err >&5
11377    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11378    (exit $ac_status); } &&
11379 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 6850 | Line 11389 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11389    ac_status=$?
11390    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11391    (exit $ac_status); }; }; then
11392 <  ac_cv_header_time=yes
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  
6858 – ac_cv_header_time=no
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_header_time" >&5
11409 < echo "${ECHO_T}$ac_cv_header_time" >&6
11410 < if test $ac_cv_header_time = yes; then
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 TIME_WITH_SYS_TIME 1
11413 > #define HAVE_STD_STL 1
11414   _ACEOF
11415  
11416 < fi
11416 >  fi
11417  
11418  
11419 < echo "$as_me:$LINENO: checking for clock_t" >&5
11420 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11421 < if test "${ac_cv_type_clock_t+set}" = set; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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 < $ac_includes_default
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 < if ((clock_t *) 0)
6889 <  return 0;
6890 < if (sizeof (clock_t))
6891 <  return 0;
11462 > int fd=0;ofstream s;s.attach(fd);
11463    ;
11464    return 0;
11465   }
# Line 6902 | Line 11473 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11473    cat conftest.err >&5
11474    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11475    (exit $ac_status); } &&
11476 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 6914 | Line 11486 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11486    ac_status=$?
11487    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11488    (exit $ac_status); }; }; then
11489 <  ac_cv_type_clock_t=yes
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  
6922 – ac_cv_type_clock_t=no
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_type_clock_t" >&5
11505 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11506 < if test $ac_cv_type_clock_t = yes; then
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_CLOCK_T 1
11508 > cat >>confdefs.h <<\_ACEOF
11509 > #define HAVE_FSTREAM_ATTACH 1
11510   _ACEOF
11511  
11512 +  fi
11513  
6935 – fi
11514  
11515 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11516 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11517 < if test "${ac_cv_c_const+set}" = set; then
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 <  cat >conftest.$ac_ext <<_ACEOF
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 < /* FIXME: Include the comments suggested by Paul. */
6953 < #ifndef __cplusplus
6954 <  /* Ultrix mips cc rejects this.  */
6955 <  typedef int charset[2];
6956 <  const charset x;
6957 <  /* SunOS 4.1.1 cc rejects this.  */
6958 <  char const *const *ccp;
6959 <  char **p;
6960 <  /* NEC SVR4.0.2 mips cc rejects this.  */
6961 <  struct point {int x, y;};
6962 <  static struct point const zero = {0,0};
6963 <  /* AIX XL C 1.02.0.0 rejects this.
6964 <     It does not let you subtract one const X* pointer from another in
6965 <     an arm of an if-expression whose if-part is not a constant
6966 <     expression */
6967 <  const char *g = "string";
6968 <  ccp = &g + (g ? g-g : 0);
6969 <  /* HPUX 7.0 cc rejects these. */
6970 <  ++ccp;
6971 <  p = (char**) ccp;
6972 <  ccp = (char const *const *) p;
6973 <  { /* SCO 3.2v4 cc rejects this.  */
6974 <    char *t;
6975 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
6976 <
6977 <    *t++ = 0;
6978 <  }
6979 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6980 <    int x[] = {25, 17};
6981 <    const int *foo = &x[0];
6982 <    ++foo;
6983 <  }
6984 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6985 <    typedef const int *iptr;
6986 <    iptr p = 0;
6987 <    ++p;
6988 <  }
6989 <  { /* AIX XL C 1.02.0.0 rejects this saying
6990 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6991 <    struct s { int j; const int *ap[3]; };
6992 <    struct s *b; b->j = 5;
6993 <  }
6994 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6995 <    const int foo = 10;
6996 <  }
6997 < #endif
6998 <
11560 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11561    ;
11562    return 0;
11563   }
# Line 7009 | Line 11571 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11571    cat conftest.err >&5
11572    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11573    (exit $ac_status); } &&
11574 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 7021 | Line 11584 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11584    ac_status=$?
11585    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11586    (exit $ac_status); }; }; then
11587 <  ac_cv_c_const=yes
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  
7029 – ac_cv_c_const=no
11592   fi
11593   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11594 < fi
11595 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7034 < echo "${ECHO_T}$ac_cv_c_const" >&6
7035 < if test $ac_cv_c_const = no; then
7036 <
7037 < cat >>confdefs.h <<\_ACEOF
7038 < #define const
7039 < _ACEOF
7040 <
7041 < fi
7042 <
7043 < echo "$as_me:$LINENO: checking for inline" >&5
7044 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7045 < if test "${ac_cv_c_inline+set}" = set; then
7046 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7047 < else
7048 <  ac_cv_c_inline=no
7049 < for ac_kw in inline __inline__ __inline; do
7050 <  cat >conftest.$ac_ext <<_ACEOF
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 < #ifndef __cplusplus
11602 < typedef int foo_t;
11603 < static $ac_kw foo_t static_foo () {return 0; }
11604 < $ac_kw foo_t foo () {return 0; }
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
# Line 7069 | Line 11633 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11633    cat conftest.err >&5
11634    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11635    (exit $ac_status); } &&
11636 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 7081 | Line 11646 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11646    ac_status=$?
11647    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648    (exit $ac_status); }; }; then
11649 <  ac_cv_c_inline=$ac_kw; break
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 < done
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_c_inline" >&5
11665 < echo "${ECHO_T}$ac_cv_c_inline" >&6
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 <
11669 < case $ac_cv_c_inline in
7099 <  inline | yes) ;;
7100 <  *)
7101 <    case $ac_cv_c_inline in
7102 <      no) ac_val=;;
7103 <      *) ac_val=$ac_cv_c_inline;;
7104 <    esac
7105 <    cat >>confdefs.h <<_ACEOF
7106 < #ifndef __cplusplus
7107 < #define inline $ac_val
7108 < #endif
11668 > cat >>confdefs.h <<\_ACEOF
11669 > #define HAVE_FSTREAM_OPEN 1
11670   _ACEOF
7110 –    ;;
7111 – esac
11671  
11672 +  fi
11673 +  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11674  
11675 <
11676 <
7116 < for ac_func in rint sranddev
7117 < do
7118 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7119 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7120 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7121 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7122 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7123 < else
7124 <  cat >conftest.$ac_ext <<_ACEOF
7125 < /* confdefs.h.  */
11675 > cat >>confdefs.h <<\_ACEOF
11676 > #define FSTREAM_OPEN_PROT 1
11677   _ACEOF
7127 – cat confdefs.h >>conftest.$ac_ext
7128 – cat >>conftest.$ac_ext <<_ACEOF
7129 – /* end confdefs.h.  */
7130 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7131 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7132 – #define $ac_func innocuous_$ac_func
11678  
11679 < /* System header to define __stub macros and hopefully few prototypes,
7135 <    which can conflict with char $ac_func (); below.
7136 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7137 <    <limits.h> exists even on freestanding compilers.  */
11679 >  fi
11680  
7139 – #ifdef __STDC__
7140 – # include <limits.h>
7141 – #else
7142 – # include <assert.h>
7143 – #endif
11681  
7145 – #undef $ac_func
11682  
7147 – /* Override any gcc2 internal prototype to avoid an error.  */
7148 – #ifdef __cplusplus
7149 – extern "C"
7150 – {
7151 – #endif
7152 – /* We use char because int might match the return type of a gcc2
7153 –   builtin and then its argument prototype would still apply.  */
7154 – char $ac_func ();
7155 – /* The GNU C library defines this for functions which it implements
7156 –    to always fail with ENOSYS.  Some functions are actually named
7157 –    something starting with __ and the normal name is an alias.  */
7158 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7159 – choke me
7160 – #else
7161 – char (*f) () = $ac_func;
7162 – #endif
7163 – #ifdef __cplusplus
7164 – }
7165 – #endif
11683  
7167 – int
7168 – main ()
7169 – {
7170 – return f != $ac_func;
7171 –  ;
7172 –  return 0;
7173 – }
7174 – _ACEOF
7175 – rm -f conftest.$ac_objext conftest$ac_exeext
7176 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7177 –  (eval $ac_link) 2>conftest.er1
7178 –  ac_status=$?
7179 –  grep -v '^ *+' conftest.er1 >conftest.err
7180 –  rm -f conftest.er1
7181 –  cat conftest.err >&5
7182 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7183 –  (exit $ac_status); } &&
7184 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7185 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7186 –  (eval $ac_try) 2>&5
7187 –  ac_status=$?
7188 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7189 –  (exit $ac_status); }; } &&
7190 –         { ac_try='test -s conftest$ac_exeext'
7191 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7192 –  (eval $ac_try) 2>&5
7193 –  ac_status=$?
7194 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7195 –  (exit $ac_status); }; }; then
7196 –  eval "$as_ac_var=yes"
7197 – else
7198 –  echo "$as_me: failed program was:" >&5
7199 – sed 's/^/| /' conftest.$ac_ext >&5
11684  
7201 – eval "$as_ac_var=no"
7202 – fi
7203 – rm -f conftest.err conftest.$ac_objext \
7204 –      conftest$ac_exeext conftest.$ac_ext
7205 – fi
7206 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7207 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7208 – if test `eval echo '${'$as_ac_var'}'` = yes; then
7209 –  cat >>confdefs.h <<_ACEOF
7210 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7211 – _ACEOF
11685  
7213 – fi
7214 – done
11686  
11687 <
7217 <  # clean out junk possibly left behind by a previous configuration
7218 <  rm -f src/getopt.h
7219 <  # Check for getopt_long support
7220 <
7221 < for ac_header in getopt.h
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
# Line 7251 | Line 11717 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11717    cat conftest.err >&5
11718    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11719    (exit $ac_status); } &&
11720 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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=$?
# Line 7294 | Line 11761 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_c_preproc_warn_flag
11765 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
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
# Line 7315 | Line 11782 | echo "${ECHO_T}$ac_header_preproc" >&6
11782   echo "${ECHO_T}$ac_header_preproc" >&6
11783  
11784   # So?  What about this header?
11785 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
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;}
# Line 7366 | Line 11833 | done
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 < for ac_func in getopt_long
11844 < do
11845 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11846 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7374 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7375 < if eval "test \"\${$as_ac_var+set}\" = set"; then
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
# Line 7381 | Line 11852 | cat >>conftest.$ac_ext <<_ACEOF
11852   cat confdefs.h >>conftest.$ac_ext
11853   cat >>conftest.$ac_ext <<_ACEOF
11854   /* end confdefs.h.  */
7384 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7385 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7386 – #define $ac_func innocuous_$ac_func
11855  
11856 < /* System header to define __stub macros and hopefully few prototypes,
11857 <    which can conflict with char $ac_func (); below.
11858 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11859 <    <limits.h> exists even on freestanding compilers.  */
11860 <
11861 < #ifdef __STDC__
7394 < # include <limits.h>
7395 < #else
7396 < # include <assert.h>
7397 < #endif
7398 <
7399 < #undef $ac_func
7400 <
7401 < /* Override any gcc2 internal prototype to avoid an error.  */
7402 < #ifdef __cplusplus
7403 < extern "C"
7404 < {
7405 < #endif
7406 < /* We use char because int might match the return type of a gcc2
7407 <   builtin and then its argument prototype would still apply.  */
7408 < char $ac_func ();
7409 < /* The GNU C library defines this for functions which it implements
7410 <    to always fail with ENOSYS.  Some functions are actually named
7411 <    something starting with __ and the normal name is an alias.  */
7412 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7413 < choke me
7414 < #else
7415 < char (*f) () = $ac_func;
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
7417 – #ifdef __cplusplus
7418 – }
11863   #endif
7420 –
11864   int
11865   main ()
11866   {
11867 < return f != $ac_func;
11867 > const char *foo = __func__;
11868    ;
11869    return 0;
11870   }
11871   _ACEOF
11872 < rm -f conftest.$ac_objext conftest$ac_exeext
11873 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11874 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"                   || test ! -s conftest.err'
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_exeext'
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 <  eval "$as_ac_var=yes"
11894 >  ac_cv_cpp_func=yes
11895   else
11896    echo "$as_me: failed program was:" >&5
11897   sed 's/^/| /' conftest.$ac_ext >&5
11898  
7455 – eval "$as_ac_var=no"
7456 – fi
7457 – rm -f conftest.err conftest.$ac_objext \
7458 –      conftest$ac_exeext conftest.$ac_ext
7459 – fi
7460 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7461 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7462 – if test `eval echo '${'$as_ac_var'}'` = yes; then
7463 –  cat >>confdefs.h <<_ACEOF
7464 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7465 – _ACEOF
7466 –
7467 – else
7468 –  # FreeBSD has a gnugetopt library for this
7469 –    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7470 – echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7471 – if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7472 –  echo $ECHO_N "(cached) $ECHO_C" >&6
7473 – else
7474 –  ac_check_lib_save_LIBS=$LIBS
7475 – LIBS="-lgnugetopt  $LIBS"
11899   cat >conftest.$ac_ext <<_ACEOF
11900   /* confdefs.h.  */
11901   _ACEOF
# Line 7480 | Line 11903 | cat >>conftest.$ac_ext <<_ACEOF
11903   cat >>conftest.$ac_ext <<_ACEOF
11904   /* end confdefs.h.  */
11905  
11906 < /* Override any gcc2 internal prototype to avoid an error.  */
11907 < #ifdef __cplusplus
11908 < extern "C"
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 < /* We use char because int might match the return type of a gcc2
7488 <   builtin and then its argument prototype would still apply.  */
7489 < char getopt_long ();
11913 > #endif
11914   int
11915   main ()
11916   {
11917 < getopt_long ();
11917 > const char *foo = __FUNCTION__;
11918    ;
11919    return 0;
11920   }
11921   _ACEOF
11922 < rm -f conftest.$ac_objext conftest$ac_exeext
11923 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11924 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"                   || test ! -s conftest.err'
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_exeext'
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_lib_gnugetopt_getopt_long=yes
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_lib_gnugetopt_getopt_long=no
11949 > ac_cv_cpp_func=no
11950   fi
11951 < rm -f conftest.err conftest.$ac_objext \
7527 <      conftest$ac_exeext conftest.$ac_ext
7528 < LIBS=$ac_check_lib_save_LIBS
11951 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11952   fi
11953 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11954 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11955 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11956 <  cat >>confdefs.h <<\_ACEOF
11957 < #define HAVE_GETOPT_LONG 1
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 < else
7538 <  # use the GNU replacement
7539 <      case $LIBOBJS in
7540 <    "getopt.$ac_objext"   | \
7541 <  *" getopt.$ac_objext"   | \
7542 <    "getopt.$ac_objext "* | \
7543 <  *" getopt.$ac_objext "* ) ;;
7544 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7545 < esac
11963 > elif test $ac_cv_cpp_func = no; then
11964  
11965 <      case $LIBOBJS in
11966 <    "getopt1.$ac_objext"   | \
11967 <  *" getopt1.$ac_objext"   | \
7550 <    "getopt1.$ac_objext "* | \
7551 <  *" getopt1.$ac_objext "* ) ;;
7552 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7553 < esac
11965 > cat >>confdefs.h <<\_ACEOF
11966 > #define __func__ ""
11967 > _ACEOF
11968  
7555 –                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7556 –
11969   fi
11970  
11971 < fi
7560 < done
11971 >
11972  
11973  
11974  
# Line 7569 | Line 11980 | case $debug in
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
# Line 7579 | Line 12101 | cat > conftest.c <<EOF
12101  
12102   cat > conftest.c <<EOF
12103   #ifdef __GNUC__
12104 <  #ifndef __INTEL_COMPILER
12104 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12105 >     no;
12106 >  #else
12107       yes;
12108    #endif
12109   #endif
# Line 7617 | Line 12141 | if test "$ac_test_CFLAGS" != "set"; then
12141                      CFLAGS="-O"
12142                  fi;;
12143    sparc-solaris2*) if test "$CC" = cc; then
12144 <                    CFLAGS="-native -fast -xO5 -dalign"
12144 >                    CFLAGS="-O -dalign"
12145                   fi;;
12146  
12147    alpha*-osf*)  if test "$CC" = cc; then
# Line 7647 | Line 12171 | if test "$ac_test_CFLAGS" != "set"; then
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  
# Line 7660 | Line 12187 | if test "$ac_test_CFLAGS" != "set"; then
12187      # -malign-double for x86 systems
12188  
12189  
12190 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12191 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
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-cc} -malign-double -c conftest.c 2>&1`"; then
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
# Line 7687 | Line 12214 | fi
12214      # -fstrict-aliasing for gcc-2.95+
12215  
12216  
12217 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12218 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
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-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
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
# Line 7718 | Line 12245 | fi
12245                    case "${host_cpu}" in
12246            i586*)
12247  
12248 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12249 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
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-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
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
# Line 7741 | Line 12268 | else
12268          :
12269  
12270  
12271 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12272 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
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-cc} -mpentium -c conftest.c 2>&1`"; then
12277 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12278          ac_pentium=yes
12279   else
12280          ac_pentium=no
# Line 7770 | Line 12297 | fi
12297                    ;;
12298            i686*)
12299  
12300 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12301 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
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-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
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
# Line 7793 | Line 12320 | else
12320          :
12321  
12322  
12323 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12324 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
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-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12329 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12330          ac_pentiumpro=yes
12331   else
12332          ac_pentiumpro=no
# Line 7826 | Line 12353 | fi
12353                  if test -n "$is60x"; then
12354  
12355  
12356 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12357 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
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-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
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
# Line 7884 | Line 12411 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12411          :
12412  
12413  
12414 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12415 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
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-cc} -mcpu=750 -c conftest.c 2>&1`"; then
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
# Line 7917 | Line 12444 | fi
12444                  if test -z "$CPU_FLAGS"; then
12445  
12446  
12447 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12448 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
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-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
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
# Line 7945 | Line 12472 | fi
12472                  if test -z "$CPU_FLAGS"; then
12473  
12474  
12475 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12476 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
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-cc} -mpowerpc -c conftest.c 2>&1`"; then
12481 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12482          ac_m_powerpc=yes
12483   else
12484          ac_m_powerpc=no
# Line 7990 | Line 12517 | fi
12517  
12518  
12519  
12520 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12521 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
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-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12526 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12527          ac_guessed_cflags=yes
12528   else
12529          ac_guessed_cflags=no
# Line 8040 | Line 12567 | cat > conftest.cpp <<EOF
12567  
12568   cat > conftest.cpp <<EOF
12569   #ifdef __GNUC__
12570 <  #ifndef __INTEL_COMPILER
12570 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12571 >     no;
12572 >  #else
12573       yes;
12574    #endif
12575   #endif
# Line 8078 | Line 12607 | if test "$ac_test_CXXFLAGS" != "set"; then
12607                      CXXFLAGS="-O"
12608                  fi;;
12609    sparc-solaris2*) if test "$CXX" = CC; then
12610 <                    CXXFLAGS="-native -fast -xO5 -dalign"
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"
# Line 8099 | Line 12628 | if test "$ac_test_CXXFLAGS" != "set"; then
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  
# Line 8112 | Line 12644 | if test "$ac_test_CXXFLAGS" != "set"; then
12644      # -malign-double for x86 systems
12645  
12646  
12647 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12648 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
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-c++} -malign-double -c conftest.cpp 2>&1`"; then
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
# Line 8139 | Line 12671 | fi
12671      # -fstrict-aliasing for gcc-2.95+
12672  
12673  
12674 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12675 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
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-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
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
# Line 8170 | Line 12702 | fi
12702                    case "${host_cpu}" in
12703            i586*)
12704  
12705 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12706 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
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-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
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
# Line 8193 | Line 12725 | else
12725          :
12726  
12727  
12728 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12729 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
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-c++} -mpentium -c conftest.cpp 2>&1`"; then
12734 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12735          ac_pentium=yes
12736   else
12737          ac_pentium=no
# Line 8222 | Line 12754 | fi
12754                    ;;
12755            i686*)
12756  
12757 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12758 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
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-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
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
# Line 8245 | Line 12777 | else
12777          :
12778  
12779  
12780 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12781 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
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-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12786 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12787          ac_pentiumpro=yes
12788   else
12789          ac_pentiumpro=no
# Line 8278 | Line 12810 | fi
12810                  if test -n "$is60x"; then
12811  
12812  
12813 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12814 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
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-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
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
# Line 8336 | Line 12868 | if test "$ac_cv_prog_gxx_2_95" = yes; then
12868          :
12869  
12870  
12871 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12872 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
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-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
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
# Line 8369 | Line 12901 | fi
12901                  if test -z "$CPU_FLAGS"; then
12902  
12903  
12904 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12905 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
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-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
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
# Line 8397 | Line 12929 | fi
12929                  if test -z "$CPU_FLAGS"; then
12930  
12931  
12932 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12933 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
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-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12938 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12939          ac_m_powerpc=yes
12940   else
12941          ac_m_powerpc=no
# Line 8442 | Line 12974 | fi
12974  
12975  
12976  
12977 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12978 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
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-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12983 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12984          ac_guessed_cxxflags=yes
12985   else
12986          ac_guessed_cxxflags=no
# Line 8472 | Line 13004 | else
13004          echo "**********************************************************"
13005          echo ""
13006          CXXFLAGS=""
8475 –
8476 – fi
8477 –
8478 –
8479 – fi
8480 –
8481 –
8482 –
8483 –
8484 –
8485 – # Try to determine "good" native compiler flags if none specified on command
8486 – # line
8487 –
8488 – if test x"$F90FLAGS" = x ; then
8489 –  F90FLAGS=""
8490 –  case "${host_cpu}-${host_os}" in
8491 –
8492 –  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8493 –                    F90FLAGS="-O"
8494 –                fi;;
8495 –   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8496 –                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8497 –                fi;;
8498 –   powerpc*-aix*)
8499 –        if test "$F90" = f90 -o "$F90" = xlf90; then
8500 –                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8501 –                echo "*******************************************************"
8502 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8503 –                echo "*  recommended that you use                           *"
8504 –                echo "*                                                     *"
8505 –                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8506 –                echo "*                                 ^^^                 *"
8507 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8508 –                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8509 –                echo "*******************************************************"
8510 –        fi;;
8511 –   *darwin*)
8512 –        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8513 –                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8514 –        fi;;
8515 –  esac
8516 –
8517 –  if test -n "$CPU_FLAGS"; then
8518 –        F90FLAGS="$F90FLAGS $CPU_FLAGS"
8519 –  fi
8520 –
8521 –  if test -z "$F90FLAGS"; then
8522 –        echo ""
8523 –        echo "**********************************************************"
8524 –        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8525 –        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8526 –        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8527 –        echo "**********************************************************"
8528 –        echo ""
8529 –        F90FLAGS="-O3"
8530 –  fi
8531 –
8532 –
8533 – echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8534 – echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8535 – if test "${ac_guessed_f90flags+set}" = set; then
8536 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8537 – else
8538 –
8539 –
8540 –
8541 – ac_ext=f90
8542 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8543 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8544 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8545 –
8546 – echo 'program main' > conftest.$ac_ext
8547 – echo 'end program main' >> conftest.$ac_ext
8548 – ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8549 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8550 –  (eval $ac_compile) 2>&5
8551 –  ac_status=$?
8552 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8553 –  (exit $ac_status); }; then
8554 –        ac_guessed_f90flags=yes
8555 – else
8556 –        ac_guessed_f90flags=no
8557 – fi
8558 – rm -f conftest*
8559 – ac_ext=c
8560 – ac_cpp='$CPP $CPPFLAGS'
8561 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8562 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8563 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
8564 –
8565 –
8566 – fi
8567 – echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8568 – echo "${ECHO_T}$ac_guessed_f90flags" >&6
8569 – if test "$ac_guessed_f90flags" = yes; then
8570 –        :
8571 –
8572 – else
8573 –        :
8574 –
8575 –        echo ""
8576 –        echo "**********************************************************"
8577 –        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8578 –        echo "* your compiler.                                         *"
8579 –        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8580 –        echo "**********************************************************"
8581 –        echo ""
8582 –        F90FLAGS=""
13007  
13008   fi
13009  
# Line 8588 | Line 13012 | esac
13012  
13013       ;;
13014   esac
8591 –
8592 – # Find a good install program.  We prefer a C program (faster),
8593 – # so one script is as good as another.  But avoid the broken or
8594 – # incompatible versions:
8595 – # SysV /etc/install, /usr/sbin/install
8596 – # SunOS /usr/etc/install
8597 – # IRIX /sbin/install
8598 – # AIX /bin/install
8599 – # AmigaOS /C/install, which installs bootblocks on floppy discs
8600 – # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8601 – # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8602 – # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8603 – # OS/2's system install, which has a completely different semantic
8604 – # ./install, which can be erroneously created by make from ./install.sh.
8605 – echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8606 – echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8607 – if test -z "$INSTALL"; then
8608 – if test "${ac_cv_path_install+set}" = set; then
8609 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8610 – else
8611 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8612 – for as_dir in $PATH
8613 – do
8614 –  IFS=$as_save_IFS
8615 –  test -z "$as_dir" && as_dir=.
8616 –  # Account for people who put trailing slashes in PATH elements.
8617 – case $as_dir/ in
8618 –  ./ | .// | /cC/* | \
8619 –  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8620 –  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8621 –  /usr/ucb/* ) ;;
8622 –  *)
8623 –    # OSF1 and SCO ODT 3.0 have their own names for install.
8624 –    # Don't use installbsd from OSF since it installs stuff as root
8625 –    # by default.
8626 –    for ac_prog in ginstall scoinst install; do
8627 –      for ac_exec_ext in '' $ac_executable_extensions; do
8628 –        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8629 –          if test $ac_prog = install &&
8630 –            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8631 –            # AIX install.  It has an incompatible calling convention.
8632 –            :
8633 –          elif test $ac_prog = install &&
8634 –            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8635 –            # program-specific install script used by HP pwplus--don't use.
8636 –            :
8637 –          else
8638 –            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8639 –            break 3
8640 –          fi
8641 –        fi
8642 –      done
8643 –    done
8644 –    ;;
8645 – esac
8646 – done
8647 –
8648 –
8649 – fi
8650 –  if test "${ac_cv_path_install+set}" = set; then
8651 –    INSTALL=$ac_cv_path_install
8652 –  else
8653 –    # As a last resort, use the slow shell script.  We don't cache a
8654 –    # path for INSTALL within a source directory, because that will
8655 –    # break other packages using the cache if that directory is
8656 –    # removed, or if the path is relative.
8657 –    INSTALL=$ac_install_sh
8658 –  fi
8659 – fi
8660 – echo "$as_me:$LINENO: result: $INSTALL" >&5
8661 – echo "${ECHO_T}$INSTALL" >&6
8662 –
8663 – # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8664 – # It thinks the first close brace ends the variable substitution.
8665 – test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8666 –
8667 – test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8668 –
8669 – test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8670 –
8671 – echo "$as_me:$LINENO: checking whether ln -s works" >&5
8672 – echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8673 – LN_S=$as_ln_s
8674 – if test "$LN_S" = "ln -s"; then
8675 –  echo "$as_me:$LINENO: result: yes" >&5
8676 – echo "${ECHO_T}yes" >&6
8677 – else
8678 –  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8679 – echo "${ECHO_T}no, using $LN_S" >&6
8680 – fi
8681 –
8682 – echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8683 – echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8684 – set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8685 – if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
8686 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8687 – else
8688 –  cat >conftest.make <<\_ACEOF
8689 – all:
8690 –        @echo 'ac_maketemp="$(MAKE)"'
8691 – _ACEOF
8692 – # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8693 – eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8694 – if test -n "$ac_maketemp"; then
8695 –  eval ac_cv_prog_make_${ac_make}_set=yes
8696 – else
8697 –  eval ac_cv_prog_make_${ac_make}_set=no
8698 – fi
8699 – rm -f conftest.make
8700 – fi
8701 – if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
8702 –  echo "$as_me:$LINENO: result: yes" >&5
8703 – echo "${ECHO_T}yes" >&6
8704 –  SET_MAKE=
8705 – else
8706 –  echo "$as_me:$LINENO: result: no" >&5
8707 – echo "${ECHO_T}no" >&6
8708 –  SET_MAKE="MAKE=${MAKE-make}"
8709 – fi
8710 –
8711 – if test -n "$ac_tool_prefix"; then
8712 –  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
8713 – set dummy ${ac_tool_prefix}ranlib; ac_word=$2
8714 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8715 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8716 – if test "${ac_cv_prog_RANLIB+set}" = set; then
8717 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8718 – else
8719 –  if test -n "$RANLIB"; then
8720 –  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8721 – else
8722 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8723 – for as_dir in $PATH
8724 – do
8725 –  IFS=$as_save_IFS
8726 –  test -z "$as_dir" && as_dir=.
8727 –  for ac_exec_ext in '' $ac_executable_extensions; do
8728 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8729 –    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8730 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8731 –    break 2
8732 –  fi
8733 – done
8734 – done
13015  
8736 – fi
8737 – fi
8738 – RANLIB=$ac_cv_prog_RANLIB
8739 – if test -n "$RANLIB"; then
8740 –  echo "$as_me:$LINENO: result: $RANLIB" >&5
8741 – echo "${ECHO_T}$RANLIB" >&6
8742 – else
8743 –  echo "$as_me:$LINENO: result: no" >&5
8744 – echo "${ECHO_T}no" >&6
8745 – fi
13016  
8747 – fi
8748 – if test -z "$ac_cv_prog_RANLIB"; then
8749 –  ac_ct_RANLIB=$RANLIB
8750 –  # Extract the first word of "ranlib", so it can be a program name with args.
8751 – set dummy ranlib; ac_word=$2
8752 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8753 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8754 – if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
8755 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8756 – else
8757 –  if test -n "$ac_ct_RANLIB"; then
8758 –  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
8759 – else
8760 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8761 – for as_dir in $PATH
8762 – do
8763 –  IFS=$as_save_IFS
8764 –  test -z "$as_dir" && as_dir=.
8765 –  for ac_exec_ext in '' $ac_executable_extensions; do
8766 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8767 –    ac_cv_prog_ac_ct_RANLIB="ranlib"
8768 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8769 –    break 2
8770 –  fi
8771 – done
8772 – done
8773 –
8774 –  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
8775 – fi
8776 – fi
8777 – ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
8778 – if test -n "$ac_ct_RANLIB"; then
8779 –  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
8780 – echo "${ECHO_T}$ac_ct_RANLIB" >&6
8781 – else
8782 –  echo "$as_me:$LINENO: result: no" >&5
8783 – echo "${ECHO_T}no" >&6
8784 – fi
8785 –
8786 –  RANLIB=$ac_ct_RANLIB
8787 – else
8788 –  RANLIB="$ac_cv_prog_RANLIB"
8789 – fi
8790 –
8791 – for ac_prog in 'bison -y' byacc
8792 – do
8793 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
8794 – set dummy $ac_prog; ac_word=$2
8795 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8796 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8797 – if test "${ac_cv_prog_YACC+set}" = set; then
8798 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8799 – else
8800 –  if test -n "$YACC"; then
8801 –  ac_cv_prog_YACC="$YACC" # Let the user override the test.
8802 – else
8803 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804 – for as_dir in $PATH
8805 – do
8806 –  IFS=$as_save_IFS
8807 –  test -z "$as_dir" && as_dir=.
8808 –  for ac_exec_ext in '' $ac_executable_extensions; do
8809 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810 –    ac_cv_prog_YACC="$ac_prog"
8811 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812 –    break 2
8813 –  fi
8814 – done
8815 – done
8816 –
8817 – fi
8818 – fi
8819 – YACC=$ac_cv_prog_YACC
8820 – if test -n "$YACC"; then
8821 –  echo "$as_me:$LINENO: result: $YACC" >&5
8822 – echo "${ECHO_T}$YACC" >&6
8823 – else
8824 –  echo "$as_me:$LINENO: result: no" >&5
8825 – echo "${ECHO_T}no" >&6
8826 – fi
8827 –
8828 –  test -n "$YACC" && break
8829 – done
8830 – test -n "$YACC" || YACC="yacc"
8831 –
8832 – for ac_prog in flex lex
8833 – do
8834 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
8835 – set dummy $ac_prog; ac_word=$2
8836 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8837 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8838 – if test "${ac_cv_prog_LEX+set}" = set; then
8839 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8840 – else
8841 –  if test -n "$LEX"; then
8842 –  ac_cv_prog_LEX="$LEX" # Let the user override the test.
8843 – else
8844 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8845 – for as_dir in $PATH
8846 – do
8847 –  IFS=$as_save_IFS
8848 –  test -z "$as_dir" && as_dir=.
8849 –  for ac_exec_ext in '' $ac_executable_extensions; do
8850 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8851 –    ac_cv_prog_LEX="$ac_prog"
8852 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8853 –    break 2
8854 –  fi
8855 – done
8856 – done
8857 –
8858 – fi
8859 – fi
8860 – LEX=$ac_cv_prog_LEX
8861 – if test -n "$LEX"; then
8862 –  echo "$as_me:$LINENO: result: $LEX" >&5
8863 – echo "${ECHO_T}$LEX" >&6
8864 – else
8865 –  echo "$as_me:$LINENO: result: no" >&5
8866 – echo "${ECHO_T}no" >&6
8867 – fi
8868 –
8869 –  test -n "$LEX" && break
8870 – done
8871 – test -n "$LEX" || LEX=":"
8872 –
8873 – if test -z "$LEXLIB"
8874 – then
8875 –  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8876 – echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8877 – if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8878 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8879 – else
8880 –  ac_check_lib_save_LIBS=$LIBS
8881 – LIBS="-lfl  $LIBS"
8882 – cat >conftest.$ac_ext <<_ACEOF
8883 – /* confdefs.h.  */
8884 – _ACEOF
8885 – cat confdefs.h >>conftest.$ac_ext
8886 – cat >>conftest.$ac_ext <<_ACEOF
8887 – /* end confdefs.h.  */
8888 –
8889 – /* Override any gcc2 internal prototype to avoid an error.  */
8890 – #ifdef __cplusplus
8891 – extern "C"
8892 – #endif
8893 – /* We use char because int might match the return type of a gcc2
8894 –   builtin and then its argument prototype would still apply.  */
8895 – char yywrap ();
8896 – int
8897 – main ()
8898 – {
8899 – yywrap ();
8900 –  ;
8901 –  return 0;
8902 – }
8903 – _ACEOF
8904 – rm -f conftest.$ac_objext conftest$ac_exeext
8905 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8906 –  (eval $ac_link) 2>conftest.er1
8907 –  ac_status=$?
8908 –  grep -v '^ *+' conftest.er1 >conftest.err
8909 –  rm -f conftest.er1
8910 –  cat conftest.err >&5
8911 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8912 –  (exit $ac_status); } &&
8913 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8914 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8915 –  (eval $ac_try) 2>&5
8916 –  ac_status=$?
8917 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8918 –  (exit $ac_status); }; } &&
8919 –         { ac_try='test -s conftest$ac_exeext'
8920 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8921 –  (eval $ac_try) 2>&5
8922 –  ac_status=$?
8923 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8924 –  (exit $ac_status); }; }; then
8925 –  ac_cv_lib_fl_yywrap=yes
8926 – else
8927 –  echo "$as_me: failed program was:" >&5
8928 – sed 's/^/| /' conftest.$ac_ext >&5
8929 –
8930 – ac_cv_lib_fl_yywrap=no
8931 – fi
8932 – rm -f conftest.err conftest.$ac_objext \
8933 –      conftest$ac_exeext conftest.$ac_ext
8934 – LIBS=$ac_check_lib_save_LIBS
8935 – fi
8936 – echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8937 – echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8938 – if test $ac_cv_lib_fl_yywrap = yes; then
8939 –  LEXLIB="-lfl"
8940 – else
8941 –  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8942 – echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8943 – if test "${ac_cv_lib_l_yywrap+set}" = set; then
8944 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8945 – else
8946 –  ac_check_lib_save_LIBS=$LIBS
8947 – LIBS="-ll  $LIBS"
8948 – cat >conftest.$ac_ext <<_ACEOF
8949 – /* confdefs.h.  */
8950 – _ACEOF
8951 – cat confdefs.h >>conftest.$ac_ext
8952 – cat >>conftest.$ac_ext <<_ACEOF
8953 – /* end confdefs.h.  */
8954 –
8955 – /* Override any gcc2 internal prototype to avoid an error.  */
8956 – #ifdef __cplusplus
8957 – extern "C"
8958 – #endif
8959 – /* We use char because int might match the return type of a gcc2
8960 –   builtin and then its argument prototype would still apply.  */
8961 – char yywrap ();
8962 – int
8963 – main ()
8964 – {
8965 – yywrap ();
8966 –  ;
8967 –  return 0;
8968 – }
8969 – _ACEOF
8970 – rm -f conftest.$ac_objext conftest$ac_exeext
8971 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8972 –  (eval $ac_link) 2>conftest.er1
8973 –  ac_status=$?
8974 –  grep -v '^ *+' conftest.er1 >conftest.err
8975 –  rm -f conftest.er1
8976 –  cat conftest.err >&5
8977 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8978 –  (exit $ac_status); } &&
8979 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8980 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8981 –  (eval $ac_try) 2>&5
8982 –  ac_status=$?
8983 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8984 –  (exit $ac_status); }; } &&
8985 –         { ac_try='test -s conftest$ac_exeext'
8986 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8987 –  (eval $ac_try) 2>&5
8988 –  ac_status=$?
8989 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8990 –  (exit $ac_status); }; }; then
8991 –  ac_cv_lib_l_yywrap=yes
8992 – else
8993 –  echo "$as_me: failed program was:" >&5
8994 – sed 's/^/| /' conftest.$ac_ext >&5
8995 –
8996 – ac_cv_lib_l_yywrap=no
8997 – fi
8998 – rm -f conftest.err conftest.$ac_objext \
8999 –      conftest$ac_exeext conftest.$ac_ext
9000 – LIBS=$ac_check_lib_save_LIBS
9001 – fi
9002 – echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9003 – echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9004 – if test $ac_cv_lib_l_yywrap = yes; then
9005 –  LEXLIB="-ll"
9006 – fi
9007 –
9008 – fi
9009 –
9010 – fi
9011 –
9012 – if test "x$LEX" != "x:"; then
9013 –  echo "$as_me:$LINENO: checking lex output file root" >&5
9014 – echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9015 – if test "${ac_cv_prog_lex_root+set}" = set; then
9016 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9017 – else
9018 –  # The minimal lex program is just a single line: %%.  But some broken lexes
9019 – # (Solaris, I think it was) want two %% lines, so accommodate them.
9020 – cat >conftest.l <<_ACEOF
9021 – %%
9022 – %%
9023 – _ACEOF
9024 – { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9025 –  (eval $LEX conftest.l) 2>&5
9026 –  ac_status=$?
9027 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9028 –  (exit $ac_status); }
9029 – if test -f lex.yy.c; then
9030 –  ac_cv_prog_lex_root=lex.yy
9031 – elif test -f lexyy.c; then
9032 –  ac_cv_prog_lex_root=lexyy
9033 – else
9034 –  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9035 – echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9036 –   { (exit 1); exit 1; }; }
9037 – fi
9038 – fi
9039 – echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9040 – echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9041 – rm -f conftest.l
9042 – LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
9043 –
9044 – echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9045 – echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9046 – if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9047 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9048 – else
9049 –  # POSIX says lex can declare yytext either as a pointer or an array; the
9050 – # default is implementation-dependent. Figure out which it is, since
9051 – # not all implementations provide the %pointer and %array declarations.
9052 – ac_cv_prog_lex_yytext_pointer=no
9053 – echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9054 – ac_save_LIBS=$LIBS
9055 – LIBS="$LIBS $LEXLIB"
9056 – cat >conftest.$ac_ext <<_ACEOF
9057 – `cat $LEX_OUTPUT_ROOT.c`
9058 – _ACEOF
9059 – rm -f conftest.$ac_objext conftest$ac_exeext
9060 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9061 –  (eval $ac_link) 2>conftest.er1
9062 –  ac_status=$?
9063 –  grep -v '^ *+' conftest.er1 >conftest.err
9064 –  rm -f conftest.er1
9065 –  cat conftest.err >&5
9066 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067 –  (exit $ac_status); } &&
9068 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9069 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9070 –  (eval $ac_try) 2>&5
9071 –  ac_status=$?
9072 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073 –  (exit $ac_status); }; } &&
9074 –         { ac_try='test -s conftest$ac_exeext'
9075 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9076 –  (eval $ac_try) 2>&5
9077 –  ac_status=$?
9078 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9079 –  (exit $ac_status); }; }; then
9080 –  ac_cv_prog_lex_yytext_pointer=yes
9081 – else
9082 –  echo "$as_me: failed program was:" >&5
9083 – sed 's/^/| /' conftest.$ac_ext >&5
9084 –
9085 – fi
9086 – rm -f conftest.err conftest.$ac_objext \
9087 –      conftest$ac_exeext conftest.$ac_ext
9088 – LIBS=$ac_save_LIBS
9089 – rm -f "${LEX_OUTPUT_ROOT}.c"
9090 –
9091 – fi
9092 – echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9093 – echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9094 – if test $ac_cv_prog_lex_yytext_pointer = yes; then
9095 –
9096 – cat >>confdefs.h <<\_ACEOF
9097 – #define YYTEXT_POINTER 1
9098 – _ACEOF
9099 –
9100 – fi
9101 –
9102 – fi
9103 –
9104 –   # Extract the first word of "perl", so it can be a program name with args.
9105 – set dummy perl; ac_word=$2
9106 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9107 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9108 – if test "${ac_cv_path_PERLINTERP+set}" = set; then
9109 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9110 – else
9111 –  case $PERLINTERP in
9112 –  [\\/]* | ?:[\\/]*)
9113 –  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9114 –  ;;
9115 –  *)
9116 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9117 – for as_dir in $PATH
9118 – do
9119 –  IFS=$as_save_IFS
9120 –  test -z "$as_dir" && as_dir=.
9121 –  for ac_exec_ext in '' $ac_executable_extensions; do
9122 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9123 –    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9124 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9125 –    break 2
9126 –  fi
9127 – done
9128 – done
9129 –
9130 –  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9131 –  ;;
9132 – esac
9133 – fi
9134 – PERLINTERP=$ac_cv_path_PERLINTERP
9135 –
9136 – if test -n "$PERLINTERP"; then
9137 –  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9138 – echo "${ECHO_T}$PERLINTERP" >&6
9139 – else
9140 –  echo "$as_me:$LINENO: result: no" >&5
9141 – echo "${ECHO_T}no" >&6
9142 – fi
9143 –
9144 –   ac_cv_path_perlinterp="$PERLINTERP"
9145 –   _sHpB='#!'
9146 –
9147 –
9148 – # Check whether --with-perl-shebang or --without-perl-shebang was given.
9149 – if test "${with_perl_shebang+set}" = set; then
9150 –  withval="$with_perl_shebang"
9151 –  opt_perl_shebang="$withval"
9152 – else
9153 –                opt_perl_shebang="not_set"
9154 – fi;
9155 –   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9156 – echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9157 – if test "${ax_cv_opt_perl_shebang+set}" = set; then
9158 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9159 – else
9160 –   case "$opt_perl_shebang" in
9161 –                      not_set  ) ax_cv_opt_perl_shebang=''
9162 –                               ;;
9163 –                         *     )
9164 –        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9165 –                    esac
9166 –
9167 – fi
9168 – echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9169 – echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9170 –   if test "A$ax_cv_opt_perl_shebang" != "A"
9171 –     then
9172 –       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9173 –       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9174 –              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9175 – echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
9176 –
9177 – # Automatic detection of sharpbang formula starts here
9178 –     else
9179 –   _somian_shbangperl=`$PERLINTERP -V:startperl`
9180 –   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9181 –   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9182 – echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9183 – if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9184 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9185 – else
9186 –  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9187 –        if test "x$_somian_kspb_perl" == x
9188 –          then _somian_ksbp_warn_empty='durnit'
9189 –          else
9190 –          case "A$_somian_kspb_perl" in
9191 –                 A#!*perl* )
9192 –           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9193 –                        ;;
9194 –                     A*    )  _somian_ksbp_warn_defau='trouble'
9195 –                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9196 –          esac
9197 –        fi
9198 –
9199 – fi
9200 – echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
9201 – echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
9202 – # The above prints Checking ... result message to user.
9203 –   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9204 –
9205 –    if test A${_somian_ksbp_warn_empty+set} == Aset
9206 –      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9207 – echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9208 –    fi
9209 – # Inform user after printing result value
9210 –    if test A${_somian_ksbp_warn_defau+set} == Aset
9211 –      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9212 – echo "$as_me: Maybe Not good -" >&6;}
9213 –           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9214 – echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9215 –      else { echo "$as_me:$LINENO: OK Good result - " >&5
9216 – echo "$as_me: OK Good result - " >&6;}
9217 –           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9218 – echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9219 –    fi
9220 –  fi
9221 –
9222 – # Extract the first word of "ar", so it can be a program name with args.
9223 – set dummy ar; ac_word=$2
9224 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9225 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9226 – if test "${ac_cv_prog_AR+set}" = set; then
9227 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9228 – else
9229 –  if test -n "$AR"; then
9230 –  ac_cv_prog_AR="$AR" # Let the user override the test.
9231 – else
9232 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9233 – for as_dir in $PATH
9234 – do
9235 –  IFS=$as_save_IFS
9236 –  test -z "$as_dir" && as_dir=.
9237 –  for ac_exec_ext in '' $ac_executable_extensions; do
9238 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9239 –    ac_cv_prog_AR="ar"
9240 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9241 –    break 2
9242 –  fi
9243 – done
9244 – done
9245 –
9246 –  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
9247 – fi
9248 – fi
9249 – AR=$ac_cv_prog_AR
9250 – if test -n "$AR"; then
9251 –  echo "$as_me:$LINENO: result: $AR" >&5
9252 – echo "${ECHO_T}$AR" >&6
9253 – else
9254 –  echo "$as_me:$LINENO: result: no" >&5
9255 – echo "${ECHO_T}no" >&6
9256 – fi
9257 –
9258 – if test "$AR" = "NONE"; then
9259 –  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
9260 – echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9261 –   { (exit 1); exit 1; }; }
9262 –  cat >confcache <<\_ACEOF
9263 – # This file is a shell script that caches the results of configure
9264 – # tests run on this system so they can be shared between configure
9265 – # scripts and configure runs, see configure's option --config-cache.
9266 – # It is not useful on other systems.  If it contains results you don't
9267 – # want to keep, you may remove or edit it.
9268 – #
9269 – # config.status only pays attention to the cache file if you give it
9270 – # the --recheck option to rerun configure.
9271 – #
9272 – # `ac_cv_env_foo' variables (set or unset) will be overridden when
9273 – # loading this file, other *unset* `ac_cv_foo' will be assigned the
9274 – # following values.
9275 –
9276 – _ACEOF
9277 –
9278 – # The following way of writing the cache mishandles newlines in values,
9279 – # but we know of no workaround that is simple, portable, and efficient.
9280 – # So, don't put newlines in cache variables' values.
9281 – # Ultrix sh set writes to stderr and can't be redirected directly,
9282 – # and sets the high bit in the cache file unless we assign to the vars.
9283 – {
9284 –  (set) 2>&1 |
9285 –    case `(ac_space=' '; set | grep ac_space) 2>&1` in
9286 –    *ac_space=\ *)
9287 –      # `set' does not quote correctly, so add quotes (double-quote
9288 –      # substitution turns \\\\ into \\, and sed turns \\ into \).
9289 –      sed -n \
9290 –        "s/'/'\\\\''/g;
9291 –          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9292 –      ;;
9293 –    *)
9294 –      # `set' quotes correctly as required by POSIX, so do not add quotes.
9295 –      sed -n \
9296 –        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9297 –      ;;
9298 –    esac;
9299 – } |
9300 –  sed '
9301 –     t clear
9302 –     : clear
9303 –     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9304 –     t end
9305 –     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9306 –     : end' >>confcache
9307 – if diff $cache_file confcache >/dev/null 2>&1; then :; else
9308 –  if test -w $cache_file; then
9309 –    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9310 –    cat confcache >$cache_file
9311 –  else
9312 –    echo "not updating unwritable cache $cache_file"
9313 –  fi
9314 – fi
9315 – rm -f confcache
9316 –  exit 1
9317 – fi
9318 –
9319 – # Extract the first word of "ps", so it can be a program name with args.
9320 – set dummy ps; ac_word=$2
9321 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9322 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9323 – if test "${ac_cv_path_PS+set}" = set; then
9324 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9325 – else
9326 –  case $PS in
9327 –  [\\/]* | ?:[\\/]*)
9328 –  ac_cv_path_PS="$PS" # Let the user override the test with a path.
9329 –  ;;
9330 –  *)
9331 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9332 – for as_dir in $PATH
9333 – do
9334 –  IFS=$as_save_IFS
9335 –  test -z "$as_dir" && as_dir=.
9336 –  for ac_exec_ext in '' $ac_executable_extensions; do
9337 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9338 –    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9339 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9340 –    break 2
9341 –  fi
9342 – done
9343 – done
9344 –
9345 –  ;;
9346 – esac
9347 – fi
9348 – PS=$ac_cv_path_PS
9349 –
9350 – if test -n "$PS"; then
9351 –  echo "$as_me:$LINENO: result: $PS" >&5
9352 – echo "${ECHO_T}$PS" >&6
9353 – else
9354 –  echo "$as_me:$LINENO: result: no" >&5
9355 – echo "${ECHO_T}no" >&6
9356 – fi
9357 –
9358 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9359 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9360 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
9361 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9362 – else
9363 –
9364 –        if $PS ax -o rss > /dev/null 2>&1; then
9365 –                ac_cv_prog_ps_ax=yes
9366 –        else
9367 –                ac_cv_prog_ps_ax=no
9368 –        fi
9369 –        if $PS -ef -o rss > /dev/null 2>&1; then
9370 –                ac_cv_prog_ps_ef=yes
9371 –        else
9372 –                ac_cv_prog_ps_ef=no
9373 –        fi
9374 –        if test "$ac_cv_prog_ps_ax" = yes; then
9375 –                ac_cv_prog_ps_syntax=BSD
9376 –        else
9377 –                if test "$ac_cv_prog_ps_ef" = yes; then
9378 –                        ac_cv_prog_ps_syntax=POSIX
9379 –                else
9380 –                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9381 – echo "$as_me: error: Could not determine ps syntax" >&2;}
9382 –   { (exit 1); exit 1; }; }
9383 –                fi
9384 –        fi
9385 –
9386 – fi
9387 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9388 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
9389 –
9390 –
9391 – cat >>confdefs.h <<_ACEOF
9392 – #define PSCOMMAND $PS
9393 – _ACEOF
9394 –
9395 –
13017   cat >>confdefs.h <<\_ACEOF
13018   #define OBAPI
13019   _ACEOF
13020  
13021  
13022  
9402 – if test "$ac_cv_prog_ps_syntax" = BSD; then
9403 –  cat >>confdefs.h <<\_ACEOF
9404 – #define PSTYPE_IS_BSD 1
9405 – _ACEOF
13023  
9407 – else
9408 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
9409 –       cat >>confdefs.h <<\_ACEOF
9410 – #define PSTYPE_IS_POSIX 1
9411 – _ACEOF
9412 –
9413 –   else
9414 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9415 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
9416 –   { (exit 1); exit 1; }; }
9417 –   fi
9418 – fi
9419 –
9420 –
13024   # Check whether --with-mpi or --without-mpi was given.
13025   if test "${with_mpi+set}" = set; then
13026    withval="$with_mpi"
# Line 9443 | Line 13046 | 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.cc
13060 < if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
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
# Line 9471 | Line 13080 | echo $ECHO_N "checking whether mpif.h is usable... $EC
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.f90 <<EOF
13095 > cat >conftest.$ac_ext <<EOF
13096   program main
13097     include 'mpif.h'
13098   end
13099   EOF
13100 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
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"
# Line 9500 | Line 13119 | fi
13119   _ACEOF
13120  
13121   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  
13130 +
13131   ac_ext=c
13132   ac_cpp='$CPP $CPPFLAGS'
13133   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 9508 | Line 13135 | ac_save_LDFLAGS=$LDFLAGS
13135   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13136  
13137   ac_save_LDFLAGS=$LDFLAGS
13138 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
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
# Line 9532 | Line 13159 | char MPI_Init ();
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   {
# Line 9549 | Line 13184 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
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"                   || test ! -s conftest.err'
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=$?
# Line 9579 | Line 13215 | fi
13215   fi
13216  
13217   fi
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 -lmpi" >&5
13221 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13222 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; 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    ac_check_lib_save_LIBS=$LIBS
13226 < LIBS="-lmpi  $LIBS"
13226 > LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13227   cat >conftest.$ac_ext <<_ACEOF
13228   /* confdefs.h.  */
13229   _ACEOF
# Line 9601 | Line 13238 | char MPI_Init ();
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   {
# Line 9618 | Line 13263 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
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"                   || test ! -s conftest.err'
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=$?
# Line 9630 | Line 13276 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13276    ac_status=$?
13277    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13278    (exit $ac_status); }; }; then
13279 <  ac_cv_lib_mpi_MPI_Init=yes
13279 >  ac_cv_lib_pmpich_MPI_Init=yes
13280   else
13281    echo "$as_me: failed program was:" >&5
13282   sed 's/^/| /' conftest.$ac_ext >&5
13283  
13284 < ac_cv_lib_mpi_MPI_Init=no
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
13288 > LIBS=$ac_check_lib_save_LIBS
13289 > fi
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
9644 – echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
9645 – echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
9646 – if test $ac_cv_lib_mpi_MPI_Init = yes; then
9647 –  MPI_LIB="-lmpi"
9648 – fi
13295  
13296   fi
9651 – $as_unset ac_cv_lib_mpi_MPI_Init
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
# Line 9656 | Line 13301 | else
13301    echo $ECHO_N "(cached) $ECHO_C" >&6
13302   else
13303    ac_check_lib_save_LIBS=$LIBS
13304 < LIBS="-lmpi "-llam" $LIBS"
13304 > LIBS="-lmpi  $LIBS"
13305   cat >conftest.$ac_ext <<_ACEOF
13306   /* confdefs.h.  */
13307   _ACEOF
# Line 9671 | Line 13316 | char MPI_Init ();
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 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   {
# Line 9688 | Line 13341 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13341    cat conftest.err >&5
13342    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13343    (exit $ac_status); } &&
13344 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13344 >         { ac_try='test -z "$ac_c_werror_flag"
13345 >                         || test ! -s conftest.err'
13346    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13347    (eval $ac_try) 2>&5
13348    ac_status=$?
# Line 9714 | Line 13368 | if test $ac_cv_lib_mpi_MPI_Init = yes; 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 -llam"
13371 >  MPI_LIB="-lmpi"
13372   fi
13373  
13374   fi
13375 < $as_unset ac_cv_lib_mpich_MPI_Init
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 -lmpich" >&5
13378 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13379 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; 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="-lmpich "-lpmpich" $LIBS"
13383 > LIBS="-lmpi -llam $LIBS"
13384   cat >conftest.$ac_ext <<_ACEOF
13385   /* confdefs.h.  */
13386   _ACEOF
# Line 9741 | Line 13395 | char MPI_Init ();
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 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   {
# Line 9758 | Line 13420 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13420    cat conftest.err >&5
13421    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13422    (exit $ac_status); } &&
13423 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13423 >         { ac_try='test -z "$ac_c_werror_flag"
13424 >                         || test ! -s conftest.err'
13425    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13426    (eval $ac_try) 2>&5
13427    ac_status=$?
# Line 9770 | 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_mpich_MPI_Init=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_mpich_MPI_Init=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_mpich_MPI_Init" >&5
13448 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13449 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13450 <  MPI_LIB="-lmpich -lpmpich"
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
9791 –
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
# Line 9812 | Line 13474 | char MPI_Init ();
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   {
# Line 9829 | Line 13499 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13499    cat conftest.err >&5
13500    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13501    (exit $ac_status); } &&
13502 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13502 >         { ac_try='test -z "$ac_c_werror_flag"
13503 >                         || test ! -s conftest.err'
13504    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13505    (eval $ac_try) 2>&5
13506    ac_status=$?
# Line 9887 | Line 13558 | fi
13558  
13559  
13560  
13561 + acx_cgal_found=no
13562  
13563 < USE_CGAL=no
13564 < cgal_makefile=auto
13563 > # Check whether --with-cgalmakefile or --without-cgalmakefile was given.
13564 > if test "${with_cgalmakefile+set}" = set; then
13565 >  withval="$with_cgalmakefile"
13566  
9894 – # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
9895 – if test "${with_cgal_makefile+set}" = set; then
9896 –  withval="$with_cgal_makefile"
9897 –  cgal_makefile="$withval"
13567   fi;
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
13574  
13575 < if test "x$cgal_makefile" != xno; then
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 <  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
9903 <    cgal_makefile="$CGAL_MAKEFILE"
9904 <  fi
13579 >    if test \! -z "$CGAL_MAKEFILE"; then
13580  
13581 <  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13582 < echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13581 >        if test -e "$CGAL_MAKEFILE"; then
13582 >            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
13583  
13584 <  if test -f "$cgal_makefile"; then
13584 > cat > $tname << _ACEOF
13585 > include $CGAL_MAKEFILE
13586  
13587 <    cat >config.tmp.Makefile <<EOF
13588 < include $cgal_makefile
9913 < default:
9914 <        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
9915 <        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
9916 <        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
9917 <        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
9918 <        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
9919 <        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
9920 <        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
9921 <        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
9922 <        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
9923 <        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
9924 <        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
9925 <        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
9926 < EOF
9927 <
9928 <    make -s -f config.tmp.Makefile
9929 <    . config.tmp.cgalvariables
9930 <
9931 <    rm -f config.tmp.Makefile config.tmp.cgalvariables
9932 <
9933 <    if test "x$CGAL_INCLDIR" = "x"; then
9934 <      CGAL_INCLDIR=""
9935 <    fi
9936 <
9937 <    if test "x$CGAL_LIBDIR" = "x"; then
9938 <      CGAL_LIBDIR=""
9939 <    fi
13587 > cppflags:
13588 >        @echo \$(CGAL_CXXFLAGS)
13589  
13590 <    if test "x$CGAL_RLIBDIR" = "x"; then
13591 <      CGAL_RLIBDIR=""
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
13621  
13622 <    if test "x$LEDA_INCLDIR" = "x"; then
13623 <      LEDA_INCLDIR=""
13624 <    fi
13625 <
13626 <    if test "x$LEDA_LIBDIR" = "x"; then
9950 <      LEDA_LIBDIR=""
9951 <    fi
9952 <
9953 <    if test "x$LEDA_RLIBDIR" = "x"; then
9954 <      LEDA_RLIBDIR=""
9955 <    fi
9956 <
9957 <    if test "x$GMP_INCLDIR" = "x"; then
9958 <      GMP_INCLDIR=""
9959 <    fi
9960 <
9961 <    if test "x$GMP_LIBDIR" = "x"; then
9962 <      GMP_LIBDIR=""
9963 <    fi
9964 <
9965 <    if test "x$GMP_RLIBDIR" = "x"; then
9966 <      GMP_RLIBDIR=""
9967 <    fi
9968 <
9969 <    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
9970 < echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
9971 <    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
9972 < echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
9973 <    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
9974 < echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
9975 <    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
9976 < echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
9977 <    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
9978 < echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
9979 <    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
9980 < echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
9981 <    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
9982 < echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
9983 <    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
9984 < echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
9985 <    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
9986 < echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
9987 <
9988 <    ac_ext=cc
9989 < ac_cpp='$CXXCPP $CPPFLAGS'
9990 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9991 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9992 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9993 <
9994 <    save_CXXFLAGS="$CXXFLAGS"
9995 <    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
9996 <    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
9997 <  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
9998 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
9999 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
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_Cartesian_h" >&5
13630 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
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/Cartesian.h usability" >&5
13634 < echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
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
# Line 10012 | Line 13639 | $ac_includes_default
13639   cat >>conftest.$ac_ext <<_ACEOF
13640   /* end confdefs.h.  */
13641   $ac_includes_default
13642 < #include <CGAL/Cartesian.h>
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
# Line 10023 | Line 13650 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13650    cat conftest.err >&5
13651    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13652    (exit $ac_status); } &&
13653 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
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=$?
# Line 10047 | Line 13675 | echo "${ECHO_T}$ac_header_compiler" >&6
13675   echo "${ECHO_T}$ac_header_compiler" >&6
13676  
13677   # Is the header present?
13678 < echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13679 < echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
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/Cartesian.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
# Line 10066 | Line 13694 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
13698 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 10087 | Line 13715 | echo "${ECHO_T}$ac_header_preproc" >&6
13715   echo "${ECHO_T}$ac_header_preproc" >&6
13716  
13717   # So?  What about this header?
13718 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13718 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13719    yes:no: )
13720 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13721 < echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13722 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13723 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
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/Cartesian.h: present but cannot be compiled" >&5
13728 < echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13729 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13730 < echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13731 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13732 < echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13733 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13734 < echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13735 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13736 < echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13737 <    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13738 < echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 10118 | Line 13746 | esac
13746        sed "s/^/$as_me: WARNING:     /" >&2
13747      ;;
13748   esac
13749 < echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13750 < echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13751 < if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
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_Cartesian_h=$ac_header_preproc
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_Cartesian_h" >&5
13757 < echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
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_Cartesian_h = yes; then
13761 <  cgal=yes
13760 > if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
13761 >  cgal_have_header=yes
13762   else
13763 <  cgal=no
13763 >  cgal_have_header=no
13764   fi
13765  
13766  
13767 <    CXXFLAGS="$save_CXXFLAGS"
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="-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  
10141 –    if test "x$cgal" = xyes; then
10142 –      echo "$as_me:$LINENO: checking for CGAL version" >&5
10143 – echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
10144 –      LOCATION=${CGAL_INCLDIR}
10145 –      LOCATION=${LOCATION:-/usr/include}
10146 –      if test -f $LOCATION/CGAL/version.h; then
10147 –        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
10148 –      else
10149 –        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
10150 –      fi
10151 –      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
10152 –        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
10153 – echo "${ECHO_T}($CGAL_VERSION) yes" >&6
10154 –      else
10155 –        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
10156 – echo "${ECHO_T}($CGAL_VERSION) no" >&6
10157 –        cgal=no
10158 –      fi
10159 –    fi
13782  
13783 <    if test "x$cgal" = xyes; then
13784 <      CGAL_LIBS="-lCGAL"
13785 <      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13786 < echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13787 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13788 <        CGAL_USES_LEDA=yes
13789 <        echo "$as_me:$LINENO: result: yes" >&5
13790 < echo "${ECHO_T}yes" >&6
13791 <        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13792 <      else
13793 <        echo "$as_me:$LINENO: result: no" >&5
13794 < echo "${ECHO_T}no" >&6
13795 <        CGAL_USES_LEDA=no
13796 <      fi
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
13791 > int
13792 > main ()
13793 > {
13794 > main ();
13795 >  ;
13796 >  return 0;
13797 > }
13798 > _ACEOF
13799 > rm -f conftest.$ac_objext conftest$ac_exeext
13800 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13801 >  (eval $ac_link) 2>conftest.er1
13802 >  ac_status=$?
13803 >  grep -v '^ *+' conftest.er1 >conftest.err
13804 >  rm -f conftest.er1
13805 >  cat conftest.err >&5
13806 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13807 >  (exit $ac_status); } &&
13808 >         { ac_try='test -z "$ac_c_werror_flag"
13809 >                         || test ! -s conftest.err'
13810 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13811 >  (eval $ac_try) 2>&5
13812 >  ac_status=$?
13813 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13814 >  (exit $ac_status); }; } &&
13815 >         { ac_try='test -s conftest$ac_exeext'
13816 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13817 >  (eval $ac_try) 2>&5
13818 >  ac_status=$?
13819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13820 >  (exit $ac_status); }; }; then
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 <      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13827 < echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13828 <      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13829 <        CGAL_USES_GMP=yes
13830 <        echo "$as_me:$LINENO: result: yes" >&5
13831 < echo "${ECHO_T}yes" >&6
13832 <        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13833 <      else
13834 <        echo "$as_me:$LINENO: result: no" >&5
13835 < echo "${ECHO_T}no" >&6
13836 <        CGAL_USES_GMP=no
13837 <      fi
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_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 <      CGAL_LIBS="$CGAL_LIBS -lm"
13841 <
13842 <      CGAL_CXXFLAGS="-ftemplate-depth-50"
13843 <
13844 <      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13845 < echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13846 <      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13847 < echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
10197 <      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
10198 < echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
10199 <      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
10200 < echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
10201 <      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
10202 < echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
10203 <      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
10204 < echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
10205 <      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
10206 < echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
10207 <    fi
10208 <
10209 <    if test "x$cgal" = xyes; then
10210 <      save_LIBS="$LIBS"
10211 <      LIBS="$LIBS -L$CGAL_LIBDIR"
10212 <      if test "x$CGAL_USES_LEDA" = xyes; then
10213 <        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
10214 <      fi
10215 <      # if test "x$CGAL_USES_GMP" = xyes; then
10216 <      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
10217 <      # fi
10218 <      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
10219 < echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
10220 < save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
10221 < CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
10222 < save_LIBS_CHECK_CXX_LIB="$LIBS"
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="-lCGAL  $LIBS"
13849   cat >conftest.$ac_ext <<_ACEOF
13850   /* confdefs.h.  */
# Line 10227 | Line 13852 | cat >>conftest.$ac_ext <<_ACEOF
13852   cat confdefs.h >>conftest.$ac_ext
13853   cat >>conftest.$ac_ext <<_ACEOF
13854   /* end confdefs.h.  */
13855 < #include <CGAL/Cartesian.h>
13855 >
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 > #endif
13865   int
13866   main ()
13867   {
13868 < ::CGAL::Cartesian<int>::Point_2 P
13868 > main ();
13869    ;
13870    return 0;
13871   }
# Line 10245 | Line 13879 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13879    cat conftest.err >&5
13880    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13881    (exit $ac_status); } &&
13882 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
13882 >         { ac_try='test -z "$ac_c_werror_flag"
13883 >                         || test ! -s conftest.err'
13884    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13885    (eval $ac_try) 2>&5
13886    ac_status=$?
# Line 10257 | 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 <  echo "$as_me:$LINENO: result: yes" >&5
10261 < echo "${ECHO_T}yes" >&6
10262 < cgal=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 < echo "$as_me:$LINENO: result: no" >&5
10268 < echo "${ECHO_T}no" >&6
10269 < cgal=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 < CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13905 < LIBS="$save_LIBS_CHECK_CXX_LIB"
13906 <      LIBS="$save_LIBS"
13907 <    fi
13908 <
13909 <  fi
13910 <  ac_ext=c
13911 < ac_cpp='$CPP $CPPFLAGS'
13912 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13913 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10283 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13904 > LIBS=$ac_check_lib_save_LIBS
13905 > fi
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 +                        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="-lmpfr  $LIBS"
13925 + cat >conftest.$ac_ext <<_ACEOF
13926 + /* confdefs.h.  */
13927 + _ACEOF
13928 + cat confdefs.h >>conftest.$ac_ext
13929 + cat >>conftest.$ac_ext <<_ACEOF
13930 + /* end confdefs.h.  */
13931  
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 + #endif
13941 + int
13942 + main ()
13943 + {
13944 + main ();
13945 +  ;
13946 +  return 0;
13947 + }
13948 + _ACEOF
13949 + rm -f conftest.$ac_objext conftest$ac_exeext
13950 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13951 +  (eval $ac_link) 2>conftest.er1
13952 +  ac_status=$?
13953 +  grep -v '^ *+' conftest.er1 >conftest.err
13954 +  rm -f conftest.er1
13955 +  cat conftest.err >&5
13956 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13957 +  (exit $ac_status); } &&
13958 +         { ac_try='test -z "$ac_c_werror_flag"
13959 +                         || test ! -s conftest.err'
13960 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13961 +  (eval $ac_try) 2>&5
13962 +  ac_status=$?
13963 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13964 +  (exit $ac_status); }; } &&
13965 +         { ac_try='test -s conftest$ac_exeext'
13966 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13967 +  (eval $ac_try) 2>&5
13968 +  ac_status=$?
13969 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13970 +  (exit $ac_status); }; }; then
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_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_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 < if test "x$cgal" = xyes; then
13989 <  USE_CGAL=yes
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="-lgmp  $LIBS"
13995 > cat >conftest.$ac_ext <<_ACEOF
13996 > /* confdefs.h.  */
13997 > _ACEOF
13998 > cat confdefs.h >>conftest.$ac_ext
13999 > cat >>conftest.$ac_ext <<_ACEOF
14000 > /* end confdefs.h.  */
14001  
14002 < cat >>confdefs.h <<\_ACEOF
14003 < #define HAVE_CGAL 1
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 > #endif
14011 > int
14012 > main ()
14013 > {
14014 > main ();
14015 >  ;
14016 >  return 0;
14017 > }
14018   _ACEOF
14019 + rm -f conftest.$ac_objext conftest$ac_exeext
14020 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14021 +  (eval $ac_link) 2>conftest.er1
14022 +  ac_status=$?
14023 +  grep -v '^ *+' conftest.er1 >conftest.err
14024 +  rm -f conftest.er1
14025 +  cat conftest.err >&5
14026 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14027 +  (exit $ac_status); } &&
14028 +         { ac_try='test -z "$ac_c_werror_flag"
14029 +                         || test ! -s conftest.err'
14030 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14031 +  (eval $ac_try) 2>&5
14032 +  ac_status=$?
14033 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14034 +  (exit $ac_status); }; } &&
14035 +         { ac_try='test -s conftest$ac_exeext'
14036 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14037 +  (eval $ac_try) 2>&5
14038 +  ac_status=$?
14039 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14040 +  (exit $ac_status); }; }; then
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_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_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 < cat >>confdefs.h <<_ACEOF
14059 < #define CGAL_VERSION $CGAL_VERSION
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="-lgmpxx  $LIBS"
14065 > cat >conftest.$ac_ext <<_ACEOF
14066 > /* confdefs.h.  */
14067   _ACEOF
14068 + cat confdefs.h >>conftest.$ac_ext
14069 + cat >>conftest.$ac_ext <<_ACEOF
14070 + /* end confdefs.h.  */
14071  
14072 <  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
14073 <    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14074 < echo "$as_me: WARNING: *****************************************************" >&2;}
14075 <    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
14076 < echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
14077 <    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
14078 < echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
14079 <    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14080 < echo "$as_me: WARNING: *****************************************************" >&2;}
14081 <  fi
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 > #endif
14081 > int
14082 > main ()
14083 > {
14084 > main ();
14085 >  ;
14086 >  return 0;
14087 > }
14088 > _ACEOF
14089 > rm -f conftest.$ac_objext conftest$ac_exeext
14090 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14091 >  (eval $ac_link) 2>conftest.er1
14092 >  ac_status=$?
14093 >  grep -v '^ *+' conftest.er1 >conftest.err
14094 >  rm -f conftest.er1
14095 >  cat conftest.err >&5
14096 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14097 >  (exit $ac_status); } &&
14098 >         { ac_try='test -z "$ac_c_werror_flag"
14099 >                         || test ! -s conftest.err'
14100 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14101 >  (eval $ac_try) 2>&5
14102 >  ac_status=$?
14103 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14104 >  (exit $ac_status); }; } &&
14105 >         { ac_try='test -s conftest$ac_exeext'
14106 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14107 >  (eval $ac_try) 2>&5
14108 >  ac_status=$?
14109 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14110 >  (exit $ac_status); }; }; then
14111 >  ac_cv_lib_gmpxx_main=yes
14112   else
14113 <   if test "x$cgal_makefile" != xno; then
14114 <    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
14115 < echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
14116 <  fi
10315 <  CGAL_INCLDIR=
10316 <  CGAL_LIBDIR=
10317 <  CGAL_RLIBDIR=
10318 <  CGAL_DEFINES=
10319 <  CGAL_CXXFLAGS=
10320 <  CGAL_LIBS=
14113 >  echo "$as_me: failed program was:" >&5
14114 > sed 's/^/| /' conftest.$ac_ext >&5
14115 >
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_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
14129  
14130 < CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
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 >  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.  */
14148  
10326 – CGAL_LIB_DIR=${CGAL_LIBDIR}
14149  
14150 < CGAL_RLIB_DIR=${CGAL_RLIBDIR}
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 > main ();
14162 >  ;
14163 >  return 0;
14164 > }
14165 > _ACEOF
14166 > rm -f conftest.$ac_objext conftest$ac_exeext
14167 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14168 >  (eval $ac_link) 2>conftest.er1
14169 >  ac_status=$?
14170 >  grep -v '^ *+' conftest.er1 >conftest.err
14171 >  rm -f conftest.er1
14172 >  cat conftest.err >&5
14173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14174 >  (exit $ac_status); } &&
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
14179 >  ac_status=$?
14180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14181 >  (exit $ac_status); }; } &&
14182 >         { ac_try='test -s conftest$ac_exeext'
14183 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14184 >  (eval $ac_try) 2>&5
14185 >  ac_status=$?
14186 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14187 >  (exit $ac_status); }; }; then
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 + ac_cv_lib_Core_main=no
14194 + fi
14195 + rm -f conftest.err conftest.$ac_objext \
14196 +      conftest$ac_exeext conftest.$ac_ext
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
14206 + fi
14207  
14208  
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 + else
14217 +        echo "$as_me:$LINENO: result: no" >&5
14218 + echo "${ECHO_T}no" >&6
14219  
14220 + fi
14221 +
14222 + if test "$acx_cgal_found" == yes; then
14223 +        USE_CGAL=yes
14224 +
14225 + cat >>confdefs.h <<\_ACEOF
14226 + #define HAVE_CGAL 1
14227 + _ACEOF
14228 +
14229 +
14230 +
14231 +
14232 +
14233 +
14234 + fi
14235 +
14236 +
14237 +
14238   # Check whether --enable-doxygen or --disable-doxygen was given.
14239   if test "${enable_doxygen+set}" = set; then
14240    enableval="$enable_doxygen"
# Line 10474 | Line 14376 | fi
14376  
14377  
14378  
10477 – OBJEXT=".$OBJEXT"
14379  
10479 – OOPSE=oopse
14380  
10481 – if test "x${prefix}" = "xNONE"
10482 – then
10483 –  OOPSE_HOME=${ac_default_prefix}/oopse
10484 – else
10485 –  OOPSE_HOME=${prefix}/oopse
10486 – fi
10487 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
10488 – if test "${enable_oopse_home+set}" = set; then
10489 –  enableval="$enable_oopse_home"
10490 –  OOPSE_HOME="${enableval}"
10491 – fi;
14381  
10493 – case "x$INSTALL" in
10494 –   x/*) ;;
10495 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10496 – esac
14382  
10498 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14383  
10500 – CFLAGS=${CFLAGS-""}
10501 – CXXFLAGS=${CXXFLAGS-""}
10502 – CPPFLAGS=${CPPFLAGS-""}
10503 – FFLAGS=${FFLAGS-""}
10504 – F90FLAGS=${F90FLAGS-""}
10505 – LDFLAGS=${LDFLAGS-""}
10506 – DEBUG=${DEBUG-"-g"}
14384  
10508 – case $debug in
10509 –  1)
10510 –     FFLAGS="$DEBUG $FFLAGS"
10511 –     F90FLAGS="$DEBUG $F90FLAGS"
10512 –     ;;
10513 –  *)
10514 –     ;;
10515 – esac
10516 –
10517 –
10518 –
10519 –
10520 –
10521 –
10522 –
10523 –
10524 –
10525 –
14385  
14386  
14387  
14388  
14389  
14390  
14391 <
10533 <
10534 <          ac_config_headers="$ac_config_headers src/config.h"
10535 <
10536 <                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
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 10898 | 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 10961 | 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 11066 | 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" ;;
# Line 11155 | 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
11158 – s,@PROGNAME@,$PROGNAME,;t t
11159 – 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 11165 | 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
11181 < s,@F90FLAGS@,$F90FLAGS,;t t
11182 < s,@ac_ct_F90@,$ac_ct_F90,;t t
11183 < s,@PREPFLAG@,$PREPFLAG,;t t
11184 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11185 < s,@F90LIBS@,$F90LIBS,;t t
11186 < s,@F90_FUNC@,$F90_FUNC,;t t
11187 < s,@F90_FUNC_@,$F90_FUNC_,;t t
11188 < s,@MOD@,$MOD,;t t
11189 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11190 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11191 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11192 < 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
11195 – s,@CXXCPP@,$CXXCPP,;t t
11196 – s,@LIBOBJS@,$LIBOBJS,;t t
11197 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11198 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11199 – 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
11204 – s,@YACC@,$YACC,;t t
11205 – s,@LEX@,$LEX,;t t
11206 – s,@LEXLIB@,$LEXLIB,;t t
11207 – 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
# Line 11216 | Line 15076 | s,@USE_CGAL@,$USE_CGAL,;t t
15076   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15077   s,@USE_MPI@,$USE_MPI,;t t
15078   s,@USE_CGAL@,$USE_CGAL,;t t
11219 – s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
11220 – s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
11221 – s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
11222 – s,@CGAL_DEFINES@,$CGAL_DEFINES,;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 11233 | 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
11236 – s,@FFLAGS@,$FFLAGS,;t t
15094   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15095   CEOF
15096  
# Line 11401 | Line 15258 | esac
15258    *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
15259    esac
15260  
15261 +  if test x"$ac_file" != x-; then
15262 +    { echo "$as_me:$LINENO: creating $ac_file" >&5
15263 + echo "$as_me: creating $ac_file" >&6;}
15264 +    rm -f "$ac_file"
15265 +  fi
15266    # Let's still pretend it is `configure' which instantiates (i.e., don't
15267    # use $as_me), people would be surprised to read:
15268    #    /* config.h.  Generated by config.status.  */
# Line 11439 | Line 15301 | echo "$as_me: error: cannot find input file: $f" >&2;}
15301           fi;;
15302        esac
15303      done` || { (exit 1); exit 1; }
11442 –
11443 –  if test x"$ac_file" != x-; then
11444 –    { echo "$as_me:$LINENO: creating $ac_file" >&5
11445 – echo "$as_me: creating $ac_file" >&6;}
11446 –    rm -f "$ac_file"
11447 –  fi
15304   _ACEOF
15305   cat >>$CONFIG_STATUS <<_ACEOF
15306    sed "$ac_vpsub
# Line 11476 | Line 15332 | s,@INSTALL@,$ac_INSTALL,;t t
15332    case $ac_file in
15333      make/Makefile ) chmod 0755 scripts/* ;;
15334      src/utils/Makefile ) chmod 0755 scripts/* ;;
15335 <    src/applications/nanoRodBuilder/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

Diff Legend

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