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

Comparing trunk/OOPSE-3.0/configure (file contents):
Revision 1509 by gezelter, Wed Sep 29 17:57:47 2004 UTC vs.
Revision 2547 by gezelter, Wed Jan 11 23:06:08 2006 UTC

# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI SPRNG_LIB_DIR SPRNG_INC_DIR SPRNG_LIB USE_SPRNG MKL_LIBDIR MKL_LIB MKL_INC HAVE_MKL BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 – ac_env_CC_set=${CC+set}
757 – ac_env_CC_value=$CC
758 – ac_cv_env_CC_set=${CC+set}
759 – ac_cv_env_CC_value=$CC
760 – ac_env_CFLAGS_set=${CFLAGS+set}
761 – ac_env_CFLAGS_value=$CFLAGS
762 – ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 – ac_cv_env_CFLAGS_value=$CFLAGS
764 – ac_env_LDFLAGS_set=${LDFLAGS+set}
765 – ac_env_LDFLAGS_value=$LDFLAGS
766 – ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 – ac_cv_env_LDFLAGS_value=$LDFLAGS
768 – ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 – ac_env_CPPFLAGS_value=$CPPFLAGS
770 – ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 – ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_env_F90_set=${F90+set}
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
792 + ac_env_CXXCPP_set=${CXXCPP+set}
793 + ac_env_CXXCPP_value=$CXXCPP
794 + ac_cv_env_CXXCPP_set=${CXXCPP+set}
795 + ac_cv_env_CXXCPP_value=$CXXCPP
796  
797   #
798   # Report the --help message.
# Line 865 | Line 869 | Optional Features:
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
868 –  --enable-debug          Compile OOPSE in debug mode
872    --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873 +  --enable-debug          Compile OOPSE in debug mode
874 +  --enable-doxygen        enable documentation generation with doxygen (auto)
875 +  --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876 +  --enable-html-docs      enable HTML generation with doxygen (yes)
877 +  --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884 +  --with-zlib=DIR root directory path of zlib installation defaults to
885 +                    /usr/local or /usr if not found in /usr/local
886 +  --without-zlib to disable zlib usage completely
887    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
888 <  --with-sprng=<prefix>   compile with SPRNG installed in <prefix>
876 <                          [default=/usr/local]
877 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
888 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
889  
890   Some influential environment variables:
891 <  CC          C compiler command
892 <  CFLAGS      C compiler flags
891 >  CXX         C++ compiler command
892 >  CXXFLAGS    C++ compiler flags
893    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
894                nonstandard directory <lib dir>
895    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
896                headers in a nonstandard directory <include dir>
897 <  CXX         C++ compiler command
898 <  CXXFLAGS    C++ compiler flags
899 <  F90         Fortran 90 compiler command
900 <  F90FLAGS    Fortran 90 compiler flags
897 >  CC          C compiler command
898 >  CFLAGS      C compiler flags
899 >  FC          Fortran compiler command
900 >  FCFLAGS     Fortran compiler flags
901    CPP         C preprocessor
902 +  CXXCPP      C++ preprocessor
903  
904   Use these variables to override the choices made by `configure' or to help
905   it to find libraries and programs with nonstandard names/locations.
# Line 1362 | Line 1374 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1374   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1375   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1376   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1365 –
1366 –
1367 – # This file is part of Autoconf.                       -*- Autoconf -*-
1368 – # Programming languages support.
1369 – # Copyright 2000, 2001
1370 – # Free Software Foundation, Inc.
1371 – #
1372 – # This program is free software; you can redistribute it and/or modify
1373 – # it under the terms of the GNU General Public License as published by
1374 – # the Free Software Foundation; either version 2, or (at your option)
1375 – # any later version.
1376 – #
1377 – # This program is distributed in the hope that it will be useful,
1378 – # but WITHOUT ANY WARRANTY; without even the implied warranty of
1379 – # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1380 – # GNU General Public License for more details.
1381 – #
1382 – # You should have received a copy of the GNU General Public License
1383 – # along with this program; if not, write to the Free Software
1384 – # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1385 – # 02111-1307, USA.
1386 – #
1387 – # As a special exception, the Free Software Foundation gives unlimited
1388 – # permission to copy, distribute and modify the configure scripts that
1389 – # are the output of Autoconf.  You need not follow the terms of the GNU
1390 – # General Public License when using or distributing such scripts, even
1391 – # though portions of the text of Autoconf appear in them.  The GNU
1392 – # General Public License (GPL) does govern all other use of the material
1393 – # that constitutes the Autoconf program.
1394 – #
1395 – # Certain portions of the Autoconf source text are designed to be copied
1396 – # (in certain cases, depending on the input) into the output of
1397 – # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1398 – # source text consists of comments plus executable code that decides which
1399 – # of the data portions to output in any given case.  We call these
1400 – # comments and executable code the "non-data" portions.  Autoconf never
1401 – # copies any of the non-data portions into its output.
1402 – #
1403 – # This special exception to the GPL applies to versions of Autoconf
1404 – # released by the Free Software Foundation.  When you make and
1405 – # distribute a modified version of Autoconf, you may extend this special
1406 – # exception to the GPL to apply to your modified version as well, *unless*
1407 – # your modified version has the potential to copy into its output some
1408 – # of the text that was the non-data portion of the version that you started
1409 – # with.  (In other words, unless your change moves or copies text from
1410 – # the non-data portions to the data portions.)  If your modification has
1411 – # such potential, you must delete any notice of this special exception
1412 – # to the GPL from your modified version.
1413 – #
1414 – # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1415 – # many others).
1416 –
1377  
1418 – # Table of Contents:
1419 – #
1420 – # 1. Language selection
1421 – #    and routines to produce programs in a given language.
1422 – #  a. Fortran 77 (to be moved from aclang.m4)
1423 – #  b. Fortran 90
1424 – #  c. Fortran 95
1425 – #
1426 – # 2. Producing programs in a given language.
1427 – #  a. Fortran 77 (to be moved from aclang.m4)
1428 – #  b. Fortran 90
1429 – #  c. Fortran 95
1430 – #
1431 – # 3. Looking for a compiler
1432 – #    And possibly the associated preprocessor.
1433 – #  a. Fortran 77 (to be moved from aclang.m4)
1434 – #  b. Fortran 90
1435 – #  c. Fortran 95
1436 – #
1437 – # 4. Compilers' characteristics.
1438 – #  a. Fortran 77 (to be moved from aclang.m4)
1439 – #  b. Fortran 90
1440 – #  c. Fortran 95
1378  
1379 < # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1443 < # ---------------------------------------------------------------------------
1444 < #
1445 < # Processing the elements of a list is tedious in shell programming,
1446 < # as lists tend to be implemented as space delimited strings.
1447 < #
1448 < # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1449 < # if ELEMENT is a member of LIST, otherwise it executes
1450 < # ACTION-IF-NOT-FOUND.
1451 < # _AC_LIST_MEMBER_IF
1452 <
1453 <
1454 <
1455 < # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1456 < # -------------------------------------------------
1457 < #
1458 < # Specifying options to the compiler (whether it be the C, C++ or
1459 < # Fortran 77 compiler) that are meant for the linker is compiler
1460 < # dependent.  This macro lets you give options to the compiler that
1461 < # are meant for the linker in a portable, compiler-independent way.
1462 < #
1463 < # This macro take two arguments, a list of linker options that the
1464 < # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1465 < # a shell variable (SHELL-VARIABLE).  The list of linker options are
1466 < # appended to the shell variable in a compiler-dependent way.
1467 < #
1468 < # For example, if the selected language is C, then this:
1469 < #
1470 < #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1471 < #
1472 < # will expand into this if the selected C compiler is gcc:
1473 < #
1474 < #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1475 < #
1476 < # otherwise, it will expand into this:
1477 < #
1478 < #   foo_LDFLAGS"-R /usr/local/lib/foo"
1479 < #
1480 < # You are encouraged to add support for compilers that this macro
1481 < # doesn't currently support.
1482 < # FIXME: Get rid of this macro.
1483 < # _AC_LINKER_OPTION
1484 <
1485 <
1486 <
1487 < ## ----------------------- ##
1488 < ## 1. Language selection.  ##
1489 < ## ----------------------- ##
1490 <
1491 < # ----------------------------- #
1492 < # 1b. The Fortran 90 language.  #
1493 < # ----------------------------- #
1494 <
1495 < # AC_LANG(Fortran 90)
1496 < # -------------------
1497 <
1498 <
1499 <
1500 < # _AC_LANG_ABBREV(Fortran 90)
1501 < # ---------------------------
1502 <
1503 <
1504 <
1505 < # ----------------------------- #
1506 < # 1c. The Fortran 95 language.  #
1507 < # ----------------------------- #
1508 <
1509 < # AC_LANG(Fortran 95)
1510 < # -------------------
1511 <
1512 <
1513 <
1514 < # _AC_LANG_ABBREV(Fortran 95)
1515 < # ---------------------------
1516 <
1517 <
1518 <
1519 < ## ---------------------- ##
1520 < ## 2.Producing programs.  ##
1521 < ## ---------------------- ##
1522 <
1523 < # ------------------------ #
1524 < # 2b. Fortran 90 sources.  #
1525 < # ------------------------ #
1526 <
1527 < # AC_LANG_SOURCE(Fortran 90)(BODY)
1528 < # --------------------------------
1529 <
1530 <
1531 <
1532 < # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1533 < # -----------------------------------------------
1534 <
1535 <
1536 < # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1537 < # --------------------------------------------
1538 <
1539 <
1540 <
1541 < # ------------------------ #
1542 < # 2c. Fortran 95 sources.  #
1543 < # ------------------------ #
1544 <
1545 < # AC_LANG_SOURCE(Fortran 95)(BODY)
1546 < # --------------------------------
1547 <
1548 <
1549 < # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1550 < # -----------------------------------------------
1551 <
1379 >          ac_config_headers="$ac_config_headers src/config.h"
1380  
1553 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1554 – # --------------------------------------------
1381  
1382  
1383  
1558 – ## -------------------------------------------- ##
1559 – ## 3. Looking for Compilers and Preprocessors.  ##
1560 – ## -------------------------------------------- ##
1384  
1562 – # ----------------------------- #
1563 – # 3b. The Fortran 90 compiler.  #
1564 – # ----------------------------- #
1385  
1386  
1567 – # AC_LANG_PREPROC(Fortran 90)
1568 – # ---------------------------
1569 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1387  
1388  
1389  
1573 – # AC_LANG_COMPILER(Fortran 90)
1574 – # ----------------------------
1575 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1576 – # AC_REQUIRE'able.
1390  
1391  
1392  
1580 – # AC_PROG_F90([COMPILERS...])
1581 – # ---------------------------
1582 – # COMPILERS is a space separated list of Fortran 90 compilers to search
1583 – # for.
1584 – #
1585 – # Compilers are ordered by
1586 – #  1. F90, F95
1587 – #  2. Good/tested native compilers, bad/untested native compilers
1588 – #
1589 – # pgf90 is the Portland Group F90 compilers.
1590 – # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1591 – # lf95 is the Lahey-Fujitsu compiler.
1592 – # epcf90 is the "Edinburgh Portable Compiler" F90.
1593 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1594 – # AC_PROG_F90
1393  
1394  
1597 – # ----------------------------- #
1598 – # 3c. The Fortran 95 compiler.  #
1599 – # ----------------------------- #
1395  
1396  
1602 – # AC_LANG_PREPROC(Fortran 95)
1603 – # ---------------------------
1604 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1397  
1398  
1399  
1608 – # AC_LANG_COMPILER(Fortran 95)
1609 – # ----------------------------
1610 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1611 – # AC_REQUIRE'able.
1400  
1401  
1402  
1615 – # AC_PROG_F95([COMPILERS...])
1616 – # ---------------------------
1617 – # COMPILERS is a space separated list of Fortran 95 compilers to search
1618 – # for.
1619 – #
1620 – # Compilers are ordered by
1621 – #  1. Good/tested native compilers, bad/untested native compilers
1622 – #
1623 – # xlf95 is the IBM (AIX) F95 compiler.
1624 – # lf95 is the Lahey-Fujitsu compiler.
1625 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1626 – # AC_PROG_F95
1403  
1404  
1629 – ## ------------------------------- ##
1630 – ## 4. Compilers' characteristics.  ##
1631 – ## ------------------------------- ##
1405  
1406  
1634 – # ---------------------------------------- #
1635 – # 4b. Fortan 90 compiler characteristics.  #
1636 – # ---------------------------------------- #
1407  
1408  
1639 – # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1640 – # -------------------------------------------------
1641 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1642 – # (which default value, $ac_cv_prog_f90_v, is computed by
1643 – # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1644 – # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1645 – # so that any link flags that are echoed by the compiler appear as
1646 – # space-separated items.
1647 – # _AC_PROG_F90_V_OUTPUT
1409  
1410  
1650 – # _AC_PROG_F90_V
1651 – # --------------
1652 – #
1653 – # Determine the flag that causes the Fortran 90 compiler to print
1654 – # information of library and object files (normally -v)
1655 – # Needed for AC_F90_LIBRARY_FLAGS
1656 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1657 – # _AC_PROG_F90_V
1411  
1412  
1660 – # AC_F90_LIBRARY_LDFLAGS
1661 – # ----------------------
1662 – #
1663 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1664 – # intrinsic and run-time libraries that are required to successfully
1665 – # link a Fortran 90 program or shared library.  The output variable
1666 – # F90LIBS is set to these flags.
1667 – #
1668 – # This macro is intended to be used in those situations when it is
1669 – # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1670 – # program or shared library.
1671 – #
1672 – # For example, if object files from a C++ and Fortran 90 compiler must
1673 – # be linked together, then the C++ compiler/linker must be used for
1674 – # linking (since special C++-ish things need to happen at link time
1675 – # like calling global constructors, instantiating templates, enabling
1676 – # exception support, etc.).
1677 – #
1678 – # However, the Fortran 90 intrinsic and run-time libraries must be
1679 – # linked in as well, but the C++ compiler/linker doesn't know how to
1680 – # add these Fortran 90 libraries.  Hence, the macro
1681 – # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1682 – # libraries.
1683 – #
1684 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1685 – # AC_F90_LIBRARY_LDFLAGS
1413  
1414  
1688 – # _AC_F90_NAME_MANGLING
1689 – # ---------------------
1690 – # Test for the name mangling scheme used by the Fortran 90 compiler.
1691 – #
1692 – # Sets ac_cv_f90_mangling. The value contains three fields, separated
1693 – # by commas:
1694 – #
1695 – # lower case / upper case:
1696 – #    case translation of the Fortan 90 symbols
1697 – # underscore / no underscore:
1698 – #    whether the compiler appends "_" to symbol names
1699 – # extra underscore / no extra underscore:
1700 – #    whether the compiler appends an extra "_" to symbol names already
1701 – #    containing at least one underscore
1702 – #
1703 – # _AC_F90_NAME_MANGLING
1415  
1705 – # The replacement is empty.
1416  
1417  
1418  
1709 – # AC_F90_WRAPPERS
1710 – # ---------------
1711 – # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1712 – # properly mangle the names of C identifiers, and C identifiers with
1713 – # underscores, respectively, so that they match the name mangling
1714 – # scheme used by the Fortran 90 compiler.
1715 – # AC_F90_WRAPPERS
1419  
1420  
1718 – # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1719 – # ------------------------------------
1720 – # For a Fortran subroutine of given NAME, define a shell variable
1721 – # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1722 – # argument is not supplied, it defaults to NAME.
1723 – # AC_F90_FUNC
1421  
1725 –
1726 – # ---------------------------------------- #
1727 – # 4c. Fortan 95 compiler characteristics.  #
1728 – # ---------------------------------------- #
1729 –
1730 –
1731 – # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1732 – # -------------------------------------------------
1733 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1734 – # (which default value, $ac_cv_prog_f95_v, is computed by
1735 – # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1736 – # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1737 – # so that any link flags that are echoed by the compiler appear as
1738 – # space-separated items.
1739 – # _AC_PROG_F95_V_OUTPUT
1740 –
1741 –
1742 – # _AC_PROG_F95_V
1743 – # --------------
1422   #
1745 – # Determine the flag that causes the Fortran 95 compiler to print
1746 – # information of library and object files (normally -v)
1747 – # Needed for AC_F95_LIBRARY_FLAGS
1748 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1749 – # _AC_PROG_F95_V
1750 –
1751 –
1752 – # AC_F95_LIBRARY_LDFLAGS
1753 – # ----------------------
1423   #
1755 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1756 – # intrinsic and run-time libraries that are required to successfully
1757 – # link a Fortran 95 program or shared library.  The output variable
1758 – # F95LIBS is set to these flags.
1424   #
1760 – # This macro is intended to be used in those situations when it is
1761 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1762 – # program or shared library.
1763 – #
1764 – # For example, if object files from a C++ and Fortran 95 compiler must
1765 – # be linked together, then the C++ compiler/linker must be used for
1766 – # linking (since special C++-ish things need to happen at link time
1767 – # like calling global constructors, instantiating templates, enabling
1768 – # exception support, etc.).
1769 – #
1770 – # However, the Fortran 95 intrinsic and run-time libraries must be
1771 – # linked in as well, but the C++ compiler/linker doesn't know how to
1772 – # add these Fortran 95 libraries.  Hence, the macro
1773 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1774 – # libraries.
1775 – #
1776 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1777 – # AC_F95_LIBRARY_LDFLAGS
1425  
1426  
1427 < # _AC_F95_NAME_MANGLING
1428 < # ---------------------
1782 < # Test for the name mangling scheme used by the Fortran 95 compiler.
1427 > # AC_F90_MODULE_NAMES
1428 > # -------------------
1429   #
1430 < # Sets ac_cv_f95_mangling. The value contains three fields, separated
1785 < # by commas:
1430 > # Figure out how the Fortran 90 compiler constructs module file names
1431   #
1432 < # lower case / upper case:
1788 < #    case translation of the Fortan 95 symbols
1789 < # underscore / no underscore:
1790 < #    whether the compiler appends "_" to symbol names
1791 < # extra underscore / no extra underscore:
1792 < #    whether the compiler appends an extra "_" to symbol names already
1793 < #    containing at least one underscore
1794 < #
1795 < # _AC_F95_NAME_MANGLING
1432 > # AC_F90_MODULE_NAMES
1433  
1797 – # The replacement is empty.
1434  
1435  
1436  
1801 – # AC_F95_WRAPPERS
1802 – # ---------------
1803 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1804 – # properly mangle the names of C identifiers, and C identifiers with
1805 – # underscores, respectively, so that they match the name mangling
1806 – # scheme used by the Fortran 95 compiler.
1807 – # AC_F95_WRAPPERS
1437  
1438  
1810 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1811 – # ------------------------------------
1812 – # For a Fortran subroutine of given NAME, define a shell variable
1813 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1814 – # argument is not supplied, it defaults to NAME.
1815 – # AC_F95_FUNC
1439  
1440  
1441  
# Line 1843 | Line 1466 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1466  
1467  
1468  
1846 –
1847 –
1848 –
1849 –
1850 –
1851 –
1852 –
1853 –
1854 –
1855 –
1856 –
1857 –
1858 –
1859 –
1860 –
1861 –
1862 –
1863 –
1864 –
1865 –
1866 –
1867 –
1868 –
1869 –
1870 –
1871 – # set program name
1872 – PROGNAME="oopse"
1873 –
1874 –
1875 – # there are two ways to do debugging.  One with the --enable-debug flag
1876 – # and one using the DEBUG environment variable
1877 –
1878 – debug=0
1879 – # Check whether --enable-debug or --disable-debug was given.
1880 – if test "${enable_debug+set}" = set; then
1881 –  enableval="$enable_debug"
1882 –  debug=1
1883 – fi;
1884 – if test "${DEBUG}"; then
1885 –
1886 – cat >>confdefs.h <<\_ACEOF
1887 – #define debug 1
1888 – _ACEOF
1889 –
1890 –  msg="$msg, debug mode"
1891 – fi
1892 –
1893 –
1469   # who am i
1470   # Make sure we can run config.sub.
1471   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1949 | Line 1524 | ac_ext=c
1524  
1525  
1526  
1527 < ac_ext=c
1528 < ac_cpp='$CPP $CPPFLAGS'
1529 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1530 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1531 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1527 > # set program name
1528 > PROGNAME="oopse"
1529 >
1530 >
1531 >
1532 >
1533 > OBJEXT=".$OBJEXT"
1534 >
1535 > OOPSE=oopse
1536 >
1537 > if test "x${prefix}" = "xNONE"
1538 > then
1539 >  OOPSE_HOME=${ac_default_prefix}/oopse
1540 > else
1541 >  OOPSE_HOME=${prefix}/oopse
1542 > fi
1543 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1544 > if test "${enable_oopse_home+set}" = set; then
1545 >  enableval="$enable_oopse_home"
1546 >  OOPSE_HOME="${enableval}"
1547 > fi;
1548 >
1549 > # there are two ways to do debugging.  One with the --enable-debug flag
1550 > # 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
1555 >  enableval="$enable_debug"
1556 >  debug=1
1557 > fi;
1558 > if test "${DEBUG}"; then
1559 >
1560 > cat >>confdefs.h <<\_ACEOF
1561 > #define debug 1
1562 > _ACEOF
1563 >
1564 >  msg="$msg, debug mode"
1565 > fi
1566 >
1567 >
1568 > # Checks for programs.
1569 > ac_ext=cc
1570 > ac_cpp='$CXXCPP $CPPFLAGS'
1571 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1572 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1573 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1574   if test -n "$ac_tool_prefix"; then
1575 <  for ac_prog in icc xlc gcc cc
1575 >  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
1576    do
1577      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1578   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1579   echo "$as_me:$LINENO: checking for $ac_word" >&5
1580   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1581 < if test "${ac_cv_prog_CC+set}" = set; then
1581 > if test "${ac_cv_prog_CXX+set}" = set; then
1582    echo $ECHO_N "(cached) $ECHO_C" >&6
1583   else
1584 <  if test -n "$CC"; then
1585 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1584 >  if test -n "$CXX"; then
1585 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1586   else
1587   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1588   for as_dir in $PATH
# Line 1974 | Line 1591 | do
1591    test -z "$as_dir" && as_dir=.
1592    for ac_exec_ext in '' $ac_executable_extensions; do
1593    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1594 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1594 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1595      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1596      break 2
1597    fi
# Line 1983 | Line 1600 | CC=$ac_cv_prog_CC
1600  
1601   fi
1602   fi
1603 < CC=$ac_cv_prog_CC
1604 < if test -n "$CC"; then
1605 <  echo "$as_me:$LINENO: result: $CC" >&5
1606 < echo "${ECHO_T}$CC" >&6
1603 > CXX=$ac_cv_prog_CXX
1604 > if test -n "$CXX"; then
1605 >  echo "$as_me:$LINENO: result: $CXX" >&5
1606 > echo "${ECHO_T}$CXX" >&6
1607   else
1608    echo "$as_me:$LINENO: result: no" >&5
1609   echo "${ECHO_T}no" >&6
1610   fi
1611  
1612 <    test -n "$CC" && break
1612 >    test -n "$CXX" && break
1613    done
1614   fi
1615 < if test -z "$CC"; then
1616 <  ac_ct_CC=$CC
1617 <  for ac_prog in icc xlc gcc cc
1615 > if test -z "$CXX"; then
1616 >  ac_ct_CXX=$CXX
1617 >  for ac_prog in $CCC pathCC icpc icc xlc++ xlC CC g++ c++
1618   do
1619    # Extract the first word of "$ac_prog", so it can be a program name with args.
1620   set dummy $ac_prog; ac_word=$2
1621   echo "$as_me:$LINENO: checking for $ac_word" >&5
1622   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1623 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1623 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1624    echo $ECHO_N "(cached) $ECHO_C" >&6
1625   else
1626 <  if test -n "$ac_ct_CC"; then
1627 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1626 >  if test -n "$ac_ct_CXX"; then
1627 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1628   else
1629   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1630   for as_dir in $PATH
# Line 2016 | Line 1633 | do
1633    test -z "$as_dir" && as_dir=.
1634    for ac_exec_ext in '' $ac_executable_extensions; do
1635    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1636 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1636 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1637      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1638      break 2
1639    fi
# Line 2025 | Line 1642 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1642  
1643   fi
1644   fi
1645 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1646 < if test -n "$ac_ct_CC"; then
1647 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1648 < echo "${ECHO_T}$ac_ct_CC" >&6
1645 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1646 > if test -n "$ac_ct_CXX"; then
1647 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1648 > echo "${ECHO_T}$ac_ct_CXX" >&6
1649   else
1650    echo "$as_me:$LINENO: result: no" >&5
1651   echo "${ECHO_T}no" >&6
1652   fi
1653  
1654 <  test -n "$ac_ct_CC" && break
1654 >  test -n "$ac_ct_CXX" && break
1655   done
1656 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1657  
1658 <  CC=$ac_ct_CC
1658 >  CXX=$ac_ct_CXX
1659   fi
1660  
1661  
2044 – test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2045 – See \`config.log' for more details." >&5
2046 – echo "$as_me: error: no acceptable C compiler found in \$PATH
2047 – See \`config.log' for more details." >&2;}
2048 –   { (exit 1); exit 1; }; }
2049 –
1662   # Provide some information about the compiler.
1663   echo "$as_me:$LINENO:" \
1664 <     "checking for C compiler version" >&5
1664 >     "checking for C++ compiler version" >&5
1665   ac_compiler=`set X $ac_compile; echo $2`
1666   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1667    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2087 | Line 1699 | echo "$as_me:$LINENO: checking for C compiler default
1699   # Try to create an executable without -o first, disregard a.out.
1700   # It will help us diagnose broken compilers, and finding out an intuition
1701   # of exeext.
1702 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1703 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1702 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1703 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1704   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1705   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1706    (eval $ac_link_default) 2>&5
# Line 2131 | Line 1743 | sed 's/^/| /' conftest.$ac_ext >&5
1743    echo "$as_me: failed program was:" >&5
1744   sed 's/^/| /' conftest.$ac_ext >&5
1745  
1746 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1746 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1747   See \`config.log' for more details." >&5
1748 < echo "$as_me: error: C compiler cannot create executables
1748 > echo "$as_me: error: C++ compiler cannot create executables
1749   See \`config.log' for more details." >&2;}
1750     { (exit 77); exit 77; }; }
1751   fi
# Line 2144 | Line 1756 | echo "$as_me:$LINENO: checking whether the C compiler
1756  
1757   # Check the compiler produces executables we can run.  If not, either
1758   # the compiler is broken, or we cross compile.
1759 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1760 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1759 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1760 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1761   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1762   # If not cross compiling, check that we can run a simple program.
1763   if test "$cross_compiling" != yes; then
# Line 2160 | Line 1772 | if test "$cross_compiling" != yes; then
1772      if test "$cross_compiling" = maybe; then
1773          cross_compiling=yes
1774      else
1775 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1775 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1776   If you meant to cross compile, use \`--host'.
1777   See \`config.log' for more details." >&5
1778 < echo "$as_me: error: cannot run C compiled programs.
1778 > echo "$as_me: error: cannot run C++ compiled programs.
1779   If you meant to cross compile, use \`--host'.
1780   See \`config.log' for more details." >&2;}
1781     { (exit 1); exit 1; }; }
# Line 2268 | Line 1880 | echo "$as_me:$LINENO: checking whether we are using th
1880   echo "${ECHO_T}$ac_cv_objext" >&6
1881   OBJEXT=$ac_cv_objext
1882   ac_objext=$OBJEXT
1883 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1884 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1885 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1883 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1884 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1885 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1886    echo $ECHO_N "(cached) $ECHO_C" >&6
1887   else
1888    cat >conftest.$ac_ext <<_ACEOF
# Line 2300 | Line 1912 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1912    cat conftest.err >&5
1913    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1914    (exit $ac_status); } &&
1915 <         { ac_try='test -z "$ac_c_werror_flag"
1915 >         { ac_try='test -z "$ac_cxx_werror_flag"
1916                           || test ! -s conftest.err'
1917    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1918    (eval $ac_try) 2>&5
# Line 2321 | Line 1933 | ac_cv_c_compiler_gnu=$ac_compiler_gnu
1933   ac_compiler_gnu=no
1934   fi
1935   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1936 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
1936 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1937  
1938   fi
1939 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1940 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1941 < GCC=`test $ac_compiler_gnu = yes && echo yes`
1942 < ac_test_CFLAGS=${CFLAGS+set}
1943 < ac_save_CFLAGS=$CFLAGS
1944 < CFLAGS="-g"
1945 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1946 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1947 < if test "${ac_cv_prog_cc_g+set}" = set; then
1939 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1940 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1941 > GXX=`test $ac_compiler_gnu = yes && echo yes`
1942 > ac_test_CXXFLAGS=${CXXFLAGS+set}
1943 > ac_save_CXXFLAGS=$CXXFLAGS
1944 > CXXFLAGS="-g"
1945 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1946 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1947 > if test "${ac_cv_prog_cxx_g+set}" = set; then
1948    echo $ECHO_N "(cached) $ECHO_C" >&6
1949   else
1950    cat >conftest.$ac_ext <<_ACEOF
# Line 2359 | Line 1971 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1971    cat conftest.err >&5
1972    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973    (exit $ac_status); } &&
1974 <         { ac_try='test -z "$ac_c_werror_flag"
1974 >         { ac_try='test -z "$ac_cxx_werror_flag"
1975                           || test ! -s conftest.err'
1976    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1977    (eval $ac_try) 2>&5
# Line 2372 | Line 1984 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1984    ac_status=$?
1985    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986    (exit $ac_status); }; }; then
1987 <  ac_cv_prog_cc_g=yes
1987 >  ac_cv_prog_cxx_g=yes
1988   else
1989    echo "$as_me: failed program was:" >&5
1990   sed 's/^/| /' conftest.$ac_ext >&5
1991  
1992 < ac_cv_prog_cc_g=no
1992 > ac_cv_prog_cxx_g=no
1993   fi
1994   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995   fi
1996 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
1997 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
1998 < if test "$ac_test_CFLAGS" = set; then
1999 <  CFLAGS=$ac_save_CFLAGS
2000 < elif test $ac_cv_prog_cc_g = yes; then
2001 <  if test "$GCC" = yes; then
2002 <    CFLAGS="-g -O2"
1996 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
1997 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
1998 > if test "$ac_test_CXXFLAGS" = set; then
1999 >  CXXFLAGS=$ac_save_CXXFLAGS
2000 > elif test $ac_cv_prog_cxx_g = yes; then
2001 >  if test "$GXX" = yes; then
2002 >    CXXFLAGS="-g -O2"
2003    else
2004 <    CFLAGS="-g"
2004 >    CXXFLAGS="-g"
2005    fi
2006   else
2007 <  if test "$GCC" = yes; then
2008 <    CFLAGS="-O2"
2007 >  if test "$GXX" = yes; then
2008 >    CXXFLAGS="-O2"
2009    else
2010 <    CFLAGS=
2010 >    CXXFLAGS=
2011    fi
2012   fi
2013 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2402 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2403 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2404 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2405 < else
2406 <  ac_cv_prog_cc_stdc=no
2407 < ac_save_CC=$CC
2408 < cat >conftest.$ac_ext <<_ACEOF
2409 < /* confdefs.h.  */
2410 < _ACEOF
2411 < cat confdefs.h >>conftest.$ac_ext
2412 < cat >>conftest.$ac_ext <<_ACEOF
2413 < /* end confdefs.h.  */
2414 < #include <stdarg.h>
2415 < #include <stdio.h>
2416 < #include <sys/types.h>
2417 < #include <sys/stat.h>
2418 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2419 < struct buf { int x; };
2420 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2421 < static char *e (p, i)
2422 <     char **p;
2423 <     int i;
2424 < {
2425 <  return p[i];
2426 < }
2427 < static char *f (char * (*g) (char **, int), char **p, ...)
2428 < {
2429 <  char *s;
2430 <  va_list v;
2431 <  va_start (v,p);
2432 <  s = g (p, va_arg (v,int));
2433 <  va_end (v);
2434 <  return s;
2435 < }
2436 <
2437 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2438 <   function prototypes and stuff, but not '\xHH' hex character constants.
2439 <   These don't provoke an error unfortunately, instead are silently treated
2440 <   as 'x'.  The following induces an error, until -std1 is added to get
2441 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2442 <   array size at least.  It's necessary to write '\x00'==0 to get something
2443 <   that's true only with -std1.  */
2444 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2445 <
2446 < int test (int i, double x);
2447 < struct s1 {int (*f) (int a);};
2448 < struct s2 {int (*f) (double a);};
2449 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2450 < int argc;
2451 < char **argv;
2452 < int
2453 < main ()
2454 < {
2455 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2456 <  ;
2457 <  return 0;
2458 < }
2459 < _ACEOF
2460 < # Don't try gcc -ansi; that turns off useful extensions and
2461 < # breaks some systems' header files.
2462 < # AIX                   -qlanglvl=ansi
2463 < # Ultrix and OSF/1      -std1
2464 < # HP-UX 10.20 and later -Ae
2465 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2466 < # SVR4                  -Xc -D__EXTENSIONS__
2467 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2468 < do
2469 <  CC="$ac_save_CC $ac_arg"
2470 <  rm -f conftest.$ac_objext
2471 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2472 <  (eval $ac_compile) 2>conftest.er1
2473 <  ac_status=$?
2474 <  grep -v '^ *+' conftest.er1 >conftest.err
2475 <  rm -f conftest.er1
2476 <  cat conftest.err >&5
2477 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2478 <  (exit $ac_status); } &&
2479 <         { ac_try='test -z "$ac_c_werror_flag"
2480 <                         || test ! -s conftest.err'
2481 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2482 <  (eval $ac_try) 2>&5
2483 <  ac_status=$?
2484 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2485 <  (exit $ac_status); }; } &&
2486 <         { ac_try='test -s conftest.$ac_objext'
2487 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2488 <  (eval $ac_try) 2>&5
2489 <  ac_status=$?
2490 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2491 <  (exit $ac_status); }; }; then
2492 <  ac_cv_prog_cc_stdc=$ac_arg
2493 < break
2494 < else
2495 <  echo "$as_me: failed program was:" >&5
2496 < sed 's/^/| /' conftest.$ac_ext >&5
2497 <
2498 < fi
2499 < rm -f conftest.err conftest.$ac_objext
2500 < done
2501 < rm -f conftest.$ac_ext conftest.$ac_objext
2502 < CC=$ac_save_CC
2503 <
2504 < fi
2505 <
2506 < case "x$ac_cv_prog_cc_stdc" in
2507 <  x|xno)
2508 <    echo "$as_me:$LINENO: result: none needed" >&5
2509 < echo "${ECHO_T}none needed" >&6 ;;
2510 <  *)
2511 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2512 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2513 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2514 < esac
2515 <
2516 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2517 < # in C++ we need to declare it.  In case someone uses the same compiler
2518 < # for both compiling C and C++ we need to have the C++ compiler decide
2519 < # the declaration of exit, since it's the most demanding environment.
2520 < cat >conftest.$ac_ext <<_ACEOF
2521 < #ifndef __cplusplus
2522 <  choke me
2523 < #endif
2524 < _ACEOF
2525 < rm -f conftest.$ac_objext
2526 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2527 <  (eval $ac_compile) 2>conftest.er1
2528 <  ac_status=$?
2529 <  grep -v '^ *+' conftest.er1 >conftest.err
2530 <  rm -f conftest.er1
2531 <  cat conftest.err >&5
2532 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2533 <  (exit $ac_status); } &&
2534 <         { ac_try='test -z "$ac_c_werror_flag"
2535 <                         || test ! -s conftest.err'
2536 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2537 <  (eval $ac_try) 2>&5
2538 <  ac_status=$?
2539 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2540 <  (exit $ac_status); }; } &&
2541 <         { ac_try='test -s conftest.$ac_objext'
2542 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2543 <  (eval $ac_try) 2>&5
2544 <  ac_status=$?
2545 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2546 <  (exit $ac_status); }; }; then
2547 <  for ac_declaration in \
2013 > for ac_declaration in \
2014     '' \
2015     'extern "C" void std::exit (int) throw (); using std::exit;' \
2016     'extern "C" void std::exit (int); using std::exit;' \
# Line 2577 | Line 2043 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2043    cat conftest.err >&5
2044    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045    (exit $ac_status); } &&
2046 <         { ac_try='test -z "$ac_c_werror_flag"
2046 >         { ac_try='test -z "$ac_cxx_werror_flag"
2047                           || test ! -s conftest.err'
2048    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2049    (eval $ac_try) 2>&5
# Line 2622 | Line 2088 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2088    cat conftest.err >&5
2089    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2090    (exit $ac_status); } &&
2091 <         { ac_try='test -z "$ac_c_werror_flag"
2091 >         { ac_try='test -z "$ac_cxx_werror_flag"
2092                           || test ! -s conftest.err'
2093    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2094    (eval $ac_try) 2>&5
# Line 2650 | Line 2116 | else
2116    echo '#endif'             >>confdefs.h
2117   fi
2118  
2653 – else
2654 –  echo "$as_me: failed program was:" >&5
2655 – sed 's/^/| /' conftest.$ac_ext >&5
2656 –
2657 – fi
2658 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2119   ac_ext=c
2120   ac_cpp='$CPP $CPPFLAGS'
2121   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2122   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2123   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2124  
2125 <
2126 < ac_ext=cc
2127 < ac_cpp='$CXXCPP $CPPFLAGS'
2128 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2129 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2670 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2125 > ac_ext=c
2126 > ac_cpp='$CPP $CPPFLAGS'
2127 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2128 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2129 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2130   if test -n "$ac_tool_prefix"; then
2131 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2131 >  for ac_prog in pathcc icc xlc gcc cc
2132    do
2133      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2134   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2135   echo "$as_me:$LINENO: checking for $ac_word" >&5
2136   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2137 < if test "${ac_cv_prog_CXX+set}" = set; then
2137 > if test "${ac_cv_prog_CC+set}" = set; then
2138    echo $ECHO_N "(cached) $ECHO_C" >&6
2139   else
2140 <  if test -n "$CXX"; then
2141 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2140 >  if test -n "$CC"; then
2141 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2142   else
2143   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2144   for as_dir in $PATH
# Line 2688 | Line 2147 | do
2147    test -z "$as_dir" && as_dir=.
2148    for ac_exec_ext in '' $ac_executable_extensions; do
2149    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2150 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2150 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2151      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2152      break 2
2153    fi
# Line 2697 | Line 2156 | CXX=$ac_cv_prog_CXX
2156  
2157   fi
2158   fi
2159 < CXX=$ac_cv_prog_CXX
2160 < if test -n "$CXX"; then
2161 <  echo "$as_me:$LINENO: result: $CXX" >&5
2162 < echo "${ECHO_T}$CXX" >&6
2159 > CC=$ac_cv_prog_CC
2160 > if test -n "$CC"; then
2161 >  echo "$as_me:$LINENO: result: $CC" >&5
2162 > echo "${ECHO_T}$CC" >&6
2163   else
2164    echo "$as_me:$LINENO: result: no" >&5
2165   echo "${ECHO_T}no" >&6
2166   fi
2167  
2168 <    test -n "$CXX" && break
2168 >    test -n "$CC" && break
2169    done
2170   fi
2171 < if test -z "$CXX"; then
2172 <  ac_ct_CXX=$CXX
2173 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2171 > if test -z "$CC"; then
2172 >  ac_ct_CC=$CC
2173 >  for ac_prog in pathcc icc xlc gcc cc
2174   do
2175    # Extract the first word of "$ac_prog", so it can be a program name with args.
2176   set dummy $ac_prog; ac_word=$2
2177   echo "$as_me:$LINENO: checking for $ac_word" >&5
2178   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2179 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2179 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2180    echo $ECHO_N "(cached) $ECHO_C" >&6
2181   else
2182 <  if test -n "$ac_ct_CXX"; then
2183 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2182 >  if test -n "$ac_ct_CC"; then
2183 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2184   else
2185   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2186   for as_dir in $PATH
# Line 2730 | Line 2189 | do
2189    test -z "$as_dir" && as_dir=.
2190    for ac_exec_ext in '' $ac_executable_extensions; do
2191    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2192 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2192 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2193      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2194      break 2
2195    fi
# Line 2739 | Line 2198 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2198  
2199   fi
2200   fi
2201 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2202 < if test -n "$ac_ct_CXX"; then
2203 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2204 < echo "${ECHO_T}$ac_ct_CXX" >&6
2201 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2202 > if test -n "$ac_ct_CC"; then
2203 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2204 > echo "${ECHO_T}$ac_ct_CC" >&6
2205   else
2206    echo "$as_me:$LINENO: result: no" >&5
2207   echo "${ECHO_T}no" >&6
2208   fi
2209  
2210 <  test -n "$ac_ct_CXX" && break
2210 >  test -n "$ac_ct_CC" && break
2211   done
2753 – test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2212  
2213 <  CXX=$ac_ct_CXX
2213 >  CC=$ac_ct_CC
2214   fi
2215  
2216  
2217 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2218 + See \`config.log' for more details." >&5
2219 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2220 + See \`config.log' for more details." >&2;}
2221 +   { (exit 1); exit 1; }; }
2222 +
2223   # Provide some information about the compiler.
2224   echo "$as_me:$LINENO:" \
2225 <     "checking for C++ compiler version" >&5
2225 >     "checking for C compiler version" >&5
2226   ac_compiler=`set X $ac_compile; echo $2`
2227   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2228    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2776 | Line 2240 | echo "$as_me:$LINENO: checking whether we are using th
2240    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2241    (exit $ac_status); }
2242  
2243 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2244 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2245 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2243 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2244 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2245 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2246    echo $ECHO_N "(cached) $ECHO_C" >&6
2247   else
2248    cat >conftest.$ac_ext <<_ACEOF
# Line 2808 | Line 2272 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2272    cat conftest.err >&5
2273    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2274    (exit $ac_status); } &&
2275 <         { ac_try='test -z "$ac_cxx_werror_flag"
2275 >         { ac_try='test -z "$ac_c_werror_flag"
2276                           || test ! -s conftest.err'
2277    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2278    (eval $ac_try) 2>&5
# Line 2829 | Line 2293 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2293   ac_compiler_gnu=no
2294   fi
2295   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2296 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2296 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2297  
2298   fi
2299 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2300 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2301 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2302 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2303 < ac_save_CXXFLAGS=$CXXFLAGS
2304 < CXXFLAGS="-g"
2305 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2306 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2307 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2299 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2300 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2301 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2302 > ac_test_CFLAGS=${CFLAGS+set}
2303 > ac_save_CFLAGS=$CFLAGS
2304 > CFLAGS="-g"
2305 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2306 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2307 > if test "${ac_cv_prog_cc_g+set}" = set; then
2308    echo $ECHO_N "(cached) $ECHO_C" >&6
2309   else
2310    cat >conftest.$ac_ext <<_ACEOF
# Line 2867 | Line 2331 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2331    cat conftest.err >&5
2332    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2333    (exit $ac_status); } &&
2334 <         { ac_try='test -z "$ac_cxx_werror_flag"
2334 >         { ac_try='test -z "$ac_c_werror_flag"
2335                           || test ! -s conftest.err'
2336    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2337    (eval $ac_try) 2>&5
# Line 2880 | Line 2344 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2344    ac_status=$?
2345    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2346    (exit $ac_status); }; }; then
2347 <  ac_cv_prog_cxx_g=yes
2347 >  ac_cv_prog_cc_g=yes
2348   else
2349    echo "$as_me: failed program was:" >&5
2350   sed 's/^/| /' conftest.$ac_ext >&5
2351  
2352 < ac_cv_prog_cxx_g=no
2352 > ac_cv_prog_cc_g=no
2353   fi
2354   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2355   fi
2356 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2357 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2358 < if test "$ac_test_CXXFLAGS" = set; then
2359 <  CXXFLAGS=$ac_save_CXXFLAGS
2360 < elif test $ac_cv_prog_cxx_g = yes; then
2361 <  if test "$GXX" = yes; then
2362 <    CXXFLAGS="-g -O2"
2356 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2357 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2358 > if test "$ac_test_CFLAGS" = set; then
2359 >  CFLAGS=$ac_save_CFLAGS
2360 > elif test $ac_cv_prog_cc_g = yes; then
2361 >  if test "$GCC" = yes; then
2362 >    CFLAGS="-g -O2"
2363    else
2364 <    CXXFLAGS="-g"
2364 >    CFLAGS="-g"
2365    fi
2366   else
2367 <  if test "$GXX" = yes; then
2368 <    CXXFLAGS="-O2"
2367 >  if test "$GCC" = yes; then
2368 >    CFLAGS="-O2"
2369    else
2370 <    CXXFLAGS=
2370 >    CFLAGS=
2371    fi
2372   fi
2373 < for ac_declaration in \
2374 <   '' \
2375 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2376 <   'extern "C" void std::exit (int); using std::exit;' \
2377 <   'extern "C" void exit (int) throw ();' \
2378 <   'extern "C" void exit (int);' \
2379 <   'void exit (int);'
2380 < do
2917 <  cat >conftest.$ac_ext <<_ACEOF
2373 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2374 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2375 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2376 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2377 > else
2378 >  ac_cv_prog_cc_stdc=no
2379 > ac_save_CC=$CC
2380 > cat >conftest.$ac_ext <<_ACEOF
2381   /* confdefs.h.  */
2382   _ACEOF
2383   cat confdefs.h >>conftest.$ac_ext
2384   cat >>conftest.$ac_ext <<_ACEOF
2385   /* end confdefs.h.  */
2386 < $ac_declaration
2387 < #include <stdlib.h>
2388 < int
2389 < main ()
2386 > #include <stdarg.h>
2387 > #include <stdio.h>
2388 > #include <sys/types.h>
2389 > #include <sys/stat.h>
2390 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2391 > struct buf { int x; };
2392 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2393 > static char *e (p, i)
2394 >     char **p;
2395 >     int i;
2396   {
2397 < exit (42);
2929 <  ;
2930 <  return 0;
2397 >  return p[i];
2398   }
2399 < _ACEOF
2400 < rm -f conftest.$ac_objext
2399 > static char *f (char * (*g) (char **, int), char **p, ...)
2400 > {
2401 >  char *s;
2402 >  va_list v;
2403 >  va_start (v,p);
2404 >  s = g (p, va_arg (v,int));
2405 >  va_end (v);
2406 >  return s;
2407 > }
2408 >
2409 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2410 >   function prototypes and stuff, but not '\xHH' hex character constants.
2411 >   These don't provoke an error unfortunately, instead are silently treated
2412 >   as 'x'.  The following induces an error, until -std1 is added to get
2413 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2414 >   array size at least.  It's necessary to write '\x00'==0 to get something
2415 >   that's true only with -std1.  */
2416 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2417 >
2418 > int test (int i, double x);
2419 > struct s1 {int (*f) (int a);};
2420 > struct s2 {int (*f) (double a);};
2421 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2422 > int argc;
2423 > char **argv;
2424 > int
2425 > main ()
2426 > {
2427 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2428 >  ;
2429 >  return 0;
2430 > }
2431 > _ACEOF
2432 > # Don't try gcc -ansi; that turns off useful extensions and
2433 > # breaks some systems' header files.
2434 > # AIX                   -qlanglvl=ansi
2435 > # Ultrix and OSF/1      -std1
2436 > # HP-UX 10.20 and later -Ae
2437 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2438 > # SVR4                  -Xc -D__EXTENSIONS__
2439 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2440 > do
2441 >  CC="$ac_save_CC $ac_arg"
2442 >  rm -f conftest.$ac_objext
2443   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2444    (eval $ac_compile) 2>conftest.er1
2445    ac_status=$?
# Line 2939 | Line 2448 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2448    cat conftest.err >&5
2449    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2450    (exit $ac_status); } &&
2451 <         { ac_try='test -z "$ac_cxx_werror_flag"
2451 >         { ac_try='test -z "$ac_c_werror_flag"
2452                           || test ! -s conftest.err'
2453    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2454    (eval $ac_try) 2>&5
# Line 2952 | Line 2461 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2461    ac_status=$?
2462    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2463    (exit $ac_status); }; }; then
2464 +  ac_cv_prog_cc_stdc=$ac_arg
2465 + break
2466 + else
2467 +  echo "$as_me: failed program was:" >&5
2468 + sed 's/^/| /' conftest.$ac_ext >&5
2469 +
2470 + fi
2471 + rm -f conftest.err conftest.$ac_objext
2472 + done
2473 + rm -f conftest.$ac_ext conftest.$ac_objext
2474 + CC=$ac_save_CC
2475 +
2476 + fi
2477 +
2478 + case "x$ac_cv_prog_cc_stdc" in
2479 +  x|xno)
2480 +    echo "$as_me:$LINENO: result: none needed" >&5
2481 + echo "${ECHO_T}none needed" >&6 ;;
2482 +  *)
2483 +    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2484 + echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2485 +    CC="$CC $ac_cv_prog_cc_stdc" ;;
2486 + esac
2487 +
2488 + # Some people use a C++ compiler to compile C.  Since we use `exit',
2489 + # in C++ we need to declare it.  In case someone uses the same compiler
2490 + # for both compiling C and C++ we need to have the C++ compiler decide
2491 + # the declaration of exit, since it's the most demanding environment.
2492 + cat >conftest.$ac_ext <<_ACEOF
2493 + #ifndef __cplusplus
2494 +  choke me
2495 + #endif
2496 + _ACEOF
2497 + rm -f conftest.$ac_objext
2498 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2499 +  (eval $ac_compile) 2>conftest.er1
2500 +  ac_status=$?
2501 +  grep -v '^ *+' conftest.er1 >conftest.err
2502 +  rm -f conftest.er1
2503 +  cat conftest.err >&5
2504 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2505 +  (exit $ac_status); } &&
2506 +         { ac_try='test -z "$ac_c_werror_flag"
2507 +                         || test ! -s conftest.err'
2508 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2509 +  (eval $ac_try) 2>&5
2510 +  ac_status=$?
2511 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2512 +  (exit $ac_status); }; } &&
2513 +         { ac_try='test -s conftest.$ac_objext'
2514 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2515 +  (eval $ac_try) 2>&5
2516 +  ac_status=$?
2517 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2518 +  (exit $ac_status); }; }; then
2519 +  for ac_declaration in \
2520 +   '' \
2521 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2522 +   'extern "C" void std::exit (int); using std::exit;' \
2523 +   'extern "C" void exit (int) throw ();' \
2524 +   'extern "C" void exit (int);' \
2525 +   'void exit (int);'
2526 + do
2527 +  cat >conftest.$ac_ext <<_ACEOF
2528 + /* confdefs.h.  */
2529 + _ACEOF
2530 + cat confdefs.h >>conftest.$ac_ext
2531 + cat >>conftest.$ac_ext <<_ACEOF
2532 + /* end confdefs.h.  */
2533 + $ac_declaration
2534 + #include <stdlib.h>
2535 + int
2536 + main ()
2537 + {
2538 + exit (42);
2539 +  ;
2540 +  return 0;
2541 + }
2542 + _ACEOF
2543 + rm -f conftest.$ac_objext
2544 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2545 +  (eval $ac_compile) 2>conftest.er1
2546 +  ac_status=$?
2547 +  grep -v '^ *+' conftest.er1 >conftest.err
2548 +  rm -f conftest.er1
2549 +  cat conftest.err >&5
2550 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2551 +  (exit $ac_status); } &&
2552 +         { ac_try='test -z "$ac_c_werror_flag"
2553 +                         || test ! -s conftest.err'
2554 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2555 +  (eval $ac_try) 2>&5
2556 +  ac_status=$?
2557 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2558 +  (exit $ac_status); }; } &&
2559 +         { ac_try='test -s conftest.$ac_objext'
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); }; }; then
2565    :
2566   else
2567    echo "$as_me: failed program was:" >&5
# Line 2984 | Line 2594 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2594    cat conftest.err >&5
2595    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2596    (exit $ac_status); } &&
2597 <         { ac_try='test -z "$ac_cxx_werror_flag"
2597 >         { ac_try='test -z "$ac_c_werror_flag"
2598                           || test ! -s conftest.err'
2599    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2600    (eval $ac_try) 2>&5
# Line 3012 | Line 2622 | ac_ext=c
2622    echo '#endif'             >>confdefs.h
2623   fi
2624  
2625 + else
2626 +  echo "$as_me: failed program was:" >&5
2627 + sed 's/^/| /' conftest.$ac_ext >&5
2628 +
2629 + fi
2630 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2631   ac_ext=c
2632   ac_cpp='$CPP $CPPFLAGS'
2633   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2634   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2635   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2636  
2637 <
2638 < OOPSE_TEMPLATE_FLAGS=""
2639 < if test $ac_cv_cxx_compiler_gnu = no; then
2640 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3025 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3026 <  echo 'void f(){}' > conftest.cc
3027 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3028 <    echo "$as_me:$LINENO: result: yes" >&5
3029 < echo "${ECHO_T}yes" >&6
3030 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3031 <  else
3032 <    echo "$as_me:$LINENO: result: no" >&5
3033 < echo "${ECHO_T}no" >&6
3034 <  fi
3035 <  rm -f conftest*
3036 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3037 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3038 <  echo 'void f(){}' > conftest.cc
3039 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3040 <    echo "$as_me:$LINENO: result: yes" >&5
3041 < echo "${ECHO_T}yes" >&6
3042 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3043 <  else
3044 <    echo "$as_me:$LINENO: result: no" >&5
3045 < echo "${ECHO_T}no" >&6
3046 <  fi
3047 <  rm -f conftest*
3048 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3049 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3050 <  echo 'void f(){}' > conftest.cc
3051 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3052 <    echo "$as_me:$LINENO: result: yes" >&5
3053 < echo "${ECHO_T}yes" >&6
3054 <    OOPSE_TEMPLATE_FLAGS="-pto"
3055 <  else
3056 <    echo "$as_me:$LINENO: result: no" >&5
3057 < echo "${ECHO_T}no" >&6
3058 <  fi
3059 <  rm -f conftest*
3060 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3061 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3062 <  echo 'void f(){}' > conftest.cc
3063 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3064 <    echo "$as_me:$LINENO: result: yes" >&5
3065 < echo "${ECHO_T}yes" >&6
3066 <
3067 <
3068 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3069 <  else
3070 <    echo "$as_me:$LINENO: result: no" >&5
3071 < echo "${ECHO_T}no" >&6
3072 <  fi
3073 < fi
3074 <
3075 <
3076 <
3077 <
3078 < ac_ext=f90
3079 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3080 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3081 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2637 > ac_ext=${FC_SRCEXT-f}
2638 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2639 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2640 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2641   if test -n "$ac_tool_prefix"; then
2642 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2642 >  for ac_prog in pathf95 ifort ifc xlf95 pgf95 lf95 epcf90 xlf90 pgf90 fort f95 f90 g95 f77
2643    do
2644      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2645   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2646   echo "$as_me:$LINENO: checking for $ac_word" >&5
2647   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2648 < if test "${ac_cv_prog_F90+set}" = set; then
2648 > if test "${ac_cv_prog_FC+set}" = set; then
2649    echo $ECHO_N "(cached) $ECHO_C" >&6
2650   else
2651 <  if test -n "$F90"; then
2652 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2651 >  if test -n "$FC"; then
2652 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2653   else
2654   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2655   for as_dir in $PATH
# Line 3099 | Line 2658 | do
2658    test -z "$as_dir" && as_dir=.
2659    for ac_exec_ext in '' $ac_executable_extensions; do
2660    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2661 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2661 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2662      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2663      break 2
2664    fi
# Line 3108 | Line 2667 | F90=$ac_cv_prog_F90
2667  
2668   fi
2669   fi
2670 < F90=$ac_cv_prog_F90
2671 < if test -n "$F90"; then
2672 <  echo "$as_me:$LINENO: result: $F90" >&5
2673 < echo "${ECHO_T}$F90" >&6
2670 > FC=$ac_cv_prog_FC
2671 > if test -n "$FC"; then
2672 >  echo "$as_me:$LINENO: result: $FC" >&5
2673 > echo "${ECHO_T}$FC" >&6
2674   else
2675    echo "$as_me:$LINENO: result: no" >&5
2676   echo "${ECHO_T}no" >&6
2677   fi
2678  
2679 <    test -n "$F90" && break
2679 >    test -n "$FC" && break
2680    done
2681   fi
2682 < if test -z "$F90"; then
2683 <  ac_ct_F90=$F90
2684 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2682 > if test -z "$FC"; then
2683 >  ac_ct_FC=$FC
2684 >  for ac_prog in pathf95 ifort ifc xlf95 pgf95 lf95 epcf90 xlf90 pgf90 fort f95 f90 g95 f77
2685   do
2686    # Extract the first word of "$ac_prog", so it can be a program name with args.
2687   set dummy $ac_prog; ac_word=$2
2688   echo "$as_me:$LINENO: checking for $ac_word" >&5
2689   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2690 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2690 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2691    echo $ECHO_N "(cached) $ECHO_C" >&6
2692   else
2693 <  if test -n "$ac_ct_F90"; then
2694 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2693 >  if test -n "$ac_ct_FC"; then
2694 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2695   else
2696   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2697   for as_dir in $PATH
# Line 3141 | Line 2700 | do
2700    test -z "$as_dir" && as_dir=.
2701    for ac_exec_ext in '' $ac_executable_extensions; do
2702    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2703 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2703 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2704      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2705      break 2
2706    fi
# Line 3150 | Line 2709 | ac_ct_F90=$ac_cv_prog_ac_ct_F90
2709  
2710   fi
2711   fi
2712 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2713 < if test -n "$ac_ct_F90"; then
2714 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2715 < echo "${ECHO_T}$ac_ct_F90" >&6
2712 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2713 > if test -n "$ac_ct_FC"; then
2714 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2715 > echo "${ECHO_T}$ac_ct_FC" >&6
2716   else
2717    echo "$as_me:$LINENO: result: no" >&5
2718   echo "${ECHO_T}no" >&6
2719   fi
2720  
2721 <  test -n "$ac_ct_F90" && break
2721 >  test -n "$ac_ct_FC" && break
2722   done
2723  
2724 <  F90=$ac_ct_F90
2724 >  FC=$ac_ct_FC
2725   fi
2726  
2727  
2728 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2729 < # input file.
2728 > # Provide some information about the compiler.
2729 > echo "$as_me:2729:" \
2730 >     "checking for Fortran compiler version" >&5
2731 > ac_compiler=`set X $ac_compile; echo $2`
2732 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2733 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2734 >  ac_status=$?
2735 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2736 >  (exit $ac_status); }
2737 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2738 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2739 >  ac_status=$?
2740 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2741 >  (exit $ac_status); }
2742 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2743 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2744 >  ac_status=$?
2745 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2746 >  (exit $ac_status); }
2747 > rm -f a.out
2748 >
2749 > # If we don't use `.F' as extension, the preprocessor is not run on the
2750 > # input file.  (Note that this only needs to work for GNU compilers.)
2751   ac_save_ext=$ac_ext
2752 < ac_ext=F90
2753 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2754 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2755 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2752 > ac_ext=F
2753 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2754 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2755 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2756    echo $ECHO_N "(cached) $ECHO_C" >&6
2757   else
2758    cat >conftest.$ac_ext <<_ACEOF
2759 <
3180 < program main
3181 <
2759 >      program main
2760   #ifndef __GNUC__
2761         choke me
2762   #endif
2763  
2764 < end program main
3187 <
2764 >      end
2765   _ACEOF
2766   rm -f conftest.$ac_objext
2767   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3195 | Line 2772 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2772    cat conftest.err >&5
2773    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2774    (exit $ac_status); } &&
2775 <         { ac_try='test -z "$ac_f90_werror_flag"
2775 >         { ac_try='test -z "$ac_fc_werror_flag"
2776                           || test ! -s conftest.err'
2777    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2778    (eval $ac_try) 2>&5
# Line 3216 | Line 2793 | ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2793   ac_compiler_gnu=no
2794   fi
2795   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2796 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2796 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2797  
2798   fi
2799 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2800 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2799 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2800 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2801   ac_ext=$ac_save_ext
2802 < G95=`test $ac_compiler_gnu = yes && echo yes`
2803 < ac_ext=c
2804 < ac_cpp='$CPP $CPPFLAGS'
2805 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2806 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2807 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2802 > ac_test_FFLAGS=${FCFLAGS+set}
2803 > ac_save_FFLAGS=$FCFLAGS
2804 > FCFLAGS=
2805 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2806 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2807 > if test "${ac_cv_prog_fc_g+set}" = set; then
2808 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2809 > else
2810 >  FCFLAGS=-g
2811 > cat >conftest.$ac_ext <<_ACEOF
2812 >      program main
2813  
2814 <
3233 <
3234 <
3235 <
3236 < # Try to determine native compiler flags that allow us to use F90 suffix
3237 < # for preprocessed f90 source.
3238 <
3239 < if test "$ac_test_PREPFLAG" != "set"; then
3240 <  PREPFLAG=""
3241 <  case "${host_cpu}-${host_os}" in
3242 <
3243 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3244 <                    PREPFLAG="-fpp1 "
3245 <                fi;;
3246 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3247 <                    PREPFLAG="-qsuffix=cpp=F90 "
3248 <                fi;;
3249 <  *darwin*)
3250 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3251 <                PREPFLAG="-qsuffix=cpp=F90 "
3252 <        fi;;
3253 <  esac
3254 <
3255 <  if test -z "$PREPFLAG"; then
3256 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3257 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3258 <        PREPFLAG=""
3259 <  fi
3260 <
3261 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3262 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3263 <
3264 <
3265 <  ac_ext=f90
3266 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3267 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3268 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3269 <
3270 <  ac_save_ext=$ac_ext
3271 <  ac_ext=F90
3272 <  ac_save_F90FLAGS=$F90FLAGS
3273 <
3274 <  if test "$PREPFLAG"; then
3275 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3276 < fi
3277 <
3278 <    cat >conftest.$ac_ext <<_ACEOF
3279 <
3280 <
3281 < program main
3282 <
3283 <  integer :: i
3284 <  i = 1
3285 <
3286 <
3287 < end program main
3288 <
2814 >      end
2815   _ACEOF
2816   rm -f conftest.$ac_objext
2817   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3296 | Line 2822 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2822    cat conftest.err >&5
2823    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2824    (exit $ac_status); } &&
2825 <         { ac_try='test -z "$ac_f90_werror_flag"
2825 >         { ac_try='test -z "$ac_fc_werror_flag"
2826                           || test ! -s conftest.err'
2827    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2828    (eval $ac_try) 2>&5
# Line 3309 | Line 2835 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2835    ac_status=$?
2836    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2837    (exit $ac_status); }; }; then
2838 <  prepflagworks=1
2838 >  ac_cv_prog_fc_g=yes
2839   else
2840    echo "$as_me: failed program was:" >&5
2841   sed 's/^/| /' conftest.$ac_ext >&5
2842  
2843 < prepflagworks=0
2843 > ac_cv_prog_fc_g=no
2844   fi
2845   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2846  
2847 <  F90FLAGS=$ac_save_F90FLAGS
2848 <  ac_ext=$ac_save_ext
2849 <  ac_ext=c
2847 > fi
2848 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2849 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2850 > if test "$ac_test_FFLAGS" = set; then
2851 >  FCFLAGS=$ac_save_FFLAGS
2852 > elif test $ac_cv_prog_fc_g = yes; then
2853 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2854 >    FCFLAGS="-g -O2"
2855 >  else
2856 >    FCFLAGS="-g"
2857 >  fi
2858 > else
2859 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2860 >    FCFLAGS="-O2"
2861 >  else
2862 >    FCFLAGS=
2863 >  fi
2864 > fi
2865 >
2866 > ac_ext=c
2867   ac_cpp='$CPP $CPPFLAGS'
2868   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2869   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2870   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2871  
2872 + ac_ext=c
2873 + ac_cpp='$CPP $CPPFLAGS'
2874 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2875 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2876 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2877 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2878 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2879 + # On Suns, sometimes $CPP names a directory.
2880 + if test -n "$CPP" && test -d "$CPP"; then
2881 +  CPP=
2882 + fi
2883 + if test -z "$CPP"; then
2884 +  if test "${ac_cv_prog_CPP+set}" = set; then
2885 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2886 + else
2887 +      # Double quotes because CPP needs to be expanded
2888 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2889 +    do
2890 +      ac_preproc_ok=false
2891 + for ac_c_preproc_warn_flag in '' yes
2892 + do
2893 +  # Use a header file that comes with gcc, so configuring glibc
2894 +  # with a fresh cross-compiler works.
2895 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2896 +  # <limits.h> exists even on freestanding compilers.
2897 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2898 +  # not just through cpp. "Syntax error" is here to catch this case.
2899 +  cat >conftest.$ac_ext <<_ACEOF
2900 + /* confdefs.h.  */
2901 + _ACEOF
2902 + cat confdefs.h >>conftest.$ac_ext
2903 + cat >>conftest.$ac_ext <<_ACEOF
2904 + /* end confdefs.h.  */
2905 + #ifdef __STDC__
2906 + # include <limits.h>
2907 + #else
2908 + # include <assert.h>
2909 + #endif
2910 +                     Syntax error
2911 + _ACEOF
2912 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2913 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2914 +  ac_status=$?
2915 +  grep -v '^ *+' conftest.er1 >conftest.err
2916 +  rm -f conftest.er1
2917 +  cat conftest.err >&5
2918 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2919 +  (exit $ac_status); } >/dev/null; then
2920 +  if test -s conftest.err; then
2921 +    ac_cpp_err=$ac_c_preproc_warn_flag
2922 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2923 +  else
2924 +    ac_cpp_err=
2925 +  fi
2926 + else
2927 +  ac_cpp_err=yes
2928 + fi
2929 + if test -z "$ac_cpp_err"; then
2930 +  :
2931 + else
2932 +  echo "$as_me: failed program was:" >&5
2933 + sed 's/^/| /' conftest.$ac_ext >&5
2934  
2935 <  if test "$prepflagworks" = 1; then
2936 <    echo "$as_me:$LINENO: result: yes" >&5
2937 < echo "${ECHO_T}yes" >&6
2935 >  # Broken: fails on valid input.
2936 > continue
2937 > fi
2938 > rm -f conftest.err conftest.$ac_ext
2939  
2940 +  # OK, works on sane cases.  Now check whether non-existent headers
2941 +  # can be detected and how.
2942 +  cat >conftest.$ac_ext <<_ACEOF
2943 + /* confdefs.h.  */
2944 + _ACEOF
2945 + cat confdefs.h >>conftest.$ac_ext
2946 + cat >>conftest.$ac_ext <<_ACEOF
2947 + /* end confdefs.h.  */
2948 + #include <ac_nonexistent.h>
2949 + _ACEOF
2950 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2951 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2952 +  ac_status=$?
2953 +  grep -v '^ *+' conftest.er1 >conftest.err
2954 +  rm -f conftest.er1
2955 +  cat conftest.err >&5
2956 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2957 +  (exit $ac_status); } >/dev/null; then
2958 +  if test -s conftest.err; then
2959 +    ac_cpp_err=$ac_c_preproc_warn_flag
2960 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2961    else
2962 <    echo "$as_me:$LINENO: result: no" >&5
3336 < echo "${ECHO_T}no" >&6
3337 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3338 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3339 <   { (exit 1); exit 1; }; }
2962 >    ac_cpp_err=
2963    fi
2964 + else
2965 +  ac_cpp_err=yes
2966   fi
2967 + if test -z "$ac_cpp_err"; then
2968 +  # Broken: success on invalid input.
2969 + continue
2970 + else
2971 +  echo "$as_me: failed program was:" >&5
2972 + sed 's/^/| /' conftest.$ac_ext >&5
2973  
2974 +  # Passes both tests.
2975 + ac_preproc_ok=:
2976 + break
2977 + fi
2978 + rm -f conftest.err conftest.$ac_ext
2979  
2980 + done
2981 + # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2982 + rm -f conftest.err conftest.$ac_ext
2983 + if $ac_preproc_ok; then
2984 +  break
2985 + fi
2986  
2987 +    done
2988 +    ac_cv_prog_CPP=$CPP
2989  
3346 –
3347 – # Try to determine native compiler flags that allow us to use F90 suffix
3348 – # for preprocessed f90 source with -D type defines
3349 –
3350 – if test "$ac_test_PREPDEFFLAG" != "set"; then
3351 –  PREPDEFFLAG=""
3352 –  case "${host_cpu}-${host_os}" in
3353 –
3354 –  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3355 –                    PREPDEFFLAG=" "
3356 –                fi;;
3357 –  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3358 –                    PREPDEFFLAG="-WF,"
3359 –                fi;;
3360 –  *darwin*)
3361 –        if test "$F90" = f90 -o "$F90" = xlf90; then
3362 –                PREPDEFFLAG="-WF,"
3363 –        fi;;
3364 –  esac
3365 –
3366 –  if test -z "$PREPDEFFLAG"; then
3367 –        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3368 – echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3369 –        PREPDEFFLAG=" "
3370 –  fi
3371 –
3372 –  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3373 – echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3374 –
3375 –
3376 –  ac_ext=f90
3377 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3378 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3379 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3380 –
3381 –  ac_save_ext=$ac_ext
3382 –  ac_ext=F90
3383 –  ac_save_F90FLAGS=$F90FLAGS
3384 –
3385 –  if test "$PREPDEFFLAG"; then
3386 –  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
2990   fi
2991 <
2992 <    cat >conftest.$ac_ext <<_ACEOF
2993 <
2994 <
2995 < program main
2996 <
2997 <  integer :: i
2998 < #ifdef TEST
2999 <  i = 1
2991 >  CPP=$ac_cv_prog_CPP
2992 > else
2993 >  ac_cv_prog_CPP=$CPP
2994 > fi
2995 > echo "$as_me:$LINENO: result: $CPP" >&5
2996 > echo "${ECHO_T}$CPP" >&6
2997 > ac_preproc_ok=false
2998 > for ac_c_preproc_warn_flag in '' yes
2999 > do
3000 >  # Use a header file that comes with gcc, so configuring glibc
3001 >  # with a fresh cross-compiler works.
3002 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3003 >  # <limits.h> exists even on freestanding compilers.
3004 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3005 >  # not just through cpp. "Syntax error" is here to catch this case.
3006 >  cat >conftest.$ac_ext <<_ACEOF
3007 > /* confdefs.h.  */
3008 > _ACEOF
3009 > cat confdefs.h >>conftest.$ac_ext
3010 > cat >>conftest.$ac_ext <<_ACEOF
3011 > /* end confdefs.h.  */
3012 > #ifdef __STDC__
3013 > # include <limits.h>
3014   #else
3015 <  choke me
3015 > # include <assert.h>
3016   #endif
3017 +                     Syntax error
3018 + _ACEOF
3019 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3020 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3021 +  ac_status=$?
3022 +  grep -v '^ *+' conftest.er1 >conftest.err
3023 +  rm -f conftest.er1
3024 +  cat conftest.err >&5
3025 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3026 +  (exit $ac_status); } >/dev/null; then
3027 +  if test -s conftest.err; then
3028 +    ac_cpp_err=$ac_c_preproc_warn_flag
3029 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3030 +  else
3031 +    ac_cpp_err=
3032 +  fi
3033 + else
3034 +  ac_cpp_err=yes
3035 + fi
3036 + if test -z "$ac_cpp_err"; then
3037 +  :
3038 + else
3039 +  echo "$as_me: failed program was:" >&5
3040 + sed 's/^/| /' conftest.$ac_ext >&5
3041  
3042 +  # Broken: fails on valid input.
3043 + continue
3044 + fi
3045 + rm -f conftest.err conftest.$ac_ext
3046  
3047 < end program main
3048 <
3047 >  # OK, works on sane cases.  Now check whether non-existent headers
3048 >  # can be detected and how.
3049 >  cat >conftest.$ac_ext <<_ACEOF
3050 > /* confdefs.h.  */
3051   _ACEOF
3052 < rm -f conftest.$ac_objext
3053 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3054 <  (eval $ac_compile) 2>conftest.er1
3052 > cat confdefs.h >>conftest.$ac_ext
3053 > cat >>conftest.$ac_ext <<_ACEOF
3054 > /* end confdefs.h.  */
3055 > #include <ac_nonexistent.h>
3056 > _ACEOF
3057 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3058 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3059    ac_status=$?
3060    grep -v '^ *+' conftest.er1 >conftest.err
3061    rm -f conftest.er1
3062    cat conftest.err >&5
3063    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3064 <  (exit $ac_status); } &&
3065 <         { ac_try='test -z "$ac_f90_werror_flag"
3066 <                         || test ! -s conftest.err'
3067 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3068 <  (eval $ac_try) 2>&5
3069 <  ac_status=$?
3070 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3420 <  (exit $ac_status); }; } &&
3421 <         { ac_try='test -s conftest.$ac_objext'
3422 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3423 <  (eval $ac_try) 2>&5
3424 <  ac_status=$?
3425 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3426 <  (exit $ac_status); }; }; then
3427 <  prepdefflagworks=1
3064 >  (exit $ac_status); } >/dev/null; then
3065 >  if test -s conftest.err; then
3066 >    ac_cpp_err=$ac_c_preproc_warn_flag
3067 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3068 >  else
3069 >    ac_cpp_err=
3070 >  fi
3071   else
3072 +  ac_cpp_err=yes
3073 + fi
3074 + if test -z "$ac_cpp_err"; then
3075 +  # Broken: success on invalid input.
3076 + continue
3077 + else
3078    echo "$as_me: failed program was:" >&5
3079   sed 's/^/| /' conftest.$ac_ext >&5
3080  
3081 < prepdefflagworks=0
3081 >  # Passes both tests.
3082 > ac_preproc_ok=:
3083 > break
3084   fi
3085 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3085 > rm -f conftest.err conftest.$ac_ext
3086  
3087 <  F90FLAGS=$ac_save_F90FLAGS
3088 <  ac_ext=$ac_save_ext
3089 <  ac_ext=c
3087 > done
3088 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3089 > rm -f conftest.err conftest.$ac_ext
3090 > if $ac_preproc_ok; then
3091 >  :
3092 > else
3093 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3094 > See \`config.log' for more details." >&5
3095 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3096 > See \`config.log' for more details." >&2;}
3097 >   { (exit 1); exit 1; }; }
3098 > fi
3099 >
3100 > ac_ext=c
3101   ac_cpp='$CPP $CPPFLAGS'
3102   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3103   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3104   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3105  
3106 + echo "$as_me:$LINENO: checking for egrep" >&5
3107 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3108 + if test "${ac_cv_prog_egrep+set}" = set; then
3109 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3110 + else
3111 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3112 +    then ac_cv_prog_egrep='grep -E'
3113 +    else ac_cv_prog_egrep='egrep'
3114 +    fi
3115 + fi
3116 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3117 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3118 + EGREP=$ac_cv_prog_egrep
3119  
3120  
3121 <  if test "$prepdefflagworks" = 1; then
3122 <    echo "$as_me:$LINENO: result: yes" >&5
3121 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3122 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3123 > LN_S=$as_ln_s
3124 > if test "$LN_S" = "ln -s"; then
3125 >  echo "$as_me:$LINENO: result: yes" >&5
3126   echo "${ECHO_T}yes" >&6
3127 + else
3128 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3129 + echo "${ECHO_T}no, using $LN_S" >&6
3130 + fi
3131  
3132 <  else
3133 <    echo "$as_me:$LINENO: result: no" >&5
3132 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3133 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3134 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3135 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3136 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3137 > else
3138 >  cat >conftest.make <<\_ACEOF
3139 > all:
3140 >        @echo 'ac_maketemp="$(MAKE)"'
3141 > _ACEOF
3142 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3143 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3144 > if test -n "$ac_maketemp"; then
3145 >  eval ac_cv_prog_make_${ac_make}_set=yes
3146 > else
3147 >  eval ac_cv_prog_make_${ac_make}_set=no
3148 > fi
3149 > rm -f conftest.make
3150 > fi
3151 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3152 >  echo "$as_me:$LINENO: result: yes" >&5
3153 > echo "${ECHO_T}yes" >&6
3154 >  SET_MAKE=
3155 > else
3156 >  echo "$as_me:$LINENO: result: no" >&5
3157   echo "${ECHO_T}no" >&6
3158 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3454 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3455 <   { (exit 1); exit 1; }; }
3456 <  fi
3158 >  SET_MAKE="MAKE=${MAKE-make}"
3159   fi
3160  
3161 < ac_ext=f90
3162 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3163 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3164 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3165 <
3166 <
3167 <
3168 < ac_ext=f90
3169 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3170 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3171 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3172 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3173 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3174 < if test "${ac_cv_prog_f90_v+set}" = set; then
3175 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3161 > if test -n "$ac_tool_prefix"; then
3162 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3163 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3164 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3165 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3166 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3167 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3168 > else
3169 >  if test -n "$RANLIB"; then
3170 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3171 > else
3172 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3173 > for as_dir in $PATH
3174 > do
3175 >  IFS=$as_save_IFS
3176 >  test -z "$as_dir" && as_dir=.
3177 >  for ac_exec_ext in '' $ac_executable_extensions; do
3178 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3179 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3180 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3181 >    break 2
3182 >  fi
3183 > done
3184 > done
3185 >
3186 > fi
3187 > fi
3188 > RANLIB=$ac_cv_prog_RANLIB
3189 > if test -n "$RANLIB"; then
3190 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3191 > echo "${ECHO_T}$RANLIB" >&6
3192   else
3193 <
3194 < cat >conftest.$ac_ext <<_ACEOF
3477 <
3478 < program main
3479 <
3480 <
3481 < end program main
3482 <
3483 < _ACEOF
3484 < rm -f conftest.$ac_objext
3485 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3486 <  (eval $ac_compile) 2>conftest.er1
3487 <  ac_status=$?
3488 <  grep -v '^ *+' conftest.er1 >conftest.err
3489 <  rm -f conftest.er1
3490 <  cat conftest.err >&5
3491 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3492 <  (exit $ac_status); } &&
3493 <         { ac_try='test -z "$ac_f90_werror_flag"
3494 <                         || test ! -s conftest.err'
3495 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3496 <  (eval $ac_try) 2>&5
3497 <  ac_status=$?
3498 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3499 <  (exit $ac_status); }; } &&
3500 <         { ac_try='test -s conftest.$ac_objext'
3501 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3502 <  (eval $ac_try) 2>&5
3503 <  ac_status=$?
3504 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3505 <  (exit $ac_status); }; }; then
3506 <  ac_cv_prog_f90_v=
3507 < # Try some options frequently used verbose output
3508 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3509 <  ac_ext=f90
3510 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3511 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3512 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3513 <
3514 < cat >conftest.$ac_ext <<_ACEOF
3515 <
3516 < program main
3517 <
3518 <
3519 < end program main
3520 <
3521 < _ACEOF
3522 <
3523 < # Compile and link our simple test program by passing a flag (argument
3524 < # 1 to this macro) to the Fortran 90 compiler in order to get
3525 < # "verbose" output that we can then parse for the Fortran 90 linker
3526 < # flags.
3527 < ac_save_F90FLAGS=$F90FLAGS
3528 < F90FLAGS="$F90FLAGS $ac_verb"
3529 <
3530 < (eval echo $as_me:3530: \"$ac_link\") >&5
3531 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3532 < echo "$ac_f90_v_output" >&5
3533 < F90FLAGS=$ac_save_F90FLAGS
3534 <
3535 < rm -f conftest.*
3536 < ac_ext=f90
3537 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3538 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3539 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3540 <
3541 < # If we are using xlf then replace all the commas with spaces.
3542 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3543 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3193 >  echo "$as_me:$LINENO: result: no" >&5
3194 > echo "${ECHO_T}no" >&6
3195   fi
3196  
3546 – # If we are using Cray Fortran then delete quotes.
3547 – # Use "\"" instead of '"' for font-lock-mode.
3548 – # FIXME: a more general fix for quoted arguments with spaces?
3549 – if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3550 –  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3197   fi
3198 <  # look for -l* and *.a constructs in the output
3199 <  for ac_arg in $ac_f90_v_output; do
3200 <     case $ac_arg in
3201 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3202 <          ac_cv_prog_f90_v=$ac_verb
3203 <          break 2 ;;
3204 <     esac
3205 <  done
3198 > if test -z "$ac_cv_prog_RANLIB"; then
3199 >  ac_ct_RANLIB=$RANLIB
3200 >  # Extract the first word of "ranlib", so it can be a program name with args.
3201 > set dummy ranlib; ac_word=$2
3202 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3203 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3204 > if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3205 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3206 > else
3207 >  if test -n "$ac_ct_RANLIB"; then
3208 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3209 > else
3210 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3211 > for as_dir in $PATH
3212 > do
3213 >  IFS=$as_save_IFS
3214 >  test -z "$as_dir" && as_dir=.
3215 >  for ac_exec_ext in '' $ac_executable_extensions; do
3216 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3217 >    ac_cv_prog_ac_ct_RANLIB="ranlib"
3218 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3219 >    break 2
3220 >  fi
3221   done
3222 < if test -z "$ac_cv_prog_f90_v"; then
3223 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3224 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3222 > done
3223 >
3224 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3225   fi
3226 + fi
3227 + ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3228 + if test -n "$ac_ct_RANLIB"; then
3229 +  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3230 + echo "${ECHO_T}$ac_ct_RANLIB" >&6
3231   else
3232 <  echo "$as_me: failed program was:" >&5
3233 < sed 's/^/| /' conftest.$ac_ext >&5
3568 <
3569 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3570 < echo "$as_me: WARNING: compilation failed" >&2;}
3232 >  echo "$as_me:$LINENO: result: no" >&5
3233 > echo "${ECHO_T}no" >&6
3234   fi
3572 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3235  
3236 +  RANLIB=$ac_ct_RANLIB
3237 + else
3238 +  RANLIB="$ac_cv_prog_RANLIB"
3239   fi
3240 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3241 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3242 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3243 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3244 < if test "${ac_cv_flibs+set}" = set; then
3240 >
3241 >
3242 >   # Extract the first word of "perl", so it can be a program name with args.
3243 > set dummy perl; ac_word=$2
3244 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3245 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3246 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3247    echo $ECHO_N "(cached) $ECHO_C" >&6
3248   else
3249 <  if test "x$F90LIBS" != "x"; then
3250 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3251 < else
3249 >  case $PERLINTERP in
3250 >  [\\/]* | ?:[\\/]*)
3251 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3252 >  ;;
3253 >  *)
3254 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3255 > for as_dir in $PATH
3256 > do
3257 >  IFS=$as_save_IFS
3258 >  test -z "$as_dir" && as_dir=.
3259 >  for ac_exec_ext in '' $ac_executable_extensions; do
3260 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3261 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3262 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3263 >    break 2
3264 >  fi
3265 > done
3266 > done
3267  
3268 < ac_ext=f90
3269 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3270 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3589 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3590 <
3591 < cat >conftest.$ac_ext <<_ACEOF
3592 <
3593 < program main
3594 <
3595 <
3596 < end program main
3597 <
3598 < _ACEOF
3599 <
3600 < # Compile and link our simple test program by passing a flag (argument
3601 < # 1 to this macro) to the Fortran 90 compiler in order to get
3602 < # "verbose" output that we can then parse for the Fortran 90 linker
3603 < # flags.
3604 < ac_save_F90FLAGS=$F90FLAGS
3605 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3606 <
3607 < (eval echo $as_me:3607: \"$ac_link\") >&5
3608 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3609 < echo "$ac_f90_v_output" >&5
3610 < F90FLAGS=$ac_save_F90FLAGS
3611 <
3612 < rm -f conftest.*
3613 < ac_ext=f90
3614 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3615 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3616 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3617 <
3618 < # If we are using xlf then replace all the commas with spaces.
3619 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3620 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3268 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3269 >  ;;
3270 > esac
3271   fi
3272 + PERLINTERP=$ac_cv_path_PERLINTERP
3273  
3274 < # If we are using Cray Fortran then delete quotes.
3275 < # Use "\"" instead of '"' for font-lock-mode.
3276 < # FIXME: a more general fix for quoted arguments with spaces?
3277 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3278 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3274 > if test -n "$PERLINTERP"; then
3275 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3276 > echo "${ECHO_T}$PERLINTERP" >&6
3277 > else
3278 >  echo "$as_me:$LINENO: result: no" >&5
3279 > echo "${ECHO_T}no" >&6
3280   fi
3281  
3282 < ac_cv_f90libs=
3282 >   ac_cv_path_perlinterp="$PERLINTERP"
3283 >   _sHpB='#!'
3284  
3632 – # Save positional arguments (if any)
3633 – ac_save_positional="$@"
3285  
3286 < set X $ac_f90_v_output
3287 < while test $# != 1; do
3288 <  shift
3289 <  ac_arg=$1
3290 <  case $ac_arg in
3291 <        [\\/]*.a | ?:[\\/]*.a)
3292 <            ac_exists=false
3293 <  for ac_i in $ac_cv_f90libs; do
3294 <    if test x"$ac_arg" = x"$ac_i"; then
3295 <      ac_exists=true
3296 <      break
3286 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3287 > if test "${with_perl_shebang+set}" = set; then
3288 >  withval="$with_perl_shebang"
3289 >  opt_perl_shebang="$withval"
3290 > else
3291 >                opt_perl_shebang="not_set"
3292 > fi;
3293 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3294 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3295 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3296 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3297 > else
3298 >   case "$opt_perl_shebang" in
3299 >                      not_set  ) ax_cv_opt_perl_shebang=''
3300 >                               ;;
3301 >                         *     )
3302 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3303 >                    esac
3304 >
3305 > fi
3306 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3307 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3308 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3309 >     then
3310 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3311 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3312 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3313 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3314 >
3315 > # Automatic detection of sharpbang formula starts here
3316 >     else
3317 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3318 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3319 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3320 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3321 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3322 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3323 > else
3324 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3325 >        if test "x$_somian_kspb_perl" == x
3326 >          then _somian_ksbp_warn_empty='durnit'
3327 >          else
3328 >          case "A$_somian_kspb_perl" in
3329 >                 A#!*perl* )
3330 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3331 >                        ;;
3332 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3333 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3334 >          esac
3335 >        fi
3336 >
3337 > fi
3338 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3339 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3340 > # The above prints Checking ... result message to user.
3341 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3342 >
3343 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3344 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3345 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3346      fi
3347 + # Inform user after printing result value
3348 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3349 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3350 + echo "$as_me: Maybe Not good -" >&6;}
3351 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3352 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3353 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3354 + echo "$as_me: OK Good result - " >&6;}
3355 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3356 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3357 +    fi
3358 +  fi
3359 +
3360 + # Find a good install program.  We prefer a C program (faster),
3361 + # so one script is as good as another.  But avoid the broken or
3362 + # incompatible versions:
3363 + # SysV /etc/install, /usr/sbin/install
3364 + # SunOS /usr/etc/install
3365 + # IRIX /sbin/install
3366 + # AIX /bin/install
3367 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3368 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3369 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3370 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3371 + # OS/2's system install, which has a completely different semantic
3372 + # ./install, which can be erroneously created by make from ./install.sh.
3373 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3374 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3375 + if test -z "$INSTALL"; then
3376 + if test "${ac_cv_path_install+set}" = set; then
3377 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3378 + else
3379 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3380 + for as_dir in $PATH
3381 + do
3382 +  IFS=$as_save_IFS
3383 +  test -z "$as_dir" && as_dir=.
3384 +  # Account for people who put trailing slashes in PATH elements.
3385 + case $as_dir/ in
3386 +  ./ | .// | /cC/* | \
3387 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3388 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3389 +  /usr/ucb/* ) ;;
3390 +  *)
3391 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3392 +    # Don't use installbsd from OSF since it installs stuff as root
3393 +    # by default.
3394 +    for ac_prog in ginstall scoinst install; do
3395 +      for ac_exec_ext in '' $ac_executable_extensions; do
3396 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3397 +          if test $ac_prog = install &&
3398 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3399 +            # AIX install.  It has an incompatible calling convention.
3400 +            :
3401 +          elif test $ac_prog = install &&
3402 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3403 +            # program-specific install script used by HP pwplus--don't use.
3404 +            :
3405 +          else
3406 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3407 +            break 3
3408 +          fi
3409 +        fi
3410 +      done
3411 +    done
3412 +    ;;
3413 + esac
3414 + done
3415 +
3416 +
3417 + fi
3418 +  if test "${ac_cv_path_install+set}" = set; then
3419 +    INSTALL=$ac_cv_path_install
3420 +  else
3421 +    # As a last resort, use the slow shell script.  We don't cache a
3422 +    # path for INSTALL within a source directory, because that will
3423 +    # break other packages using the cache if that directory is
3424 +    # removed, or if the path is relative.
3425 +    INSTALL=$ac_install_sh
3426 +  fi
3427 + fi
3428 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3429 + echo "${ECHO_T}$INSTALL" >&6
3430 +
3431 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3432 + # It thinks the first close brace ends the variable substitution.
3433 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3434 +
3435 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3436 +
3437 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3438 +
3439 + case "x$INSTALL" in
3440 +   x/*) ;;
3441 +   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3442 + esac
3443 + MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3444 + # Extract the first word of "ar", so it can be a program name with args.
3445 + set dummy ar; ac_word=$2
3446 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3447 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3448 + if test "${ac_cv_prog_AR+set}" = set; then
3449 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3450 + else
3451 +  if test -n "$AR"; then
3452 +  ac_cv_prog_AR="$AR" # Let the user override the test.
3453 + else
3454 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3455 + for as_dir in $PATH
3456 + do
3457 +  IFS=$as_save_IFS
3458 +  test -z "$as_dir" && as_dir=.
3459 +  for ac_exec_ext in '' $ac_executable_extensions; do
3460 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3461 +    ac_cv_prog_AR="ar"
3462 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3463 +    break 2
3464 +  fi
3465 + done
3466 + done
3467 +
3468 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3469 + fi
3470 + fi
3471 + AR=$ac_cv_prog_AR
3472 + if test -n "$AR"; then
3473 +  echo "$as_me:$LINENO: result: $AR" >&5
3474 + echo "${ECHO_T}$AR" >&6
3475 + else
3476 +  echo "$as_me:$LINENO: result: no" >&5
3477 + echo "${ECHO_T}no" >&6
3478 + fi
3479 +
3480 + if test "$AR" = "NONE"; then
3481 +  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3482 + echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3483 +   { (exit 1); exit 1; }; }
3484 +  cat >confcache <<\_ACEOF
3485 + # This file is a shell script that caches the results of configure
3486 + # tests run on this system so they can be shared between configure
3487 + # scripts and configure runs, see configure's option --config-cache.
3488 + # It is not useful on other systems.  If it contains results you don't
3489 + # want to keep, you may remove or edit it.
3490 + #
3491 + # config.status only pays attention to the cache file if you give it
3492 + # the --recheck option to rerun configure.
3493 + #
3494 + # `ac_cv_env_foo' variables (set or unset) will be overridden when
3495 + # loading this file, other *unset* `ac_cv_foo' will be assigned the
3496 + # following values.
3497 +
3498 + _ACEOF
3499 +
3500 + # The following way of writing the cache mishandles newlines in values,
3501 + # but we know of no workaround that is simple, portable, and efficient.
3502 + # So, don't put newlines in cache variables' values.
3503 + # Ultrix sh set writes to stderr and can't be redirected directly,
3504 + # and sets the high bit in the cache file unless we assign to the vars.
3505 + {
3506 +  (set) 2>&1 |
3507 +    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3508 +    *ac_space=\ *)
3509 +      # `set' does not quote correctly, so add quotes (double-quote
3510 +      # substitution turns \\\\ into \\, and sed turns \\ into \).
3511 +      sed -n \
3512 +        "s/'/'\\\\''/g;
3513 +          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3514 +      ;;
3515 +    *)
3516 +      # `set' quotes correctly as required by POSIX, so do not add quotes.
3517 +      sed -n \
3518 +        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3519 +      ;;
3520 +    esac;
3521 + } |
3522 +  sed '
3523 +     t clear
3524 +     : clear
3525 +     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3526 +     t end
3527 +     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3528 +     : end' >>confcache
3529 + if diff $cache_file confcache >/dev/null 2>&1; then :; else
3530 +  if test -w $cache_file; then
3531 +    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3532 +    cat confcache >$cache_file
3533 +  else
3534 +    echo "not updating unwritable cache $cache_file"
3535 +  fi
3536 + fi
3537 + rm -f confcache
3538 +  exit 1
3539 + fi
3540 + # Extract the first word of "ps", so it can be a program name with args.
3541 + set dummy ps; ac_word=$2
3542 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3543 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3544 + if test "${ac_cv_path_PS+set}" = set; then
3545 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3546 + else
3547 +  case $PS in
3548 +  [\\/]* | ?:[\\/]*)
3549 +  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3550 +  ;;
3551 +  *)
3552 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3553 + for as_dir in $PATH
3554 + do
3555 +  IFS=$as_save_IFS
3556 +  test -z "$as_dir" && as_dir=.
3557 +  for ac_exec_ext in '' $ac_executable_extensions; do
3558 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3559 +    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3560 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3561 +    break 2
3562 +  fi
3563 + done
3564 + done
3565 +
3566 +  ;;
3567 + esac
3568 + fi
3569 + PS=$ac_cv_path_PS
3570 +
3571 + if test -n "$PS"; then
3572 +  echo "$as_me:$LINENO: result: $PS" >&5
3573 + echo "${ECHO_T}$PS" >&6
3574 + else
3575 +  echo "$as_me:$LINENO: result: no" >&5
3576 + echo "${ECHO_T}no" >&6
3577 + fi
3578 +
3579 + echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3580 + echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3581 + if test "${ac_cv_prog_ps_syntax+set}" = set; then
3582 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3583 + else
3584 +
3585 +        if $PS ax -o rss > /dev/null 2>&1; then
3586 +                ac_cv_prog_ps_ax=yes
3587 +        else
3588 +                ac_cv_prog_ps_ax=no
3589 +        fi
3590 +        if $PS -ef -o rss > /dev/null 2>&1; then
3591 +                ac_cv_prog_ps_ef=yes
3592 +        else
3593 +                ac_cv_prog_ps_ef=no
3594 +        fi
3595 +        if test "$ac_cv_prog_ps_ax" = yes; then
3596 +                ac_cv_prog_ps_syntax=BSD
3597 +        else
3598 +                if test "$ac_cv_prog_ps_ef" = yes; then
3599 +                        ac_cv_prog_ps_syntax=POSIX
3600 +                else
3601 +                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3602 + echo "$as_me: error: Could not determine ps syntax" >&2;}
3603 +   { (exit 1); exit 1; }; }
3604 +                fi
3605 +        fi
3606 +
3607 + fi
3608 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3609 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3610 +
3611 + cat >>confdefs.h <<_ACEOF
3612 + #define PSCOMMAND $PS
3613 + _ACEOF
3614 +
3615 + if test "$ac_cv_prog_ps_syntax" = BSD; then
3616 +
3617 + cat >>confdefs.h <<\_ACEOF
3618 + #define PSTYPE_IS_BSD 1
3619 + _ACEOF
3620 +
3621 + else
3622 +   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3623 +
3624 + cat >>confdefs.h <<\_ACEOF
3625 + #define PSTYPE_IS_POSIX 1
3626 + _ACEOF
3627 +
3628 +   else
3629 +       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3630 + echo "$as_me: error: Unknown ps syntax type!" >&2;}
3631 +   { (exit 1); exit 1; }; }
3632 +   fi
3633 + fi
3634 +
3635 + ac_ext=${FC_SRCEXT-f}
3636 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3637 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3638 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3639 +
3640 +
3641 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3642 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3643 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3644 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3645 + else
3646 +  ac_ext=F90
3647 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3648 + FCFLAGS_SRCEXT=""
3649 + ac_cv_fc_srcext_F90=unknown
3650 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3651 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3652 +  cat >conftest.$ac_ext <<_ACEOF
3653 +      program main
3654 +
3655 +      end
3656 + _ACEOF
3657 + rm -f conftest.$ac_objext
3658 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3659 +  (eval $ac_compile) 2>conftest.er1
3660 +  ac_status=$?
3661 +  grep -v '^ *+' conftest.er1 >conftest.err
3662 +  rm -f conftest.er1
3663 +  cat conftest.err >&5
3664 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3665 +  (exit $ac_status); } &&
3666 +         { ac_try='test -z "$ac_fc_werror_flag"
3667 +                         || test ! -s conftest.err'
3668 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3669 +  (eval $ac_try) 2>&5
3670 +  ac_status=$?
3671 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3672 +  (exit $ac_status); }; } &&
3673 +         { ac_try='test -s conftest.$ac_objext'
3674 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3675 +  (eval $ac_try) 2>&5
3676 +  ac_status=$?
3677 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3678 +  (exit $ac_status); }; }; then
3679 +  ac_cv_fc_srcext_F90=$ac_flag; break
3680 + else
3681 +  echo "$as_me: failed program was:" >&5
3682 + sed 's/^/| /' conftest.$ac_ext >&5
3683 +
3684 + fi
3685 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3686 + done
3687 + rm -f conftest.$ac_objext conftest.F90
3688 + FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3689 +
3690 + fi
3691 + echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3692 + echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3693 + if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3694 +  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3695 + echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3696 +   { (exit 1); exit 1; }; }
3697 + else
3698 +  FC_SRCEXT=F90
3699 +  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3700 +    FCFLAGS_SRCEXT=""
3701 +    FCFLAGS_F90=""
3702 +  else
3703 +    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3704 +    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3705 +  fi
3706 +
3707 +
3708 + fi
3709 +
3710 +
3711 +
3712 +
3713 +
3714 + # Try to determine native compiler flags that allow us to use F90 suffix
3715 + # for preprocessed f90 source.
3716 +
3717 + if test "$ac_test_PREPFLAG" != "set"; then
3718 +  PREPFLAG=""
3719 +  case "${host_cpu}-${host_os}" in
3720 +
3721 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3722 +                    PREPFLAG="-fpp1 "
3723 +                fi;;
3724 +  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3725 +                    PREPFLAG="-qsuffix=cpp=F90 "
3726 +                fi;;
3727 +  *darwin*)
3728 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3729 +                PREPFLAG="-qsuffix=cpp=F90 "
3730 +        fi;;
3731 +  esac
3732 +
3733 +  if test -z "$PREPFLAG"; then
3734 +        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3735 + echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3736 +        PREPFLAG=""
3737 +  fi
3738 +
3739 +  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3740 + echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3741 +
3742 +
3743 +  ac_ext=${FC_SRCEXT-f}
3744 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3745 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3746 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3747 +
3748 +  ac_save_ext=$ac_ext
3749 +  ac_ext=F90
3750 +  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3751 +
3752 +  if test "$PREPFLAG"; then
3753 +  FCFLAGS_SRCEXT="${PREPFLAG}"
3754 + fi
3755 +
3756 +    cat >conftest.$ac_ext <<_ACEOF
3757 +
3758 +
3759 + program conftest
3760 +  integer :: i
3761 +  i = 1
3762 + end program conftest
3763 +
3764 + _ACEOF
3765 + rm -f conftest.$ac_objext
3766 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3767 +  (eval $ac_compile) 2>conftest.er1
3768 +  ac_status=$?
3769 +  grep -v '^ *+' conftest.er1 >conftest.err
3770 +  rm -f conftest.er1
3771 +  cat conftest.err >&5
3772 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3773 +  (exit $ac_status); } &&
3774 +         { ac_try='test -z "$ac_fc_werror_flag"
3775 +                         || test ! -s conftest.err'
3776 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3777 +  (eval $ac_try) 2>&5
3778 +  ac_status=$?
3779 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3780 +  (exit $ac_status); }; } &&
3781 +         { ac_try='test -s conftest.$ac_objext'
3782 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3783 +  (eval $ac_try) 2>&5
3784 +  ac_status=$?
3785 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3786 +  (exit $ac_status); }; }; then
3787 +  prepflagworks=1
3788 + else
3789 +  echo "$as_me: failed program was:" >&5
3790 + sed 's/^/| /' conftest.$ac_ext >&5
3791 +
3792 + prepflagworks=0
3793 + fi
3794 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3795 +
3796 +  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3797 +  ac_ext=$ac_save_ext
3798 +  ac_ext=${FC_SRCEXT-f}
3799 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3800 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3801 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3802 +
3803 +
3804 +  if test "$prepflagworks" = 1; then
3805 +    echo "$as_me:$LINENO: result: yes" >&5
3806 + echo "${ECHO_T}yes" >&6
3807 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3808 +
3809 +  else
3810 +    echo "$as_me:$LINENO: result: no" >&5
3811 + echo "${ECHO_T}no" >&6
3812 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3813 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3814 +   { (exit 1); exit 1; }; }
3815 +  fi
3816 + fi
3817 +
3818 +
3819 +
3820 +
3821 +
3822 + # Try to determine native compiler flags that allow us to use F90 suffix
3823 + # for preprocessed f90 source with -D type defines
3824 +
3825 + if test "$ac_test_PREPDEFFLAG" != "set"; then
3826 +  PREPDEFFLAG=""
3827 +  case "${host_cpu}-${host_os}" in
3828 +
3829 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3830 +                    PREPDEFFLAG=" "
3831 +                fi;;
3832 +  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3833 +                    PREPDEFFLAG="-WF,"
3834 +                fi;;
3835 +  *darwin*)
3836 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3837 +                PREPDEFFLAG="-WF,"
3838 +        fi;;
3839 +  esac
3840 +
3841 +  if test -z "$PREPDEFFLAG"; then
3842 +        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3843 + echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3844 +        PREPDEFFLAG=" "
3845 +  fi
3846 +
3847 +  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3848 + echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3849 +
3850 +
3851 +  ac_ext=${FC_SRCEXT-f}
3852 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3853 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3854 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3855 +
3856 +  ac_save_ext=$ac_ext
3857 +  ac_ext=F90
3858 +  ac_save_FCFLAGS=$FCFLAGS
3859 +
3860 +  if test "$PREPDEFFLAG"; then
3861 +  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3862 + fi
3863 +
3864 +    cat >conftest.$ac_ext <<_ACEOF
3865 +
3866 +
3867 + program conftest
3868 +  integer :: i
3869 + #ifdef TEST
3870 +  i = 1
3871 + #else
3872 +  choke me
3873 + #endif
3874 + end program conftest
3875 +
3876 + _ACEOF
3877 + rm -f conftest.$ac_objext
3878 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3879 +  (eval $ac_compile) 2>conftest.er1
3880 +  ac_status=$?
3881 +  grep -v '^ *+' conftest.er1 >conftest.err
3882 +  rm -f conftest.er1
3883 +  cat conftest.err >&5
3884 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3885 +  (exit $ac_status); } &&
3886 +         { ac_try='test -z "$ac_fc_werror_flag"
3887 +                         || test ! -s conftest.err'
3888 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3889 +  (eval $ac_try) 2>&5
3890 +  ac_status=$?
3891 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3892 +  (exit $ac_status); }; } &&
3893 +         { ac_try='test -s conftest.$ac_objext'
3894 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3895 +  (eval $ac_try) 2>&5
3896 +  ac_status=$?
3897 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3898 +  (exit $ac_status); }; }; then
3899 +  prepdefflagworks=1
3900 + else
3901 +  echo "$as_me: failed program was:" >&5
3902 + sed 's/^/| /' conftest.$ac_ext >&5
3903 +
3904 + prepdefflagworks=0
3905 + fi
3906 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3907 +
3908 +  FCFLAGS=$ac_save_FCFLAGS
3909 +  ac_ext=$ac_save_ext
3910 +  ac_ext=${FC_SRCEXT-f}
3911 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3912 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3913 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3914 +
3915 +
3916 +  if test "$prepdefflagworks" = 1; then
3917 +    echo "$as_me:$LINENO: result: yes" >&5
3918 + echo "${ECHO_T}yes" >&6
3919 +
3920 +  else
3921 +    echo "$as_me:$LINENO: result: no" >&5
3922 + echo "${ECHO_T}no" >&6
3923 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3924 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3925 +   { (exit 1); exit 1; }; }
3926 +  fi
3927 + fi
3928 +
3929 + ac_ext=${FC_SRCEXT-f}
3930 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3931 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3932 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3933 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3934 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3935 + if test "${ac_cv_prog_fc_v+set}" = set; then
3936 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3937 + else
3938 +  cat >conftest.$ac_ext <<_ACEOF
3939 +      program main
3940 +
3941 +      end
3942 + _ACEOF
3943 + rm -f conftest.$ac_objext
3944 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3945 +  (eval $ac_compile) 2>conftest.er1
3946 +  ac_status=$?
3947 +  grep -v '^ *+' conftest.er1 >conftest.err
3948 +  rm -f conftest.er1
3949 +  cat conftest.err >&5
3950 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3951 +  (exit $ac_status); } &&
3952 +         { ac_try='test -z "$ac_fc_werror_flag"
3953 +                         || test ! -s conftest.err'
3954 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3955 +  (eval $ac_try) 2>&5
3956 +  ac_status=$?
3957 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3958 +  (exit $ac_status); }; } &&
3959 +         { ac_try='test -s conftest.$ac_objext'
3960 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3961 +  (eval $ac_try) 2>&5
3962 +  ac_status=$?
3963 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3964 +  (exit $ac_status); }; }; then
3965 +  ac_cv_prog_fc_v=
3966 + # Try some options frequently used verbose output
3967 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3968 +  cat >conftest.$ac_ext <<_ACEOF
3969 +      program main
3970 +
3971 +      end
3972 + _ACEOF
3973 +
3974 + # Compile and link our simple test program by passing a flag (argument
3975 + # 1 to this macro) to the Fortran compiler in order to get
3976 + # "verbose" output that we can then parse for the Fortran linker
3977 + # flags.
3978 + ac_save_FFLAGS=$FCFLAGS
3979 + FCFLAGS="$FCFLAGS $ac_verb"
3980 + (eval echo $as_me:3980: \"$ac_link\") >&5
3981 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3982 + echo "$ac_fc_v_output" >&5
3983 + FCFLAGS=$ac_save_FFLAGS
3984 +
3985 + rm -f conftest*
3986 +
3987 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
3988 + # /foo, /bar, and /baz are search directories for the Fortran linker.
3989 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
3990 + ac_fc_v_output="`echo $ac_fc_v_output |
3991 +        grep 'LPATH is:' |
3992 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
3993 +
3994 + case $ac_fc_v_output in
3995 +  # If we are using xlf then replace all the commas with spaces.
3996 +  *xlfentry*)
3997 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
3998 +
3999 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4000 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4001 +  *mGLOB_options_string*)
4002 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4003 +
4004 +  # If we are using Cray Fortran then delete quotes.
4005 +  # Use "\"" instead of '"' for font-lock-mode.
4006 +  # FIXME: a more general fix for quoted arguments with spaces?
4007 +  *cft90*)
4008 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4009 + esac
4010 +
4011 +
4012 +  # look for -l* and *.a constructs in the output
4013 +  for ac_arg in $ac_fc_v_output; do
4014 +     case $ac_arg in
4015 +        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4016 +          ac_cv_prog_fc_v=$ac_verb
4017 +          break 2 ;;
4018 +     esac
4019    done
4020 + done
4021 + if test -z "$ac_cv_prog_fc_v"; then
4022 +   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4023 + echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4024 + fi
4025 + else
4026 +  echo "$as_me: failed program was:" >&5
4027 + sed 's/^/| /' conftest.$ac_ext >&5
4028  
4029 + { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4030 + echo "$as_me: WARNING: compilation failed" >&2;}
4031 + fi
4032 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4033 +
4034 + fi
4035 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4036 + echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4037 + echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4038 + echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4039 + if test "${ac_cv_fc_libs+set}" = set; then
4040 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4041 + else
4042 +  if test "x$FCLIBS" != "x"; then
4043 +  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4044 + else
4045 +
4046 + cat >conftest.$ac_ext <<_ACEOF
4047 +      program main
4048 +
4049 +      end
4050 + _ACEOF
4051 +
4052 + # Compile and link our simple test program by passing a flag (argument
4053 + # 1 to this macro) to the Fortran compiler in order to get
4054 + # "verbose" output that we can then parse for the Fortran linker
4055 + # flags.
4056 + ac_save_FFLAGS=$FCFLAGS
4057 + FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4058 + (eval echo $as_me:4058: \"$ac_link\") >&5
4059 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4060 + echo "$ac_fc_v_output" >&5
4061 + FCFLAGS=$ac_save_FFLAGS
4062 +
4063 + rm -f conftest*
4064 +
4065 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4066 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4067 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4068 + ac_fc_v_output="`echo $ac_fc_v_output |
4069 +        grep 'LPATH is:' |
4070 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4071 +
4072 + case $ac_fc_v_output in
4073 +  # If we are using xlf then replace all the commas with spaces.
4074 +  *xlfentry*)
4075 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4076 +
4077 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4078 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4079 +  *mGLOB_options_string*)
4080 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4081 +
4082 +  # If we are using Cray Fortran then delete quotes.
4083 +  # Use "\"" instead of '"' for font-lock-mode.
4084 +  # FIXME: a more general fix for quoted arguments with spaces?
4085 +  *cft90*)
4086 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4087 + esac
4088 +
4089 +
4090 +
4091 + ac_cv_fc_libs=
4092 +
4093 + # Save positional arguments (if any)
4094 + ac_save_positional="$@"
4095 +
4096 + set X $ac_fc_v_output
4097 + while test $# != 1; do
4098 +  shift
4099 +  ac_arg=$1
4100 +  case $ac_arg in
4101 +        [\\/]*.a | ?:[\\/]*.a)
4102 +            ac_exists=false
4103 +  for ac_i in $ac_cv_fc_libs; do
4104 +    if test x"$ac_arg" = x"$ac_i"; then
4105 +      ac_exists=true
4106 +      break
4107 +    fi
4108 +  done
4109 +
4110    if test x"$ac_exists" = xtrue; then
4111    :
4112   else
4113 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4113 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4114   fi
4115  
4116            ;;
4117          -bI:*)
4118              ac_exists=false
4119 <  for ac_i in $ac_cv_f90libs; do
4119 >  for ac_i in $ac_cv_fc_libs; do
4120      if test x"$ac_arg" = x"$ac_i"; then
4121        ac_exists=true
4122        break
# Line 3667 | Line 4128 | else
4128   else
4129    if test "$ac_compiler_gnu" = yes; then
4130    for ac_link_opt in $ac_arg; do
4131 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4131 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4132    done
4133   else
4134 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4134 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4135   fi
4136   fi
4137  
4138            ;;
4139            # Ignore these flags.
4140 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4140 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4141            ;;
4142          -lkernel32)
4143 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4143 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4144            ;;
4145          -[LRuY])
4146            # These flags, when seen by themselves, take an argument.
4147            # We remove the space between option and argument and re-iterate
4148            # unless we find an empty arg or a new option (starting with -)
4149            case $2 in
4150 <             "" | -*);;
4151 <             *)
4150 >             "" | -*);;
4151 >             *)
4152                  ac_arg="$ac_arg$2"
3692 –
4153                  shift; shift
4154                  set X $ac_arg "$@"
4155                  ;;
# Line 3698 | Line 4158 | fi
4158          -YP,*)
4159            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4160                ac_exists=false
4161 <  for ac_i in $ac_cv_f90libs; do
4161 >  for ac_i in $ac_cv_fc_libs; do
4162      if test x"$ac_j" = x"$ac_i"; then
4163        ac_exists=true
4164        break
# Line 3709 | Line 4169 | else
4169    :
4170   else
4171    ac_arg="$ac_arg $ac_j"
4172 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4172 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4173   fi
4174  
4175            done
4176            ;;
4177          -[lLR]*)
4178              ac_exists=false
4179 <  for ac_i in $ac_cv_f90libs; do
4179 >  for ac_i in $ac_cv_fc_libs; do
4180      if test x"$ac_arg" = x"$ac_i"; then
4181        ac_exists=true
4182        break
# Line 3726 | Line 4186 | else
4186    if test x"$ac_exists" = xtrue; then
4187    :
4188   else
4189 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4189 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4190   fi
4191  
4192            ;;
# Line 3741 | Line 4201 | case `(uname -sr) 2>/dev/null` in
4201   # must begin with a "/").
4202   case `(uname -sr) 2>/dev/null` in
4203     "SunOS 5"*)
4204 <      ac_ld_run_path=`echo $ac_f90_v_output |
4204 >      ac_ld_run_path=`echo $ac_fc_v_output |
4205                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4206        test "x$ac_ld_run_path" != x &&
3747 –
4207          if test "$ac_compiler_gnu" = yes; then
4208    for ac_link_opt in $ac_ld_run_path; do
4209 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4209 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4210    done
4211   else
4212 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4212 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4213   fi
4214        ;;
4215   esac
4216 < fi # test "x$F90LIBS" = "x"
4216 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4217  
4218   fi
4219 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4220 < echo "${ECHO_T}$ac_cv_flibs" >&6
4221 < F90LIBS="$ac_cv_f90libs"
4219 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4220 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4221 > FCLIBS="$ac_cv_fc_libs"
4222  
3764 – ac_ext=f90
3765 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3766 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3767 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4223  
4224 + ac_ext=${FC_SRCEXT-f}
4225 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4226 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4227 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4228  
4229 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4230 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4231 < if test "${ac_cv_f90_mangling+set}" = set; then
4229 >
4230 > ac_ext=${FC_SRCEXT-f}
4231 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4232 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4233 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4234 >
4235 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4236 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4237 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4238    echo $ECHO_N "(cached) $ECHO_C" >&6
4239   else
4240 <  ac_ext=f90
4241 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4242 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4243 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3779 < cat >conftest.$ac_ext <<_ACEOF
3780 < subroutine foobar()
3781 < return
3782 < end
3783 < subroutine foo_bar()
3784 < return
3785 < end
3786 < _ACEOF
3787 < rm -f conftest.$ac_objext
3788 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3789 <  (eval $ac_compile) 2>conftest.er1
3790 <  ac_status=$?
3791 <  grep -v '^ *+' conftest.er1 >conftest.err
3792 <  rm -f conftest.er1
3793 <  cat conftest.err >&5
3794 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3795 <  (exit $ac_status); } &&
3796 <         { ac_try='test -z "$ac_f90_werror_flag"
3797 <                         || test ! -s conftest.err'
3798 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3799 <  (eval $ac_try) 2>&5
3800 <  ac_status=$?
3801 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3802 <  (exit $ac_status); }; } &&
3803 <         { ac_try='test -s conftest.$ac_objext'
3804 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3805 <  (eval $ac_try) 2>&5
3806 <  ac_status=$?
3807 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808 <  (exit $ac_status); }; }; then
3809 <  mv conftest.$ac_objext cf90_test.$ac_objext
3810 <
3811 <  ac_ext=c
4240 >  ac_fc_dm_save_LIBS=$LIBS
4241 > LIBS="$LIBS $FCLIBS"
4242 > ac_fortran_dm_var=FC_DUMMY_MAIN
4243 > ac_ext=c
4244   ac_cpp='$CPP $CPPFLAGS'
4245   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4246   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4247   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4248  
4249 <  ac_save_LIBS=$LIBS
4250 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3819 <
3820 <  ac_success=no
3821 <  for ac_foobar in foobar FOOBAR; do
3822 <    for ac_underscore in "" "_"; do
3823 <      ac_func="$ac_foobar$ac_underscore"
3824 <      cat >conftest.$ac_ext <<_ACEOF
4249 > # First, try linking without a dummy main:
4250 > cat >conftest.$ac_ext <<_ACEOF
4251   /* confdefs.h.  */
4252   _ACEOF
4253   cat confdefs.h >>conftest.$ac_ext
4254   cat >>conftest.$ac_ext <<_ACEOF
4255   /* end confdefs.h.  */
4256  
4257 < /* Override any gcc2 internal prototype to avoid an error.  */
4258 < #ifdef __cplusplus
4259 < extern "C"
4257 > #ifdef FC_DUMMY_MAIN
4258 > #ifndef FC_DUMMY_MAIN_EQ_F77
4259 > #  ifdef __cplusplus
4260 >     extern "C"
4261 > #  endif
4262 >   int FC_DUMMY_MAIN() { return 1; }
4263   #endif
4264 < /* We use char because int might match the return type of a gcc2
3836 <   builtin and then its argument prototype would still apply.  */
3837 < char $ac_func ();
4264 > #endif
4265   int
4266   main ()
4267   {
4268 < $ac_func ();
4268 >
4269    ;
4270    return 0;
4271   }
# Line 3865 | Line 4292 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4292    ac_status=$?
4293    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4294    (exit $ac_status); }; }; then
4295 <  ac_success=yes; break 2
4295 >  ac_cv_fortran_dummy_main=none
4296   else
4297    echo "$as_me: failed program was:" >&5
4298   sed 's/^/| /' conftest.$ac_ext >&5
4299  
4300 + ac_cv_fortran_dummy_main=unknown
4301   fi
4302   rm -f conftest.err conftest.$ac_objext \
4303        conftest$ac_exeext conftest.$ac_ext
3876 –    done
3877 –  done
4304  
4305 <  if test "$ac_success" = "yes"; then
4306 <     case $ac_foobar in
4307 <        foobar)
3882 <           ac_case=lower
3883 <           ac_foo_bar=foo_bar
3884 <           ;;
3885 <        FOOBAR)
3886 <           ac_case=upper
3887 <           ac_foo_bar=FOO_BAR
3888 <           ;;
3889 <     esac
3890 <
3891 <     ac_success_extra=no
3892 <     for ac_extra in "" "_"; do
3893 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3894 <
3895 <        cat >conftest.$ac_ext <<_ACEOF
4305 > if test $ac_cv_fortran_dummy_main = unknown; then
4306 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4307 >     cat >conftest.$ac_ext <<_ACEOF
4308   /* confdefs.h.  */
4309   _ACEOF
4310   cat confdefs.h >>conftest.$ac_ext
4311   cat >>conftest.$ac_ext <<_ACEOF
4312   /* end confdefs.h.  */
4313 <
4314 < /* Override any gcc2 internal prototype to avoid an error.  */
4315 < #ifdef __cplusplus
4316 < extern "C"
4313 > #define $ac_fortran_dm_var $ac_func
4314 > #ifdef FC_DUMMY_MAIN
4315 > #ifndef FC_DUMMY_MAIN_EQ_F77
4316 > #  ifdef __cplusplus
4317 >     extern "C"
4318 > #  endif
4319 >   int FC_DUMMY_MAIN() { return 1; }
4320   #endif
4321 < /* We use char because int might match the return type of a gcc2
3907 <   builtin and then its argument prototype would still apply.  */
3908 < char $ac_func ();
4321 > #endif
4322   int
4323   main ()
4324   {
4325 < $ac_func ();
4325 >
4326    ;
4327    return 0;
4328   }
# Line 3936 | Line 4349 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4349    ac_status=$?
4350    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4351    (exit $ac_status); }; }; then
4352 <  ac_success_extra=yes; break
4352 >  ac_cv_fortran_dummy_main=$ac_func; break
4353   else
4354    echo "$as_me: failed program was:" >&5
4355   sed 's/^/| /' conftest.$ac_ext >&5
# Line 3944 | Line 4357 | rm -f conftest.err conftest.$ac_objext \
4357   fi
4358   rm -f conftest.err conftest.$ac_objext \
4359        conftest$ac_exeext conftest.$ac_ext
4360 <     done
4360 >   done
4361 > fi
4362 > ac_ext=${FC_SRCEXT-f}
4363 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4364 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4365 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4366 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4367 > rm -f conftest*
4368 > LIBS=$ac_fc_dm_save_LIBS
4369  
4370 <     if test "$ac_success_extra" = "yes"; then
4371 <        ac_cv_f90_mangling="$ac_case case"
4372 <        if test -z "$ac_underscore"; then
4373 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4374 <        else
4375 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4370 > fi
4371 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4372 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4373 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4374 > if test "$FC_DUMMY_MAIN" != unknown; then
4375 >  if test $FC_DUMMY_MAIN != none; then
4376  
4377 <        fi
4378 <        if test -z "$ac_extra"; then
4379 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4380 <        else
4381 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4382 <        fi
4383 <      else
4384 <        ac_cv_f90_mangling="unknown"
4385 <      fi
4386 <  else
4387 <     ac_cv_f90_mangling="unknown"
4388 <
4389 <  fi
4390 <
4391 <  LIBS=$ac_save_LIBS
4392 <  ac_ext=f90
4393 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4394 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4395 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4396 <  rm -f cf90_test* conftest*
4397 < else
4398 <  echo "$as_me: failed program was:" >&5
4399 < sed 's/^/| /' conftest.$ac_ext >&5
4400 <
4401 < fi
4402 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4403 < ac_ext=f90
4404 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4405 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4406 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4407 <
4408 < fi
4409 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4410 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4411 <
4412 <
4413 <
4414 < case $ac_cv_f90_mangling in
4415 <  "lower case, no underscore, no extra underscore")
4416 <          cat >>confdefs.h <<\_ACEOF
4417 < #define F90_FUNC(name,NAME) name
4418 < _ACEOF
4419 <
4420 <          cat >>confdefs.h <<\_ACEOF
4421 < #define F90_FUNC_(name,NAME) name
4422 < _ACEOF
4423 < ;;
4424 <  "lower case, no underscore, extra underscore")
4425 <          cat >>confdefs.h <<\_ACEOF
4426 < #define F90_FUNC(name,NAME) name
4427 < _ACEOF
4428 <
4429 <          cat >>confdefs.h <<\_ACEOF
4430 < #define F90_FUNC_(name,NAME) name ## _
4431 < _ACEOF
4432 < ;;
4433 <  "lower case, underscore, no extra underscore")
4434 <          cat >>confdefs.h <<\_ACEOF
4435 < #define F90_FUNC(name,NAME) name ## _
4436 < _ACEOF
4437 <
4438 <          cat >>confdefs.h <<\_ACEOF
4439 < #define F90_FUNC_(name,NAME) name ## _
4440 < _ACEOF
4441 < ;;
4442 <  "lower case, underscore, extra underscore")
4443 <          cat >>confdefs.h <<\_ACEOF
4444 < #define F90_FUNC(name,NAME) name ## _
4445 < _ACEOF
4446 <
4447 <          cat >>confdefs.h <<\_ACEOF
4448 < #define F90_FUNC_(name,NAME) name ## __
4449 < _ACEOF
4450 < ;;
4451 <  "upper case, no underscore, no extra underscore")
4452 <          cat >>confdefs.h <<\_ACEOF
4453 < #define F90_FUNC(name,NAME) NAME
4454 < _ACEOF
4455 <
4456 <          cat >>confdefs.h <<\_ACEOF
4457 < #define F90_FUNC_(name,NAME) NAME
4458 < _ACEOF
4459 < ;;
4460 <  "upper case, no underscore, extra underscore")
4461 <          cat >>confdefs.h <<\_ACEOF
4462 < #define F90_FUNC(name,NAME) NAME
4463 < _ACEOF
4464 <
4465 <          cat >>confdefs.h <<\_ACEOF
4466 < #define F90_FUNC_(name,NAME) NAME ## _
4467 < _ACEOF
4468 < ;;
4469 <  "upper case, underscore, no extra underscore")
4470 <          cat >>confdefs.h <<\_ACEOF
4471 < #define F90_FUNC(name,NAME) NAME ## _
4472 < _ACEOF
4473 <
4474 <          cat >>confdefs.h <<\_ACEOF
4475 < #define F90_FUNC_(name,NAME) NAME ## _
4476 < _ACEOF
4477 < ;;
4478 <  "upper case, underscore, extra underscore")
4479 <          cat >>confdefs.h <<\_ACEOF
4480 < #define F90_FUNC(name,NAME) NAME ## _
4481 < _ACEOF
4482 <
4483 <          cat >>confdefs.h <<\_ACEOF
4484 < #define F90_FUNC_(name,NAME) NAME ## __
4485 < _ACEOF
4486 < ;;
4487 <  *)
4488 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4489 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4490 <          ;;
4491 < esac
4492 <
4493 <
4494 <
4495 <
4496 <
4497 < echo "$as_me:$LINENO: checking for module suffix" >&5
4498 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4499 < rm -f conftest*
4500 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4501 < rm -f work*
4502 < cat >conftest.f90 <<EOF
4503 <        module conftest
4504 <        integer n
4505 <        parameter (n=1)
4506 <        end module conftest
4507 < EOF
4508 < # SGI and absoft compilers generates module name in upper case!
4509 < testname="conftest"
4510 < modcase="lower"
4511 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4512 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4513 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4514 <    if test -z "$MOD" ; then
4515 <        MOD=`ls CONFTEST* 2>/dev/null \
4516 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4517 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4518 <        if test -n "$MOD" ; then
4519 <            testname="CONFTEST"
4520 <            modcase="upper"
4521 <        fi
4522 <    fi
4523 <    if test -z "$MOD" ; then
4524 <        echo "$as_me:$LINENO: result: unknown" >&5
4525 < echo "${ECHO_T}unknown" >&6
4526 <        # Use mod if we can't figure it out
4527 <        MOD="mod"
4528 <    else
4529 <        echo "$as_me:$LINENO: result: $MOD" >&5
4530 < echo "${ECHO_T}$MOD" >&6
4531 <    fi
4532 <    if test -s work.pcl ; then
4533 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4534 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4535 <    fi
4536 < else
4537 <    echo "$as_me:$LINENO: result: unknown" >&5
4538 < echo "${ECHO_T}unknown" >&6
4539 < fi
4540 <
4541 <
4542 <
4543 <
4544 <
4545 < # Check for module include path (some use -I, some (Solaris) use -M, some
4546 < # (absoft) use -p).
4547 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4548 < # specified, work.pcl and work.pc are created.  However, if you specify
4549 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4550 < # Use the module made above
4551 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4552 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4553 < rm -f conftest*
4554 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4555 < rm -f work*
4556 < cat >conftest.f90 <<EOF
4557 <        module conftest
4558 <        integer n
4559 <        parameter (n=1)
4560 <        end module conftest
4561 < EOF
4562 < # SGI and absoft compilers generates module name in upper case!
4563 < testname="conftest"
4564 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4565 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4566 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4567 <   if test -n "$mod" ; then
4568 <      testname="CONFTEST"
4569 <   fi
4570 <   madedir=0
4571 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4572 <   cp $testname.$MOD conf
4573 <   rm -f conftest* CONFTEST*
4574 <   cat >conftest1.f90 <<EOF
4575 <        program main
4576 <        use conftest
4577 <        print *, n
4578 <        end
4579 < EOF
4580 <   F90_WORK_FILES_ARG=""
4581 <   F90MODINCSPEC=""
4582 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4583 <       MODDIRFLAG="-I"
4584 <       F90MODINCSPEC="-I<dir>"
4585 <       echo "$as_me:$LINENO: result: -I" >&5
4586 < echo "${ECHO_T}-I" >&6
4587 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4588 <       MODDIRFLAG="-M"
4589 <       F90MODINCSPEC="-M<dir>"
4590 <       echo "$as_me:$LINENO: result: -M" >&5
4591 < echo "${ECHO_T}-M" >&6
4592 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4593 <       MODDIRFLAG="-p"
4594 <       F90MODINCSPEC="-p<dir>"
4595 <       echo "$as_me:$LINENO: result: -p" >&5
4596 < echo "${ECHO_T}-p" >&6
4597 <   elif test -s work.pc ; then
4598 <        cp work.pc conf/mpimod.pc
4599 <        echo "mpimod.pc" > conf/mpimod.pcl
4600 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4601 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4602 <            MODDIRFLAG='-cl,mpimod.pcl'
4603 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4604 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4605 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4606 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4377 > cat >>confdefs.h <<_ACEOF
4378 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4379 > _ACEOF
4380 >
4381 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4382 >
4383 > cat >>confdefs.h <<\_ACEOF
4384 > #define FC_DUMMY_MAIN_EQ_F77 1
4385 > _ACEOF
4386 >
4387 >  fi
4388 > fi
4389 > else
4390 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4391 > See \`config.log' for more details." >&5
4392 > echo "$as_me: error: linking to Fortran libraries from C fails
4393 > See \`config.log' for more details." >&2;}
4394 >   { (exit 1); exit 1; }; }
4395 > fi
4396 >
4397 >
4398 > ac_ext=${FC_SRCEXT-f}
4399 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4400 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4401 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4402 >
4403 > ac_ext=${FC_SRCEXT-f}
4404 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4405 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4406 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4407 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4408 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4409 > if test "${ac_cv_fc_mangling+set}" = set; then
4410 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4411 > else
4412 >  cat >conftest.$ac_ext <<_ACEOF
4413 >      subroutine foobar()
4414 >      return
4415 >      end
4416 >      subroutine foo_bar()
4417 >      return
4418 >      end
4419 > _ACEOF
4420 > rm -f conftest.$ac_objext
4421 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4422 >  (eval $ac_compile) 2>conftest.er1
4423 >  ac_status=$?
4424 >  grep -v '^ *+' conftest.er1 >conftest.err
4425 >  rm -f conftest.er1
4426 >  cat conftest.err >&5
4427 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4428 >  (exit $ac_status); } &&
4429 >         { ac_try='test -z "$ac_fc_werror_flag"
4430 >                         || test ! -s conftest.err'
4431 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4432 >  (eval $ac_try) 2>&5
4433 >  ac_status=$?
4434 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4435 >  (exit $ac_status); }; } &&
4436 >         { ac_try='test -s conftest.$ac_objext'
4437 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4438 >  (eval $ac_try) 2>&5
4439 >  ac_status=$?
4440 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4441 >  (exit $ac_status); }; }; then
4442 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4443 >
4444 >  ac_save_LIBS=$LIBS
4445 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4446 >
4447 >  ac_ext=c
4448 > ac_cpp='$CPP $CPPFLAGS'
4449 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4450 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4451 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4452 >  ac_success=no
4453 >  for ac_foobar in foobar FOOBAR; do
4454 >    for ac_underscore in "" "_"; do
4455 >      ac_func="$ac_foobar$ac_underscore"
4456 >      cat >conftest.$ac_ext <<_ACEOF
4457 > /* confdefs.h.  */
4458 > _ACEOF
4459 > cat confdefs.h >>conftest.$ac_ext
4460 > cat >>conftest.$ac_ext <<_ACEOF
4461 > /* end confdefs.h.  */
4462 >
4463 > /* Override any gcc2 internal prototype to avoid an error.  */
4464 > #ifdef __cplusplus
4465 > extern "C"
4466 > #endif
4467 > /* We use char because int might match the return type of a gcc2
4468 >   builtin and then its argument prototype would still apply.  */
4469 > char $ac_func ();
4470 > #ifdef FC_DUMMY_MAIN
4471 > #ifndef FC_DUMMY_MAIN_EQ_F77
4472 > #  ifdef __cplusplus
4473 >     extern "C"
4474 > #  endif
4475 >   int FC_DUMMY_MAIN() { return 1; }
4476 > #endif
4477 > #endif
4478 > int
4479 > main ()
4480 > {
4481 > $ac_func ();
4482 >  ;
4483 >  return 0;
4484 > }
4485 > _ACEOF
4486 > rm -f conftest.$ac_objext conftest$ac_exeext
4487 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4488 >  (eval $ac_link) 2>conftest.er1
4489 >  ac_status=$?
4490 >  grep -v '^ *+' conftest.er1 >conftest.err
4491 >  rm -f conftest.er1
4492 >  cat conftest.err >&5
4493 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4494 >  (exit $ac_status); } &&
4495 >         { ac_try='test -z "$ac_c_werror_flag"
4496 >                         || test ! -s conftest.err'
4497 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4498 >  (eval $ac_try) 2>&5
4499 >  ac_status=$?
4500 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4501 >  (exit $ac_status); }; } &&
4502 >         { ac_try='test -s conftest$ac_exeext'
4503 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4504 >  (eval $ac_try) 2>&5
4505 >  ac_status=$?
4506 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4507 >  (exit $ac_status); }; }; then
4508 >  ac_success=yes; break 2
4509 > else
4510 >  echo "$as_me: failed program was:" >&5
4511 > sed 's/^/| /' conftest.$ac_ext >&5
4512 >
4513 > fi
4514 > rm -f conftest.err conftest.$ac_objext \
4515 >      conftest$ac_exeext conftest.$ac_ext
4516 >    done
4517 >  done
4518 >  ac_ext=${FC_SRCEXT-f}
4519 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4520 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4521 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4522 >
4523 >  if test "$ac_success" = "yes"; then
4524 >     case $ac_foobar in
4525 >        foobar)
4526 >           ac_case=lower
4527 >           ac_foo_bar=foo_bar
4528 >           ;;
4529 >        FOOBAR)
4530 >           ac_case=upper
4531 >           ac_foo_bar=FOO_BAR
4532 >           ;;
4533 >     esac
4534 >
4535 >     ac_ext=c
4536 > ac_cpp='$CPP $CPPFLAGS'
4537 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4538 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4539 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4540 >     ac_success_extra=no
4541 >     for ac_extra in "" "_"; do
4542 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4543 >        cat >conftest.$ac_ext <<_ACEOF
4544 > /* confdefs.h.  */
4545 > _ACEOF
4546 > cat confdefs.h >>conftest.$ac_ext
4547 > cat >>conftest.$ac_ext <<_ACEOF
4548 > /* end confdefs.h.  */
4549 >
4550 > /* Override any gcc2 internal prototype to avoid an error.  */
4551 > #ifdef __cplusplus
4552 > extern "C"
4553 > #endif
4554 > /* We use char because int might match the return type of a gcc2
4555 >   builtin and then its argument prototype would still apply.  */
4556 > char $ac_func ();
4557 > #ifdef FC_DUMMY_MAIN
4558 > #ifndef FC_DUMMY_MAIN_EQ_F77
4559 > #  ifdef __cplusplus
4560 >     extern "C"
4561 > #  endif
4562 >   int FC_DUMMY_MAIN() { return 1; }
4563 > #endif
4564 > #endif
4565 > int
4566 > main ()
4567 > {
4568 > $ac_func ();
4569 >  ;
4570 >  return 0;
4571 > }
4572 > _ACEOF
4573 > rm -f conftest.$ac_objext conftest$ac_exeext
4574 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4575 >  (eval $ac_link) 2>conftest.er1
4576 >  ac_status=$?
4577 >  grep -v '^ *+' conftest.er1 >conftest.err
4578 >  rm -f conftest.er1
4579 >  cat conftest.err >&5
4580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4581 >  (exit $ac_status); } &&
4582 >         { ac_try='test -z "$ac_c_werror_flag"
4583 >                         || test ! -s conftest.err'
4584 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4585 >  (eval $ac_try) 2>&5
4586 >  ac_status=$?
4587 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4588 >  (exit $ac_status); }; } &&
4589 >         { ac_try='test -s conftest$ac_exeext'
4590 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4591 >  (eval $ac_try) 2>&5
4592 >  ac_status=$?
4593 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4594 >  (exit $ac_status); }; }; then
4595 >  ac_success_extra=yes; break
4596 > else
4597 >  echo "$as_me: failed program was:" >&5
4598 > sed 's/^/| /' conftest.$ac_ext >&5
4599 >
4600 > fi
4601 > rm -f conftest.err conftest.$ac_objext \
4602 >      conftest$ac_exeext conftest.$ac_ext
4603 >     done
4604 >     ac_ext=${FC_SRCEXT-f}
4605 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4606 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4607 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4608 >
4609 >     if test "$ac_success_extra" = "yes"; then
4610 >        ac_cv_fc_mangling="$ac_case case"
4611 >        if test -z "$ac_underscore"; then
4612 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4613 >        else
4614 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4615 >        fi
4616 >        if test -z "$ac_extra"; then
4617 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4618 >        else
4619 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4620 >        fi
4621 >      else
4622 >        ac_cv_fc_mangling="unknown"
4623 >      fi
4624 >  else
4625 >     ac_cv_fc_mangling="unknown"
4626 >  fi
4627 >
4628 >  LIBS=$ac_save_LIBS
4629 >  rm -f cfortran_test* conftest*
4630 > else
4631 >  echo "$as_me: failed program was:" >&5
4632 > sed 's/^/| /' conftest.$ac_ext >&5
4633 >
4634 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4635 > See \`config.log' for more details." >&5
4636 > echo "$as_me: error: cannot compile a simple Fortran program
4637 > See \`config.log' for more details." >&2;}
4638 >   { (exit 1); exit 1; }; }
4639 > fi
4640 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4641 >
4642 > fi
4643 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4644 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4645 >
4646 > ac_ext=${FC_SRCEXT-f}
4647 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4648 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4649 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4650 >
4651 > ac_ext=${FC_SRCEXT-f}
4652 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4653 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4654 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4655 >
4656 >
4657 > case $ac_cv_fc_mangling in
4658 >  "lower case, no underscore, no extra underscore")
4659 >          cat >>confdefs.h <<\_ACEOF
4660 > #define FC_FUNC(name,NAME) name
4661 > _ACEOF
4662 >
4663 >          cat >>confdefs.h <<\_ACEOF
4664 > #define FC_FUNC_(name,NAME) name
4665 > _ACEOF
4666 > ;;
4667 >  "lower case, no underscore, extra underscore")
4668 >          cat >>confdefs.h <<\_ACEOF
4669 > #define FC_FUNC(name,NAME) name
4670 > _ACEOF
4671 >
4672 >          cat >>confdefs.h <<\_ACEOF
4673 > #define FC_FUNC_(name,NAME) name ## _
4674 > _ACEOF
4675 > ;;
4676 >  "lower case, underscore, no extra underscore")
4677 >          cat >>confdefs.h <<\_ACEOF
4678 > #define FC_FUNC(name,NAME) name ## _
4679 > _ACEOF
4680 >
4681 >          cat >>confdefs.h <<\_ACEOF
4682 > #define FC_FUNC_(name,NAME) name ## _
4683 > _ACEOF
4684 > ;;
4685 >  "lower case, underscore, extra underscore")
4686 >          cat >>confdefs.h <<\_ACEOF
4687 > #define FC_FUNC(name,NAME) name ## _
4688 > _ACEOF
4689 >
4690 >          cat >>confdefs.h <<\_ACEOF
4691 > #define FC_FUNC_(name,NAME) name ## __
4692 > _ACEOF
4693 > ;;
4694 >  "upper case, no underscore, no extra underscore")
4695 >          cat >>confdefs.h <<\_ACEOF
4696 > #define FC_FUNC(name,NAME) NAME
4697 > _ACEOF
4698 >
4699 >          cat >>confdefs.h <<\_ACEOF
4700 > #define FC_FUNC_(name,NAME) NAME
4701 > _ACEOF
4702 > ;;
4703 >  "upper case, no underscore, extra underscore")
4704 >          cat >>confdefs.h <<\_ACEOF
4705 > #define FC_FUNC(name,NAME) NAME
4706 > _ACEOF
4707 >
4708 >          cat >>confdefs.h <<\_ACEOF
4709 > #define FC_FUNC_(name,NAME) NAME ## _
4710 > _ACEOF
4711 > ;;
4712 >  "upper case, underscore, no extra underscore")
4713 >          cat >>confdefs.h <<\_ACEOF
4714 > #define FC_FUNC(name,NAME) NAME ## _
4715 > _ACEOF
4716 >
4717 >          cat >>confdefs.h <<\_ACEOF
4718 > #define FC_FUNC_(name,NAME) NAME ## _
4719 > _ACEOF
4720 > ;;
4721 >  "upper case, underscore, extra underscore")
4722 >          cat >>confdefs.h <<\_ACEOF
4723 > #define FC_FUNC(name,NAME) NAME ## _
4724 > _ACEOF
4725 >
4726 >          cat >>confdefs.h <<\_ACEOF
4727 > #define FC_FUNC_(name,NAME) NAME ## __
4728 > _ACEOF
4729 > ;;
4730 >  *)
4731 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4732 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4733 >          ;;
4734 > esac
4735 >
4736 > ac_ext=${FC_SRCEXT-f}
4737 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4738 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4739 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4740 >
4741 >
4742 >
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 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4748 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4749 > if test "${ac_cv_prog_fc_v+set}" = set; then
4750 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4751 > else
4752 >  cat >conftest.$ac_ext <<_ACEOF
4753 >      program main
4754 >
4755 >      end
4756 > _ACEOF
4757 > rm -f conftest.$ac_objext
4758 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4759 >  (eval $ac_compile) 2>conftest.er1
4760 >  ac_status=$?
4761 >  grep -v '^ *+' conftest.er1 >conftest.err
4762 >  rm -f conftest.er1
4763 >  cat conftest.err >&5
4764 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4765 >  (exit $ac_status); } &&
4766 >         { ac_try='test -z "$ac_fc_werror_flag"
4767 >                         || test ! -s conftest.err'
4768 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4769 >  (eval $ac_try) 2>&5
4770 >  ac_status=$?
4771 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4772 >  (exit $ac_status); }; } &&
4773 >         { ac_try='test -s conftest.$ac_objext'
4774 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4775 >  (eval $ac_try) 2>&5
4776 >  ac_status=$?
4777 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4778 >  (exit $ac_status); }; }; then
4779 >  ac_cv_prog_fc_v=
4780 > # Try some options frequently used verbose output
4781 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4782 >  cat >conftest.$ac_ext <<_ACEOF
4783 >      program main
4784 >
4785 >      end
4786 > _ACEOF
4787 >
4788 > # Compile and link our simple test program by passing a flag (argument
4789 > # 1 to this macro) to the Fortran compiler in order to get
4790 > # "verbose" output that we can then parse for the Fortran linker
4791 > # flags.
4792 > ac_save_FFLAGS=$FCFLAGS
4793 > FCFLAGS="$FCFLAGS $ac_verb"
4794 > (eval echo $as_me:4794: \"$ac_link\") >&5
4795 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4796 > echo "$ac_fc_v_output" >&5
4797 > FCFLAGS=$ac_save_FFLAGS
4798 >
4799 > rm -f conftest*
4800 >
4801 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4802 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4803 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4804 > ac_fc_v_output="`echo $ac_fc_v_output |
4805 >        grep 'LPATH is:' |
4806 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4807 >
4808 > case $ac_fc_v_output in
4809 >  # If we are using xlf then replace all the commas with spaces.
4810 >  *xlfentry*)
4811 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4812 >
4813 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4814 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4815 >  *mGLOB_options_string*)
4816 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4817 >
4818 >  # If we are using Cray Fortran then delete quotes.
4819 >  # Use "\"" instead of '"' for font-lock-mode.
4820 >  # FIXME: a more general fix for quoted arguments with spaces?
4821 >  *cft90*)
4822 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4823 > esac
4824 >
4825 >
4826 >  # look for -l* and *.a constructs in the output
4827 >  for ac_arg in $ac_fc_v_output; do
4828 >     case $ac_arg in
4829 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4830 >          ac_cv_prog_fc_v=$ac_verb
4831 >          break 2 ;;
4832 >     esac
4833 >  done
4834 > done
4835 > if test -z "$ac_cv_prog_fc_v"; then
4836 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4837 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4838 > fi
4839 > else
4840 >  echo "$as_me: failed program was:" >&5
4841 > sed 's/^/| /' conftest.$ac_ext >&5
4842 >
4843 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4844 > echo "$as_me: WARNING: compilation failed" >&2;}
4845 > fi
4846 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4847 >
4848 > fi
4849 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4850 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4851 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4852 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4853 > if test "${ac_cv_fc_libs+set}" = set; then
4854 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4855 > else
4856 >  if test "x$FCLIBS" != "x"; then
4857 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4858 > else
4859 >
4860 > cat >conftest.$ac_ext <<_ACEOF
4861 >      program main
4862 >
4863 >      end
4864 > _ACEOF
4865 >
4866 > # Compile and link our simple test program by passing a flag (argument
4867 > # 1 to this macro) to the Fortran compiler in order to get
4868 > # "verbose" output that we can then parse for the Fortran linker
4869 > # flags.
4870 > ac_save_FFLAGS=$FCFLAGS
4871 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4872 > (eval echo $as_me:4872: \"$ac_link\") >&5
4873 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4874 > echo "$ac_fc_v_output" >&5
4875 > FCFLAGS=$ac_save_FFLAGS
4876 >
4877 > rm -f conftest*
4878 >
4879 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4880 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4881 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4882 > ac_fc_v_output="`echo $ac_fc_v_output |
4883 >        grep 'LPATH is:' |
4884 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4885 >
4886 > case $ac_fc_v_output in
4887 >  # If we are using xlf then replace all the commas with spaces.
4888 >  *xlfentry*)
4889 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4890 >
4891 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4892 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4893 >  *mGLOB_options_string*)
4894 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4895 >
4896 >  # If we are using Cray Fortran then delete quotes.
4897 >  # Use "\"" instead of '"' for font-lock-mode.
4898 >  # FIXME: a more general fix for quoted arguments with spaces?
4899 >  *cft90*)
4900 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4901 > esac
4902 >
4903 >
4904 >
4905 > ac_cv_fc_libs=
4906 >
4907 > # Save positional arguments (if any)
4908 > ac_save_positional="$@"
4909 >
4910 > set X $ac_fc_v_output
4911 > while test $# != 1; do
4912 >  shift
4913 >  ac_arg=$1
4914 >  case $ac_arg in
4915 >        [\\/]*.a | ?:[\\/]*.a)
4916 >            ac_exists=false
4917 >  for ac_i in $ac_cv_fc_libs; do
4918 >    if test x"$ac_arg" = x"$ac_i"; then
4919 >      ac_exists=true
4920 >      break
4921 >    fi
4922 >  done
4923 >
4924 >  if test x"$ac_exists" = xtrue; then
4925 >  :
4926 > else
4927 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4928 > fi
4929 >
4930 >          ;;
4931 >        -bI:*)
4932 >            ac_exists=false
4933 >  for ac_i in $ac_cv_fc_libs; do
4934 >    if test x"$ac_arg" = x"$ac_i"; then
4935 >      ac_exists=true
4936 >      break
4937 >    fi
4938 >  done
4939 >
4940 >  if test x"$ac_exists" = xtrue; then
4941 >  :
4942 > else
4943 >  if test "$ac_compiler_gnu" = yes; then
4944 >  for ac_link_opt in $ac_arg; do
4945 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4946 >  done
4947 > else
4948 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4949 > fi
4950 > fi
4951 >
4952 >          ;;
4953 >          # Ignore these flags.
4954 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4955 >          ;;
4956 >        -lkernel32)
4957 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4958 >          ;;
4959 >        -[LRuY])
4960 >          # These flags, when seen by themselves, take an argument.
4961 >          # We remove the space between option and argument and re-iterate
4962 >          # unless we find an empty arg or a new option (starting with -)
4963 >          case $2 in
4964 >             "" | -*);;
4965 >             *)
4966 >                ac_arg="$ac_arg$2"
4967 >                shift; shift
4968 >                set X $ac_arg "$@"
4969 >                ;;
4970 >          esac
4971 >          ;;
4972 >        -YP,*)
4973 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4974 >              ac_exists=false
4975 >  for ac_i in $ac_cv_fc_libs; do
4976 >    if test x"$ac_j" = x"$ac_i"; then
4977 >      ac_exists=true
4978 >      break
4979 >    fi
4980 >  done
4981 >
4982 >  if test x"$ac_exists" = xtrue; then
4983 >  :
4984 > else
4985 >  ac_arg="$ac_arg $ac_j"
4986 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4987 > fi
4988 >
4989 >          done
4990 >          ;;
4991 >        -[lLR]*)
4992 >            ac_exists=false
4993 >  for ac_i in $ac_cv_fc_libs; do
4994 >    if test x"$ac_arg" = x"$ac_i"; then
4995 >      ac_exists=true
4996 >      break
4997 >    fi
4998 >  done
4999 >
5000 >  if test x"$ac_exists" = xtrue; then
5001 >  :
5002 > else
5003 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5004 > fi
5005 >
5006 >          ;;
5007 >          # Ignore everything else.
5008 >  esac
5009 > done
5010 > # restore positional arguments
5011 > set X $ac_save_positional; shift
5012 >
5013 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5014 > # then we insist that the "run path" must be an absolute path (i.e. it
5015 > # must begin with a "/").
5016 > case `(uname -sr) 2>/dev/null` in
5017 >   "SunOS 5"*)
5018 >      ac_ld_run_path=`echo $ac_fc_v_output |
5019 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5020 >      test "x$ac_ld_run_path" != x &&
5021 >        if test "$ac_compiler_gnu" = yes; then
5022 >  for ac_link_opt in $ac_ld_run_path; do
5023 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5024 >  done
5025 > else
5026 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5027 > fi
5028 >      ;;
5029 > esac
5030 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5031 >
5032 > fi
5033 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5034 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5035 > FCLIBS="$ac_cv_fc_libs"
5036 >
5037 >
5038 > ac_ext=${FC_SRCEXT-f}
5039 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5040 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5041 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5042 >
5043 >
5044 >
5045 > echo "$as_me:$LINENO: checking for module suffix" >&5
5046 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5047 > rm -f conftest*
5048 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5049 > rm -f work*
5050 > cat >conftest.$ac_ext <<EOF
5051 >        module conftest
5052 >        integer n
5053 >        parameter (n=1)
5054 >        end module conftest
5055 > EOF
5056 > # SGI and absoft compilers generates module name in upper case!
5057 > testname="conftest"
5058 > modcase="lower"
5059 > if (eval $ac_compile) 2>/dev/null ; then
5060 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5061 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5062 >    if test -z "$MOD" ; then
5063 >        MOD=`ls CONFTEST* 2>/dev/null \
5064 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5065 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5066 >        if test -n "$MOD" ; then
5067 >            testname="CONFTEST"
5068 >            modcase="upper"
5069 >        fi
5070 >    fi
5071 >    if test -z "$MOD" ; then
5072 >        echo "$as_me:$LINENO: result: unknown" >&5
5073 > echo "${ECHO_T}unknown" >&6
5074 >        # Use mod if we can't figure it out
5075 >        MOD="mod"
5076 >    else
5077 >        echo "$as_me:$LINENO: result: $MOD" >&5
5078 > echo "${ECHO_T}$MOD" >&6
5079 >    fi
5080 >    if test -s work.pcl ; then
5081 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5082 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5083 >    fi
5084 > else
5085 >    echo "$as_me:$LINENO: result: unknown" >&5
5086 > echo "${ECHO_T}unknown" >&6
5087 > fi
5088 >
5089 >
5090 >
5091 >
5092 >
5093 > # Check for module include path (some use -I, some (Solaris) use -M, some
5094 > # (absoft) use -p).
5095 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5096 > # specified, work.pcl and work.pc are created.  However, if you specify
5097 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5098 > # Use the module made above
5099 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5100 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5101 > rm -f conftest*
5102 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5103 > rm -f work*
5104 > cat >conftest.$ac_ext <<EOF
5105 >        module conftest
5106 >        integer n
5107 >        parameter (n=1)
5108 >        end module conftest
5109 > EOF
5110 > # SGI and absoft compilers generates module name in upper case!
5111 > testname="conftest"
5112 > if (eval $ac_compile) 2>/dev/null ; then
5113 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5114 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5115 >   if test -n "$mod" ; then
5116 >      testname="CONFTEST"
5117 >   fi
5118 >   madedir=0
5119 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5120 >   cp $testname.$MOD conf
5121 >   rm -f conftest* CONFTEST*
5122 >   cat >conftest1.$ac_ext <<EOF
5123 >        program main
5124 >        use conftest
5125 >        print *, n
5126 >        end
5127 > EOF
5128 >   F90_WORK_FILES_ARG=""
5129 >   F90MODINCSPEC=""
5130 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5131 >       MODDIRFLAG="-I"
5132 >       F90MODINCSPEC="-I<dir>"
5133 >       echo "$as_me:$LINENO: result: -I" >&5
5134 > echo "${ECHO_T}-I" >&6
5135 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5136 >       MODDIRFLAG="-M"
5137 >       F90MODINCSPEC="-M<dir>"
5138 >       echo "$as_me:$LINENO: result: -M" >&5
5139 > echo "${ECHO_T}-M" >&6
5140 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5141 >       MODDIRFLAG="-p"
5142 >       F90MODINCSPEC="-p<dir>"
5143 >       echo "$as_me:$LINENO: result: -p" >&5
5144 > echo "${ECHO_T}-p" >&6
5145 >   elif test -s work.pc ; then
5146 >        cp work.pc conf/mpimod.pc
5147 >        echo "mpimod.pc" > conf/mpimod.pcl
5148 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5149 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5150 >            MODDIRFLAG='-cl,mpimod.pcl'
5151 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5152 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5153 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5154 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5155 >
5156 >        else
5157 >            # The version of the Intel compiler that I have refuses to let
5158 >            # you put the "work catalog" list anywhere but the current
5159 >            # directory. For example, you cannot in
5160 >         :
5161 >        fi
5162 >   fi
5163 >   if test -z "MODDIRFLAG" ; then
5164 >       echo "$as_me:$LINENO: result: unknown" >&5
5165 > echo "${ECHO_T}unknown" >&6
5166 >   fi
5167 >
5168 >
5169 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5170 >   if test $madedir = 1 ; then rmdir conf ; fi
5171 > fi
5172 >
5173 >
5174 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5175 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5176 > if test "${ac_cv_f90_module_names+set}" = set; then
5177 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5178 > else
5179 >  ac_ext=${FC_SRCEXT-f}
5180 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5181 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5182 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5183 >
5184 > # carry out the test in a new directory, so that we don't miss anything
5185 > mkdir conftest
5186 > cd conftest
5187 > cat >conftest.$ac_ext <<_ACEOF
5188 > MODULE Bar
5189 > END MODULE Bar
5190 > _ACEOF
5191 > rm -f conftest.$ac_objext
5192 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5193 >  (eval $ac_compile) 2>conftest.er1
5194 >  ac_status=$?
5195 >  grep -v '^ *+' conftest.er1 >conftest.err
5196 >  rm -f conftest.er1
5197 >  cat conftest.err >&5
5198 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5199 >  (exit $ac_status); } &&
5200 >         { ac_try='test -z "$ac_fc_werror_flag"
5201 >                         || test ! -s conftest.err'
5202 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5203 >  (eval $ac_try) 2>&5
5204 >  ac_status=$?
5205 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5206 >  (exit $ac_status); }; } &&
5207 >         { ac_try='test -s conftest.$ac_objext'
5208 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5209 >  (eval $ac_try) 2>&5
5210 >  ac_status=$?
5211 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5212 >  (exit $ac_status); }; }; then
5213 >  ac_cv_f90_module_names=
5214 > ac_file_list=*
5215 > for ac_file in $ac_file_list; do
5216 >   case $ac_file in
5217 >      # don't care for original source and object files
5218 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5219 >          :
5220 >          ;;
5221 >      # look for new files derived from the file name
5222 >      *conftest*)
5223 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5224 >            ac_exists=false
5225 >  for ac_i in $ac_cv_f90_module_names; do
5226 >    if test x"$ac_pat" = x"$ac_i"; then
5227 >      ac_exists=true
5228 >      break
5229 >    fi
5230 >  done
5231 >
5232 >  if test x"$ac_exists" = xtrue; then
5233 >  :
5234 > else
5235 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5236 > fi
5237 >
5238 >          ;;
5239 >      # look for new files derived from the module name,
5240 >      # with different case translation schemes
5241 >      *Bar*)
5242 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5243 >            ac_exists=false
5244 >  for ac_i in $ac_cv_f90_module_names; do
5245 >    if test x"$ac_pat" = x"$ac_i"; then
5246 >      ac_exists=true
5247 >      break
5248 >    fi
5249 >  done
5250 >
5251 >  if test x"$ac_exists" = xtrue; then
5252 >  :
5253 > else
5254 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5255 > fi
5256 >
5257 >          ;;
5258 >      *bar*)
5259 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5260 >            ac_exists=false
5261 >  for ac_i in $ac_cv_f90_module_names; do
5262 >    if test x"$ac_pat" = x"$ac_i"; then
5263 >      ac_exists=true
5264 >      break
5265 >    fi
5266 >  done
5267 >
5268 >  if test x"$ac_exists" = xtrue; then
5269 >  :
5270 > else
5271 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5272 > fi
5273 >
5274 >          ;;
5275 >      *BAR*)
5276 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5277 >            ac_exists=false
5278 >  for ac_i in $ac_cv_f90_module_names; do
5279 >    if test x"$ac_pat" = x"$ac_i"; then
5280 >      ac_exists=true
5281 >      break
5282 >    fi
5283 >  done
5284 >
5285 >  if test x"$ac_exists" = xtrue; then
5286 >  :
5287 > else
5288 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5289 > fi
5290 >
5291 >          ;;
5292 >       # Other files - we have no idea how they are generated
5293 >       *)
5294 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5295 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5296 >          ;;
5297 >   esac
5298 > done
5299 > if test "x$ac_cv_f90_module_names" = "x"; then
5300 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5301 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5302 > fi
5303 >
5304 > else
5305 >  echo "$as_me: failed program was:" >&5
5306 > sed 's/^/| /' conftest.$ac_ext >&5
5307 >
5308 > ac_cv_f90_module_names=
5309 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5310 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5311 > fi
5312 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5313 > cd ..
5314 > # cleanup
5315 > rm -rf conftest
5316 > ac_ext=${FC_SRCEXT-f}
5317 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5318 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5319 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5320 >
5321 > fi
5322 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5323 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5324 >
5325 > # We now generate a shell script that will help us to figure out the correct
5326 > # module file names, using the value of ac_cv_f90_module_names
5327 >
5328 > echo "Generating shell script modnam"
5329 >
5330 > cat > scripts/modnam << EOF
5331 > #! /bin/sh
5332 > # This script is auto-generated by configure
5333 > #
5334 > usage="\\
5335 > Usage: \$0 [FILES]
5336 >
5337 > [FILES] are Fortran 90 source files.
5338 > The output is a list of module file names that the Fortran 90 compiler
5339 > generates when compiling [FILES]."
5340 >
5341 > list=
5342 > empty=
5343 >
5344 > if test \$# -eq 0; then
5345 >   echo "\$usage"; exit 0
5346 > fi
5347 >
5348 > while test \$# != 0; do
5349 >
5350 >  file=\$1
5351 >  shift
5352 >
5353 > # strip suffix
5354 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5355 >
5356 >  test ! -f \$file && continue
5357 >
5358 > # Look for module definitions and transform them to upper / lower case
5359 >  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/'\`
5360 >  upper=\`echo \$mods | tr a-z A-Z\`
5361 >  lower=\`echo \$mods | tr A-Z a-z\`
5362 >
5363 > # Here, the patterns for generating module file names were inserted by configure
5364 >  for trans in $ac_cv_f90_module_names; do
5365 >
5366 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5367 >    var=empty
5368 >    case \$pat in
5369 >       %MODULE%)
5370 >          var=upper ;;
5371 >       %Module%)
5372 >          var=mods ;;
5373 >       %module%)
5374 >          var=lower ;;
5375 >       %FILE%)
5376 >          test -n "\$mods" && var=base ;;
5377 >    esac
5378 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5379 >    list="\$list \$new"
5380 >  done
5381 > done
5382 >
5383 > echo \$list
5384 > # end of configure-generated script
5385 > EOF
5386 > chmod 755 scripts/modnam
5387 >
5388 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5389 > F90_MODULE_NAMES=empty
5390 > case $pat in
5391 >       %MODULE%)
5392 >          F90_MODULE_NAMES=UPPER ;;
5393 >       %Module%)
5394 >          F90_MODULE_NAMES=Mixed ;;
5395 >       %module%)
5396 >          F90_MODULE_NAMES=lower ;;
5397 >       *)
5398 >          F90_MODULE_NAMES=unknown ;;
5399 > esac
5400 >
5401 > ac_ext=c
5402 > ac_cpp='$CPP $CPPFLAGS'
5403 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5404 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5405 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5406 >
5407 >
5408 > ac_ext=c
5409 > ac_cpp='$CPP $CPPFLAGS'
5410 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5411 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5412 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5413 >
5414 >
5415 >
5416 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5417 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5418 > if test "${ac_cv_lib_m_asin+set}" = set; then
5419 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5420 > else
5421 >  ac_check_lib_save_LIBS=$LIBS
5422 > LIBS="-lm  $LIBS"
5423 > cat >conftest.$ac_ext <<_ACEOF
5424 > /* confdefs.h.  */
5425 > _ACEOF
5426 > cat confdefs.h >>conftest.$ac_ext
5427 > cat >>conftest.$ac_ext <<_ACEOF
5428 > /* end confdefs.h.  */
5429 >
5430 > /* Override any gcc2 internal prototype to avoid an error.  */
5431 > #ifdef __cplusplus
5432 > extern "C"
5433 > #endif
5434 > /* We use char because int might match the return type of a gcc2
5435 >   builtin and then its argument prototype would still apply.  */
5436 > char asin ();
5437 > #ifdef FC_DUMMY_MAIN
5438 > #ifndef FC_DUMMY_MAIN_EQ_F77
5439 > #  ifdef __cplusplus
5440 >     extern "C"
5441 > #  endif
5442 >   int FC_DUMMY_MAIN() { return 1; }
5443 > #endif
5444 > #endif
5445 > int
5446 > main ()
5447 > {
5448 > asin ();
5449 >  ;
5450 >  return 0;
5451 > }
5452 > _ACEOF
5453 > rm -f conftest.$ac_objext conftest$ac_exeext
5454 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5455 >  (eval $ac_link) 2>conftest.er1
5456 >  ac_status=$?
5457 >  grep -v '^ *+' conftest.er1 >conftest.err
5458 >  rm -f conftest.er1
5459 >  cat conftest.err >&5
5460 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5461 >  (exit $ac_status); } &&
5462 >         { ac_try='test -z "$ac_c_werror_flag"
5463 >                         || test ! -s conftest.err'
5464 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5465 >  (eval $ac_try) 2>&5
5466 >  ac_status=$?
5467 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5468 >  (exit $ac_status); }; } &&
5469 >         { ac_try='test -s conftest$ac_exeext'
5470 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5471 >  (eval $ac_try) 2>&5
5472 >  ac_status=$?
5473 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5474 >  (exit $ac_status); }; }; then
5475 >  ac_cv_lib_m_asin=yes
5476 > else
5477 >  echo "$as_me: failed program was:" >&5
5478 > sed 's/^/| /' conftest.$ac_ext >&5
5479 >
5480 > ac_cv_lib_m_asin=no
5481 > fi
5482 > rm -f conftest.err conftest.$ac_objext \
5483 >      conftest$ac_exeext conftest.$ac_ext
5484 > LIBS=$ac_check_lib_save_LIBS
5485 > fi
5486 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5487 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5488 > if test $ac_cv_lib_m_asin = yes; then
5489 >  cat >>confdefs.h <<_ACEOF
5490 > #define HAVE_LIBM 1
5491 > _ACEOF
5492 >
5493 >  LIBS="-lm $LIBS"
5494 >
5495 > else
5496 >  exit
5497 > fi
5498 >
5499 >
5500 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5501 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5502 > if test "${ac_cv_header_stdc+set}" = set; then
5503 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5504 > else
5505 >  cat >conftest.$ac_ext <<_ACEOF
5506 > /* confdefs.h.  */
5507 > _ACEOF
5508 > cat confdefs.h >>conftest.$ac_ext
5509 > cat >>conftest.$ac_ext <<_ACEOF
5510 > /* end confdefs.h.  */
5511 > #include <stdlib.h>
5512 > #include <stdarg.h>
5513 > #include <string.h>
5514 > #include <float.h>
5515 >
5516 > #ifdef FC_DUMMY_MAIN
5517 > #ifndef FC_DUMMY_MAIN_EQ_F77
5518 > #  ifdef __cplusplus
5519 >     extern "C"
5520 > #  endif
5521 >   int FC_DUMMY_MAIN() { return 1; }
5522 > #endif
5523 > #endif
5524 > int
5525 > main ()
5526 > {
5527 >
5528 >  ;
5529 >  return 0;
5530 > }
5531 > _ACEOF
5532 > rm -f conftest.$ac_objext
5533 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5534 >  (eval $ac_compile) 2>conftest.er1
5535 >  ac_status=$?
5536 >  grep -v '^ *+' conftest.er1 >conftest.err
5537 >  rm -f conftest.er1
5538 >  cat conftest.err >&5
5539 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5540 >  (exit $ac_status); } &&
5541 >         { ac_try='test -z "$ac_c_werror_flag"
5542 >                         || test ! -s conftest.err'
5543 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5544 >  (eval $ac_try) 2>&5
5545 >  ac_status=$?
5546 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5547 >  (exit $ac_status); }; } &&
5548 >         { ac_try='test -s conftest.$ac_objext'
5549 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5550 >  (eval $ac_try) 2>&5
5551 >  ac_status=$?
5552 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5553 >  (exit $ac_status); }; }; then
5554 >  ac_cv_header_stdc=yes
5555 > else
5556 >  echo "$as_me: failed program was:" >&5
5557 > sed 's/^/| /' conftest.$ac_ext >&5
5558 >
5559 > ac_cv_header_stdc=no
5560 > fi
5561 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5562 >
5563 > if test $ac_cv_header_stdc = yes; then
5564 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5565 >  cat >conftest.$ac_ext <<_ACEOF
5566 > /* confdefs.h.  */
5567 > _ACEOF
5568 > cat confdefs.h >>conftest.$ac_ext
5569 > cat >>conftest.$ac_ext <<_ACEOF
5570 > /* end confdefs.h.  */
5571 > #include <string.h>
5572 >
5573 > _ACEOF
5574 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5575 >  $EGREP "memchr" >/dev/null 2>&1; then
5576 >  :
5577 > else
5578 >  ac_cv_header_stdc=no
5579 > fi
5580 > rm -f conftest*
5581 >
5582 > fi
5583 >
5584 > if test $ac_cv_header_stdc = yes; then
5585 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5586 >  cat >conftest.$ac_ext <<_ACEOF
5587 > /* confdefs.h.  */
5588 > _ACEOF
5589 > cat confdefs.h >>conftest.$ac_ext
5590 > cat >>conftest.$ac_ext <<_ACEOF
5591 > /* end confdefs.h.  */
5592 > #include <stdlib.h>
5593 >
5594 > _ACEOF
5595 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5596 >  $EGREP "free" >/dev/null 2>&1; then
5597 >  :
5598 > else
5599 >  ac_cv_header_stdc=no
5600 > fi
5601 > rm -f conftest*
5602 >
5603 > fi
5604 >
5605 > if test $ac_cv_header_stdc = yes; then
5606 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5607 >  if test "$cross_compiling" = yes; then
5608 >  :
5609 > else
5610 >  cat >conftest.$ac_ext <<_ACEOF
5611 > /* confdefs.h.  */
5612 > _ACEOF
5613 > cat confdefs.h >>conftest.$ac_ext
5614 > cat >>conftest.$ac_ext <<_ACEOF
5615 > /* end confdefs.h.  */
5616 > #include <ctype.h>
5617 > #if ((' ' & 0x0FF) == 0x020)
5618 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5619 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5620 > #else
5621 > # define ISLOWER(c) \
5622 >                   (('a' <= (c) && (c) <= 'i') \
5623 >                     || ('j' <= (c) && (c) <= 'r') \
5624 >                     || ('s' <= (c) && (c) <= 'z'))
5625 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5626 > #endif
5627 >
5628 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5629 > int
5630 > main ()
5631 > {
5632 >  int i;
5633 >  for (i = 0; i < 256; i++)
5634 >    if (XOR (islower (i), ISLOWER (i))
5635 >        || toupper (i) != TOUPPER (i))
5636 >      exit(2);
5637 >  exit (0);
5638 > }
5639 > _ACEOF
5640 > rm -f conftest$ac_exeext
5641 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5642 >  (eval $ac_link) 2>&5
5643 >  ac_status=$?
5644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5645 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5646 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5647 >  (eval $ac_try) 2>&5
5648 >  ac_status=$?
5649 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5650 >  (exit $ac_status); }; }; then
5651 >  :
5652 > else
5653 >  echo "$as_me: program exited with status $ac_status" >&5
5654 > echo "$as_me: failed program was:" >&5
5655 > sed 's/^/| /' conftest.$ac_ext >&5
5656 >
5657 > ( exit $ac_status )
5658 > ac_cv_header_stdc=no
5659 > fi
5660 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5661 > fi
5662 > fi
5663 > fi
5664 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5665 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5666 > if test $ac_cv_header_stdc = yes; then
5667 >
5668 > cat >>confdefs.h <<\_ACEOF
5669 > #define STDC_HEADERS 1
5670 > _ACEOF
5671 >
5672 > fi
5673 >
5674 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5675 >
5676 >
5677 >
5678 >
5679 >
5680 >
5681 >
5682 >
5683 >
5684 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5685 >                  inttypes.h stdint.h unistd.h
5686 > do
5687 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5688 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5689 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5690 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5691 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5692 > else
5693 >  cat >conftest.$ac_ext <<_ACEOF
5694 > /* confdefs.h.  */
5695 > _ACEOF
5696 > cat confdefs.h >>conftest.$ac_ext
5697 > cat >>conftest.$ac_ext <<_ACEOF
5698 > /* end confdefs.h.  */
5699 > $ac_includes_default
5700 >
5701 > #include <$ac_header>
5702 > _ACEOF
5703 > rm -f conftest.$ac_objext
5704 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5705 >  (eval $ac_compile) 2>conftest.er1
5706 >  ac_status=$?
5707 >  grep -v '^ *+' conftest.er1 >conftest.err
5708 >  rm -f conftest.er1
5709 >  cat conftest.err >&5
5710 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5711 >  (exit $ac_status); } &&
5712 >         { ac_try='test -z "$ac_c_werror_flag"
5713 >                         || test ! -s conftest.err'
5714 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5715 >  (eval $ac_try) 2>&5
5716 >  ac_status=$?
5717 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5718 >  (exit $ac_status); }; } &&
5719 >         { ac_try='test -s conftest.$ac_objext'
5720 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5721 >  (eval $ac_try) 2>&5
5722 >  ac_status=$?
5723 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5724 >  (exit $ac_status); }; }; then
5725 >  eval "$as_ac_Header=yes"
5726 > else
5727 >  echo "$as_me: failed program was:" >&5
5728 > sed 's/^/| /' conftest.$ac_ext >&5
5729 >
5730 > eval "$as_ac_Header=no"
5731 > fi
5732 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5733 > fi
5734 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5735 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5736 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5737 >  cat >>confdefs.h <<_ACEOF
5738 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5739 > _ACEOF
5740 >
5741 > fi
5742 >
5743 > done
5744 >
5745 >
5746 > #
5747 > # Handle user hints
5748 > #
5749 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5750 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5751 >
5752 > # Check whether --with-zlib or --without-zlib was given.
5753 > if test "${with_zlib+set}" = set; then
5754 >  withval="$with_zlib"
5755 >  if test "$withval" != no ; then
5756 >  echo "$as_me:$LINENO: result: yes" >&5
5757 > echo "${ECHO_T}yes" >&6
5758 >  if test -d "$withval"
5759 >  then
5760 >    ZLIB_HOME="$withval"
5761 >  else
5762 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5763 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5764 >  fi
5765 > else
5766 >  echo "$as_me:$LINENO: result: no" >&5
5767 > echo "${ECHO_T}no" >&6
5768 > fi
5769 > fi;
5770 >
5771 > ZLIB_HOME=/usr/local
5772 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5773 > then
5774 >        ZLIB_HOME=/usr
5775 > fi
5776 >
5777 > #
5778 > # Locate zlib, if wanted
5779 > #
5780 > if test -n "${ZLIB_HOME}"
5781 > then
5782 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5783 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5784 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5785 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5786 >
5787 >
5788 >        ac_ext=c
5789 > ac_cpp='$CPP $CPPFLAGS'
5790 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5791 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5792 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5793 >
5794 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5795 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5796 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5797 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5798 > else
5799 >  ac_check_lib_save_LIBS=$LIBS
5800 > LIBS="-lz  $LIBS"
5801 > cat >conftest.$ac_ext <<_ACEOF
5802 > /* confdefs.h.  */
5803 > _ACEOF
5804 > cat confdefs.h >>conftest.$ac_ext
5805 > cat >>conftest.$ac_ext <<_ACEOF
5806 > /* end confdefs.h.  */
5807 >
5808 > /* Override any gcc2 internal prototype to avoid an error.  */
5809 > #ifdef __cplusplus
5810 > extern "C"
5811 > #endif
5812 > /* We use char because int might match the return type of a gcc2
5813 >   builtin and then its argument prototype would still apply.  */
5814 > char inflateEnd ();
5815 > #ifdef FC_DUMMY_MAIN
5816 > #ifndef FC_DUMMY_MAIN_EQ_F77
5817 > #  ifdef __cplusplus
5818 >     extern "C"
5819 > #  endif
5820 >   int FC_DUMMY_MAIN() { return 1; }
5821 > #endif
5822 > #endif
5823 > int
5824 > main ()
5825 > {
5826 > inflateEnd ();
5827 >  ;
5828 >  return 0;
5829 > }
5830 > _ACEOF
5831 > rm -f conftest.$ac_objext conftest$ac_exeext
5832 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5833 >  (eval $ac_link) 2>conftest.er1
5834 >  ac_status=$?
5835 >  grep -v '^ *+' conftest.er1 >conftest.err
5836 >  rm -f conftest.er1
5837 >  cat conftest.err >&5
5838 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5839 >  (exit $ac_status); } &&
5840 >         { ac_try='test -z "$ac_c_werror_flag"
5841 >                         || test ! -s conftest.err'
5842 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5843 >  (eval $ac_try) 2>&5
5844 >  ac_status=$?
5845 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5846 >  (exit $ac_status); }; } &&
5847 >         { ac_try='test -s conftest$ac_exeext'
5848 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5849 >  (eval $ac_try) 2>&5
5850 >  ac_status=$?
5851 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5852 >  (exit $ac_status); }; }; then
5853 >  ac_cv_lib_z_inflateEnd=yes
5854 > else
5855 >  echo "$as_me: failed program was:" >&5
5856 > sed 's/^/| /' conftest.$ac_ext >&5
5857 >
5858 > ac_cv_lib_z_inflateEnd=no
5859 > fi
5860 > rm -f conftest.err conftest.$ac_objext \
5861 >      conftest$ac_exeext conftest.$ac_ext
5862 > LIBS=$ac_check_lib_save_LIBS
5863 > fi
5864 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5865 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5866 > if test $ac_cv_lib_z_inflateEnd = yes; then
5867 >  zlib_cv_libz=yes
5868 > else
5869 >  zlib_cv_libz=no
5870 > fi
5871 >
5872 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5873 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5874 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5875 > if test "${ac_cv_header_zlib_h+set}" = set; then
5876 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5877 > fi
5878 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5879 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5880 > else
5881 >  # Is the header compilable?
5882 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5883 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5884 > cat >conftest.$ac_ext <<_ACEOF
5885 > /* confdefs.h.  */
5886 > _ACEOF
5887 > cat confdefs.h >>conftest.$ac_ext
5888 > cat >>conftest.$ac_ext <<_ACEOF
5889 > /* end confdefs.h.  */
5890 > $ac_includes_default
5891 > #include <zlib.h>
5892 > _ACEOF
5893 > rm -f conftest.$ac_objext
5894 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5895 >  (eval $ac_compile) 2>conftest.er1
5896 >  ac_status=$?
5897 >  grep -v '^ *+' conftest.er1 >conftest.err
5898 >  rm -f conftest.er1
5899 >  cat conftest.err >&5
5900 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5901 >  (exit $ac_status); } &&
5902 >         { ac_try='test -z "$ac_c_werror_flag"
5903 >                         || test ! -s conftest.err'
5904 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5905 >  (eval $ac_try) 2>&5
5906 >  ac_status=$?
5907 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5908 >  (exit $ac_status); }; } &&
5909 >         { ac_try='test -s conftest.$ac_objext'
5910 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5911 >  (eval $ac_try) 2>&5
5912 >  ac_status=$?
5913 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5914 >  (exit $ac_status); }; }; then
5915 >  ac_header_compiler=yes
5916 > else
5917 >  echo "$as_me: failed program was:" >&5
5918 > sed 's/^/| /' conftest.$ac_ext >&5
5919 >
5920 > ac_header_compiler=no
5921 > fi
5922 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5923 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5924 > echo "${ECHO_T}$ac_header_compiler" >&6
5925 >
5926 > # Is the header present?
5927 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5928 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5929 > cat >conftest.$ac_ext <<_ACEOF
5930 > /* confdefs.h.  */
5931 > _ACEOF
5932 > cat confdefs.h >>conftest.$ac_ext
5933 > cat >>conftest.$ac_ext <<_ACEOF
5934 > /* end confdefs.h.  */
5935 > #include <zlib.h>
5936 > _ACEOF
5937 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5938 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5939 >  ac_status=$?
5940 >  grep -v '^ *+' conftest.er1 >conftest.err
5941 >  rm -f conftest.er1
5942 >  cat conftest.err >&5
5943 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5944 >  (exit $ac_status); } >/dev/null; then
5945 >  if test -s conftest.err; then
5946 >    ac_cpp_err=$ac_c_preproc_warn_flag
5947 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5948 >  else
5949 >    ac_cpp_err=
5950 >  fi
5951 > else
5952 >  ac_cpp_err=yes
5953 > fi
5954 > if test -z "$ac_cpp_err"; then
5955 >  ac_header_preproc=yes
5956 > else
5957 >  echo "$as_me: failed program was:" >&5
5958 > sed 's/^/| /' conftest.$ac_ext >&5
5959 >
5960 >  ac_header_preproc=no
5961 > fi
5962 > rm -f conftest.err conftest.$ac_ext
5963 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5964 > echo "${ECHO_T}$ac_header_preproc" >&6
5965 >
5966 > # So?  What about this header?
5967 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5968 >  yes:no: )
5969 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5970 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5971 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5972 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5973 >    ac_header_preproc=yes
5974 >    ;;
5975 >  no:yes:* )
5976 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5977 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5978 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5979 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5980 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5981 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5982 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5983 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5984 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5985 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
5986 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
5987 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5988 >    (
5989 >      cat <<\_ASBOX
5990 > ## ------------------------------ ##
5991 > ## Report this to gezelter@nd.edu ##
5992 > ## ------------------------------ ##
5993 > _ASBOX
5994 >    ) |
5995 >      sed "s/^/$as_me: WARNING:     /" >&2
5996 >    ;;
5997 > esac
5998 > echo "$as_me:$LINENO: checking for zlib.h" >&5
5999 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6000 > if test "${ac_cv_header_zlib_h+set}" = set; then
6001 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6002 > else
6003 >  ac_cv_header_zlib_h=$ac_header_preproc
6004 > fi
6005 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6006 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6007 >
6008 > fi
6009 > if test $ac_cv_header_zlib_h = yes; then
6010 >  zlib_cv_zlib_h=yes
6011 > else
6012 >  zlib_cv_zlib_h=no
6013 > fi
6014 >
6015 >
6016 >        ac_ext=c
6017 > ac_cpp='$CPP $CPPFLAGS'
6018 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6019 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6020 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6021 >
6022 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6023 >        then
6024 >                #
6025 >                # If both library and header were found, use them
6026 >                #
6027 >
6028 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6029 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6030 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6031 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6032 > else
6033 >  ac_check_lib_save_LIBS=$LIBS
6034 > LIBS="-lz  $LIBS"
6035 > cat >conftest.$ac_ext <<_ACEOF
6036 > /* confdefs.h.  */
6037 > _ACEOF
6038 > cat confdefs.h >>conftest.$ac_ext
6039 > cat >>conftest.$ac_ext <<_ACEOF
6040 > /* end confdefs.h.  */
6041 >
6042 > /* Override any gcc2 internal prototype to avoid an error.  */
6043 > #ifdef __cplusplus
6044 > extern "C"
6045 > #endif
6046 > /* We use char because int might match the return type of a gcc2
6047 >   builtin and then its argument prototype would still apply.  */
6048 > char inflateEnd ();
6049 > #ifdef FC_DUMMY_MAIN
6050 > #ifndef FC_DUMMY_MAIN_EQ_F77
6051 > #  ifdef __cplusplus
6052 >     extern "C"
6053 > #  endif
6054 >   int FC_DUMMY_MAIN() { return 1; }
6055 > #endif
6056 > #endif
6057 > int
6058 > main ()
6059 > {
6060 > inflateEnd ();
6061 >  ;
6062 >  return 0;
6063 > }
6064 > _ACEOF
6065 > rm -f conftest.$ac_objext conftest$ac_exeext
6066 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6067 >  (eval $ac_link) 2>conftest.er1
6068 >  ac_status=$?
6069 >  grep -v '^ *+' conftest.er1 >conftest.err
6070 >  rm -f conftest.er1
6071 >  cat conftest.err >&5
6072 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6073 >  (exit $ac_status); } &&
6074 >         { ac_try='test -z "$ac_c_werror_flag"
6075 >                         || test ! -s conftest.err'
6076 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6077 >  (eval $ac_try) 2>&5
6078 >  ac_status=$?
6079 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6080 >  (exit $ac_status); }; } &&
6081 >         { ac_try='test -s conftest$ac_exeext'
6082 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6083 >  (eval $ac_try) 2>&5
6084 >  ac_status=$?
6085 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6086 >  (exit $ac_status); }; }; then
6087 >  ac_cv_lib_z_inflateEnd=yes
6088 > else
6089 >  echo "$as_me: failed program was:" >&5
6090 > sed 's/^/| /' conftest.$ac_ext >&5
6091 >
6092 > ac_cv_lib_z_inflateEnd=no
6093 > fi
6094 > rm -f conftest.err conftest.$ac_objext \
6095 >      conftest$ac_exeext conftest.$ac_ext
6096 > LIBS=$ac_check_lib_save_LIBS
6097 > fi
6098 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6099 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6100 > if test $ac_cv_lib_z_inflateEnd = yes; then
6101 >  cat >>confdefs.h <<_ACEOF
6102 > #define HAVE_LIBZ 1
6103 > _ACEOF
6104 >
6105 >  LIBS="-lz $LIBS"
6106 >
6107 > fi
6108 >
6109 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6110 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6111 >                echo "$as_me:$LINENO: result: ok" >&5
6112 > echo "${ECHO_T}ok" >&6
6113 >        else
6114 >                #
6115 >                # If either header or library was not found, revert and bomb
6116 >                #
6117 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6118 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6119 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6120 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6121 >                echo "$as_me:$LINENO: result: failed" >&5
6122 > echo "${ECHO_T}failed" >&6
6123 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6124 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6125 >   { (exit 1); exit 1; }; }
6126 >        fi
6127 > fi
6128 >
6129 >
6130 >
6131 > # Checks for header files.
6132 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6133 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6134 > if test "${ac_cv_header_stdc+set}" = set; then
6135 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6136 > else
6137 >  cat >conftest.$ac_ext <<_ACEOF
6138 > /* confdefs.h.  */
6139 > _ACEOF
6140 > cat confdefs.h >>conftest.$ac_ext
6141 > cat >>conftest.$ac_ext <<_ACEOF
6142 > /* end confdefs.h.  */
6143 > #include <stdlib.h>
6144 > #include <stdarg.h>
6145 > #include <string.h>
6146 > #include <float.h>
6147 >
6148 > #ifdef FC_DUMMY_MAIN
6149 > #ifndef FC_DUMMY_MAIN_EQ_F77
6150 > #  ifdef __cplusplus
6151 >     extern "C"
6152 > #  endif
6153 >   int FC_DUMMY_MAIN() { return 1; }
6154 > #endif
6155 > #endif
6156 > int
6157 > main ()
6158 > {
6159 >
6160 >  ;
6161 >  return 0;
6162 > }
6163 > _ACEOF
6164 > rm -f conftest.$ac_objext
6165 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6166 >  (eval $ac_compile) 2>conftest.er1
6167 >  ac_status=$?
6168 >  grep -v '^ *+' conftest.er1 >conftest.err
6169 >  rm -f conftest.er1
6170 >  cat conftest.err >&5
6171 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6172 >  (exit $ac_status); } &&
6173 >         { ac_try='test -z "$ac_c_werror_flag"
6174 >                         || test ! -s conftest.err'
6175 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6176 >  (eval $ac_try) 2>&5
6177 >  ac_status=$?
6178 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6179 >  (exit $ac_status); }; } &&
6180 >         { ac_try='test -s conftest.$ac_objext'
6181 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6182 >  (eval $ac_try) 2>&5
6183 >  ac_status=$?
6184 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6185 >  (exit $ac_status); }; }; then
6186 >  ac_cv_header_stdc=yes
6187 > else
6188 >  echo "$as_me: failed program was:" >&5
6189 > sed 's/^/| /' conftest.$ac_ext >&5
6190 >
6191 > ac_cv_header_stdc=no
6192 > fi
6193 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6194 >
6195 > if test $ac_cv_header_stdc = yes; then
6196 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6197 >  cat >conftest.$ac_ext <<_ACEOF
6198 > /* confdefs.h.  */
6199 > _ACEOF
6200 > cat confdefs.h >>conftest.$ac_ext
6201 > cat >>conftest.$ac_ext <<_ACEOF
6202 > /* end confdefs.h.  */
6203 > #include <string.h>
6204 >
6205 > _ACEOF
6206 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6207 >  $EGREP "memchr" >/dev/null 2>&1; then
6208 >  :
6209 > else
6210 >  ac_cv_header_stdc=no
6211 > fi
6212 > rm -f conftest*
6213 >
6214 > fi
6215 >
6216 > if test $ac_cv_header_stdc = yes; then
6217 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6218 >  cat >conftest.$ac_ext <<_ACEOF
6219 > /* confdefs.h.  */
6220 > _ACEOF
6221 > cat confdefs.h >>conftest.$ac_ext
6222 > cat >>conftest.$ac_ext <<_ACEOF
6223 > /* end confdefs.h.  */
6224 > #include <stdlib.h>
6225 >
6226 > _ACEOF
6227 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6228 >  $EGREP "free" >/dev/null 2>&1; then
6229 >  :
6230 > else
6231 >  ac_cv_header_stdc=no
6232 > fi
6233 > rm -f conftest*
6234 >
6235 > fi
6236 >
6237 > if test $ac_cv_header_stdc = yes; then
6238 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6239 >  if test "$cross_compiling" = yes; then
6240 >  :
6241 > else
6242 >  cat >conftest.$ac_ext <<_ACEOF
6243 > /* confdefs.h.  */
6244 > _ACEOF
6245 > cat confdefs.h >>conftest.$ac_ext
6246 > cat >>conftest.$ac_ext <<_ACEOF
6247 > /* end confdefs.h.  */
6248 > #include <ctype.h>
6249 > #if ((' ' & 0x0FF) == 0x020)
6250 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6251 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6252 > #else
6253 > # define ISLOWER(c) \
6254 >                   (('a' <= (c) && (c) <= 'i') \
6255 >                     || ('j' <= (c) && (c) <= 'r') \
6256 >                     || ('s' <= (c) && (c) <= 'z'))
6257 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6258 > #endif
6259 >
6260 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6261 > int
6262 > main ()
6263 > {
6264 >  int i;
6265 >  for (i = 0; i < 256; i++)
6266 >    if (XOR (islower (i), ISLOWER (i))
6267 >        || toupper (i) != TOUPPER (i))
6268 >      exit(2);
6269 >  exit (0);
6270 > }
6271 > _ACEOF
6272 > rm -f conftest$ac_exeext
6273 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6274 >  (eval $ac_link) 2>&5
6275 >  ac_status=$?
6276 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6277 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6278 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6279 >  (eval $ac_try) 2>&5
6280 >  ac_status=$?
6281 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6282 >  (exit $ac_status); }; }; then
6283 >  :
6284 > else
6285 >  echo "$as_me: program exited with status $ac_status" >&5
6286 > echo "$as_me: failed program was:" >&5
6287 > sed 's/^/| /' conftest.$ac_ext >&5
6288 >
6289 > ( exit $ac_status )
6290 > ac_cv_header_stdc=no
6291 > fi
6292 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6293 > fi
6294 > fi
6295 > fi
6296 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6297 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
6298 > if test $ac_cv_header_stdc = yes; then
6299 >
6300 > cat >>confdefs.h <<\_ACEOF
6301 > #define STDC_HEADERS 1
6302 > _ACEOF
6303 >
6304 > fi
6305 >
6306 >
6307 >
6308 >
6309 >
6310 >
6311 >
6312 >
6313 >
6314 >
6315 > for ac_header in libintl.h limits.h stddef.h stdlib.h string.h strings.h sys/param.h sys/time.h unistd.h
6316 > do
6317 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6318 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
6319 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
6320 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6321 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
6322 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6323 > fi
6324 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6325 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6326 > else
6327 >  # Is the header compilable?
6328 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
6329 > echo $ECHO_N "checking $ac_header 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 <$ac_header>
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 $ac_header presence" >&5
6374 > echo $ECHO_N "checking $ac_header 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 <$ac_header>
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: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6416 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6417 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6418 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6419 >    ac_header_preproc=yes
6420 >    ;;
6421 >  no:yes:* )
6422 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6423 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6424 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6425 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6426 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6427 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6428 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6429 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6430 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6431 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6432 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6433 > echo "$as_me: WARNING: $ac_header: 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 $ac_header" >&5
6445 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6446 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
6447 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6448 > else
6449 >  eval "$as_ac_Header=\$ac_header_preproc"
6450 > fi
6451 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6452 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6453 >
6454 > fi
6455 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
6456 >  cat >>confdefs.h <<_ACEOF
6457 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6458 > _ACEOF
6459 >
6460 > fi
6461 >
6462 > done
6463 >
6464 >
6465 >
6466 >
6467 >
6468 >
6469 >
6470 >
6471 >
6472 >
6473 >
6474 >
6475 >
6476 >
6477 >
6478 > for ac_header in stdio.h conio.h strstream.h iostream.h fstream.h math.h time.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
6479 > do
6480 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6481 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
6482 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
6483 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6484 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
6485 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6486 > fi
6487 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6488 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6489 > else
6490 >  # Is the header compilable?
6491 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
6492 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6493 > cat >conftest.$ac_ext <<_ACEOF
6494 > /* confdefs.h.  */
6495 > _ACEOF
6496 > cat confdefs.h >>conftest.$ac_ext
6497 > cat >>conftest.$ac_ext <<_ACEOF
6498 > /* end confdefs.h.  */
6499 > $ac_includes_default
6500 > #include <$ac_header>
6501 > _ACEOF
6502 > rm -f conftest.$ac_objext
6503 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6504 >  (eval $ac_compile) 2>conftest.er1
6505 >  ac_status=$?
6506 >  grep -v '^ *+' conftest.er1 >conftest.err
6507 >  rm -f conftest.er1
6508 >  cat conftest.err >&5
6509 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6510 >  (exit $ac_status); } &&
6511 >         { ac_try='test -z "$ac_c_werror_flag"
6512 >                         || test ! -s conftest.err'
6513 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6514 >  (eval $ac_try) 2>&5
6515 >  ac_status=$?
6516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6517 >  (exit $ac_status); }; } &&
6518 >         { ac_try='test -s conftest.$ac_objext'
6519 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6520 >  (eval $ac_try) 2>&5
6521 >  ac_status=$?
6522 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6523 >  (exit $ac_status); }; }; then
6524 >  ac_header_compiler=yes
6525 > else
6526 >  echo "$as_me: failed program was:" >&5
6527 > sed 's/^/| /' conftest.$ac_ext >&5
6528 >
6529 > ac_header_compiler=no
6530 > fi
6531 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6532 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6533 > echo "${ECHO_T}$ac_header_compiler" >&6
6534 >
6535 > # Is the header present?
6536 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
6537 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6538 > cat >conftest.$ac_ext <<_ACEOF
6539 > /* confdefs.h.  */
6540 > _ACEOF
6541 > cat confdefs.h >>conftest.$ac_ext
6542 > cat >>conftest.$ac_ext <<_ACEOF
6543 > /* end confdefs.h.  */
6544 > #include <$ac_header>
6545 > _ACEOF
6546 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6547 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6548 >  ac_status=$?
6549 >  grep -v '^ *+' conftest.er1 >conftest.err
6550 >  rm -f conftest.er1
6551 >  cat conftest.err >&5
6552 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6553 >  (exit $ac_status); } >/dev/null; then
6554 >  if test -s conftest.err; then
6555 >    ac_cpp_err=$ac_c_preproc_warn_flag
6556 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6557 >  else
6558 >    ac_cpp_err=
6559 >  fi
6560 > else
6561 >  ac_cpp_err=yes
6562 > fi
6563 > if test -z "$ac_cpp_err"; then
6564 >  ac_header_preproc=yes
6565 > else
6566 >  echo "$as_me: failed program was:" >&5
6567 > sed 's/^/| /' conftest.$ac_ext >&5
6568 >
6569 >  ac_header_preproc=no
6570 > fi
6571 > rm -f conftest.err conftest.$ac_ext
6572 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6573 > echo "${ECHO_T}$ac_header_preproc" >&6
6574 >
6575 > # So?  What about this header?
6576 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6577 >  yes:no: )
6578 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6579 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6580 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6581 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6582 >    ac_header_preproc=yes
6583 >    ;;
6584 >  no:yes:* )
6585 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6586 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6587 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6588 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6589 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6590 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6591 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6592 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6593 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6594 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6595 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6596 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6597 >    (
6598 >      cat <<\_ASBOX
6599 > ## ------------------------------ ##
6600 > ## Report this to gezelter@nd.edu ##
6601 > ## ------------------------------ ##
6602 > _ASBOX
6603 >    ) |
6604 >      sed "s/^/$as_me: WARNING:     /" >&2
6605 >    ;;
6606 > esac
6607 > echo "$as_me:$LINENO: checking for $ac_header" >&5
6608 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6609 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
6610 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6611 > else
6612 >  eval "$as_ac_Header=\$ac_header_preproc"
6613 > fi
6614 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6615 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6616 >
6617 > fi
6618 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
6619 >  cat >>confdefs.h <<_ACEOF
6620 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6621 > _ACEOF
6622 >
6623 > fi
6624 >
6625 > done
6626 >
6627 >
6628 > # Checks for typedefs, structures, and compiler characteristics.
6629 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
6630 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
6631 > if test "${ac_cv_header_stdbool_h+set}" = set; then
6632 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6633 > else
6634 >  cat >conftest.$ac_ext <<_ACEOF
6635 > /* confdefs.h.  */
6636 > _ACEOF
6637 > cat confdefs.h >>conftest.$ac_ext
6638 > cat >>conftest.$ac_ext <<_ACEOF
6639 > /* end confdefs.h.  */
6640 >
6641 > #include <stdbool.h>
6642 > #ifndef bool
6643 > # error bool is not defined
6644 > #endif
6645 > #ifndef false
6646 > # error false is not defined
6647 > #endif
6648 > #if false
6649 > # error false is not 0
6650 > #endif
6651 > #ifndef true
6652 > # error true is not defined
6653 > #endif
6654 > #if true != 1
6655 > # error true is not 1
6656 > #endif
6657 > #ifndef __bool_true_false_are_defined
6658 > # error __bool_true_false_are_defined is not defined
6659 > #endif
6660 >
6661 >        struct s { _Bool s: 1; _Bool t; } s;
6662 >
6663 >        char a[true == 1 ? 1 : -1];
6664 >        char b[false == 0 ? 1 : -1];
6665 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
6666 >        char d[(bool) -0.5 == true ? 1 : -1];
6667 >        bool e = &s;
6668 >        char f[(_Bool) -0.0 == false ? 1 : -1];
6669 >        char g[true];
6670 >        char h[sizeof (_Bool)];
6671 >        char i[sizeof s.t];
6672 >
6673 > #ifdef FC_DUMMY_MAIN
6674 > #ifndef FC_DUMMY_MAIN_EQ_F77
6675 > #  ifdef __cplusplus
6676 >     extern "C"
6677 > #  endif
6678 >   int FC_DUMMY_MAIN() { return 1; }
6679 > #endif
6680 > #endif
6681 > int
6682 > main ()
6683 > {
6684 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
6685 >  ;
6686 >  return 0;
6687 > }
6688 > _ACEOF
6689 > rm -f conftest.$ac_objext
6690 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6691 >  (eval $ac_compile) 2>conftest.er1
6692 >  ac_status=$?
6693 >  grep -v '^ *+' conftest.er1 >conftest.err
6694 >  rm -f conftest.er1
6695 >  cat conftest.err >&5
6696 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6697 >  (exit $ac_status); } &&
6698 >         { ac_try='test -z "$ac_c_werror_flag"
6699 >                         || test ! -s conftest.err'
6700 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6701 >  (eval $ac_try) 2>&5
6702 >  ac_status=$?
6703 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6704 >  (exit $ac_status); }; } &&
6705 >         { ac_try='test -s conftest.$ac_objext'
6706 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6707 >  (eval $ac_try) 2>&5
6708 >  ac_status=$?
6709 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6710 >  (exit $ac_status); }; }; then
6711 >  ac_cv_header_stdbool_h=yes
6712 > else
6713 >  echo "$as_me: failed program was:" >&5
6714 > sed 's/^/| /' conftest.$ac_ext >&5
6715 >
6716 > ac_cv_header_stdbool_h=no
6717 > fi
6718 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6719 > fi
6720 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
6721 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
6722 > echo "$as_me:$LINENO: checking for _Bool" >&5
6723 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
6724 > if test "${ac_cv_type__Bool+set}" = set; then
6725 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6726 > else
6727 >  cat >conftest.$ac_ext <<_ACEOF
6728 > /* confdefs.h.  */
6729 > _ACEOF
6730 > cat confdefs.h >>conftest.$ac_ext
6731 > cat >>conftest.$ac_ext <<_ACEOF
6732 > /* end confdefs.h.  */
6733 > $ac_includes_default
6734 > #ifdef FC_DUMMY_MAIN
6735 > #ifndef FC_DUMMY_MAIN_EQ_F77
6736 > #  ifdef __cplusplus
6737 >     extern "C"
6738 > #  endif
6739 >   int FC_DUMMY_MAIN() { return 1; }
6740 > #endif
6741 > #endif
6742 > int
6743 > main ()
6744 > {
6745 > if ((_Bool *) 0)
6746 >  return 0;
6747 > if (sizeof (_Bool))
6748 >  return 0;
6749 >  ;
6750 >  return 0;
6751 > }
6752 > _ACEOF
6753 > rm -f conftest.$ac_objext
6754 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6755 >  (eval $ac_compile) 2>conftest.er1
6756 >  ac_status=$?
6757 >  grep -v '^ *+' conftest.er1 >conftest.err
6758 >  rm -f conftest.er1
6759 >  cat conftest.err >&5
6760 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6761 >  (exit $ac_status); } &&
6762 >         { ac_try='test -z "$ac_c_werror_flag"
6763 >                         || test ! -s conftest.err'
6764 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6765 >  (eval $ac_try) 2>&5
6766 >  ac_status=$?
6767 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6768 >  (exit $ac_status); }; } &&
6769 >         { ac_try='test -s conftest.$ac_objext'
6770 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6771 >  (eval $ac_try) 2>&5
6772 >  ac_status=$?
6773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6774 >  (exit $ac_status); }; }; then
6775 >  ac_cv_type__Bool=yes
6776 > else
6777 >  echo "$as_me: failed program was:" >&5
6778 > sed 's/^/| /' conftest.$ac_ext >&5
6779 >
6780 > ac_cv_type__Bool=no
6781 > fi
6782 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6783 > fi
6784 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
6785 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
6786 > if test $ac_cv_type__Bool = yes; then
6787 >
6788 > cat >>confdefs.h <<_ACEOF
6789 > #define HAVE__BOOL 1
6790 > _ACEOF
6791 >
6792 >
6793 > fi
6794 >
6795 > if test $ac_cv_header_stdbool_h = yes; then
6796 >
6797 > cat >>confdefs.h <<\_ACEOF
6798 > #define HAVE_STDBOOL_H 1
6799 > _ACEOF
6800 >
6801 > fi
6802 >
6803 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
6804 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
6805 > if test "${ac_cv_c_const+set}" = set; then
6806 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6807 > else
6808 >  cat >conftest.$ac_ext <<_ACEOF
6809 > /* confdefs.h.  */
6810 > _ACEOF
6811 > cat confdefs.h >>conftest.$ac_ext
6812 > cat >>conftest.$ac_ext <<_ACEOF
6813 > /* end confdefs.h.  */
6814 >
6815 > #ifdef FC_DUMMY_MAIN
6816 > #ifndef FC_DUMMY_MAIN_EQ_F77
6817 > #  ifdef __cplusplus
6818 >     extern "C"
6819 > #  endif
6820 >   int FC_DUMMY_MAIN() { return 1; }
6821 > #endif
6822 > #endif
6823 > int
6824 > main ()
6825 > {
6826 > /* FIXME: Include the comments suggested by Paul. */
6827 > #ifndef __cplusplus
6828 >  /* Ultrix mips cc rejects this.  */
6829 >  typedef int charset[2];
6830 >  const charset x;
6831 >  /* SunOS 4.1.1 cc rejects this.  */
6832 >  char const *const *ccp;
6833 >  char **p;
6834 >  /* NEC SVR4.0.2 mips cc rejects this.  */
6835 >  struct point {int x, y;};
6836 >  static struct point const zero = {0,0};
6837 >  /* AIX XL C 1.02.0.0 rejects this.
6838 >     It does not let you subtract one const X* pointer from another in
6839 >     an arm of an if-expression whose if-part is not a constant
6840 >     expression */
6841 >  const char *g = "string";
6842 >  ccp = &g + (g ? g-g : 0);
6843 >  /* HPUX 7.0 cc rejects these. */
6844 >  ++ccp;
6845 >  p = (char**) ccp;
6846 >  ccp = (char const *const *) p;
6847 >  { /* SCO 3.2v4 cc rejects this.  */
6848 >    char *t;
6849 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
6850 >
6851 >    *t++ = 0;
6852 >  }
6853 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6854 >    int x[] = {25, 17};
6855 >    const int *foo = &x[0];
6856 >    ++foo;
6857 >  }
6858 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6859 >    typedef const int *iptr;
6860 >    iptr p = 0;
6861 >    ++p;
6862 >  }
6863 >  { /* AIX XL C 1.02.0.0 rejects this saying
6864 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6865 >    struct s { int j; const int *ap[3]; };
6866 >    struct s *b; b->j = 5;
6867 >  }
6868 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6869 >    const int foo = 10;
6870 >  }
6871 > #endif
6872 >
6873 >  ;
6874 >  return 0;
6875 > }
6876 > _ACEOF
6877 > rm -f conftest.$ac_objext
6878 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6879 >  (eval $ac_compile) 2>conftest.er1
6880 >  ac_status=$?
6881 >  grep -v '^ *+' conftest.er1 >conftest.err
6882 >  rm -f conftest.er1
6883 >  cat conftest.err >&5
6884 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6885 >  (exit $ac_status); } &&
6886 >         { ac_try='test -z "$ac_c_werror_flag"
6887 >                         || test ! -s conftest.err'
6888 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6889 >  (eval $ac_try) 2>&5
6890 >  ac_status=$?
6891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6892 >  (exit $ac_status); }; } &&
6893 >         { ac_try='test -s conftest.$ac_objext'
6894 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6895 >  (eval $ac_try) 2>&5
6896 >  ac_status=$?
6897 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6898 >  (exit $ac_status); }; }; then
6899 >  ac_cv_c_const=yes
6900 > else
6901 >  echo "$as_me: failed program was:" >&5
6902 > sed 's/^/| /' conftest.$ac_ext >&5
6903 >
6904 > ac_cv_c_const=no
6905 > fi
6906 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6907 > fi
6908 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
6909 > echo "${ECHO_T}$ac_cv_c_const" >&6
6910 > if test $ac_cv_c_const = no; then
6911 >
6912 > cat >>confdefs.h <<\_ACEOF
6913 > #define const
6914 > _ACEOF
6915 >
6916 > fi
6917 >
6918 > echo "$as_me:$LINENO: checking for inline" >&5
6919 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
6920 > if test "${ac_cv_c_inline+set}" = set; then
6921 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6922 > else
6923 >  ac_cv_c_inline=no
6924 > for ac_kw in inline __inline__ __inline; do
6925 >  cat >conftest.$ac_ext <<_ACEOF
6926 > /* confdefs.h.  */
6927 > _ACEOF
6928 > cat confdefs.h >>conftest.$ac_ext
6929 > cat >>conftest.$ac_ext <<_ACEOF
6930 > /* end confdefs.h.  */
6931 > #ifndef __cplusplus
6932 > typedef int foo_t;
6933 > static $ac_kw foo_t static_foo () {return 0; }
6934 > $ac_kw foo_t foo () {return 0; }
6935 > #endif
6936 >
6937 > _ACEOF
6938 > rm -f conftest.$ac_objext
6939 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6940 >  (eval $ac_compile) 2>conftest.er1
6941 >  ac_status=$?
6942 >  grep -v '^ *+' conftest.er1 >conftest.err
6943 >  rm -f conftest.er1
6944 >  cat conftest.err >&5
6945 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6946 >  (exit $ac_status); } &&
6947 >         { ac_try='test -z "$ac_c_werror_flag"
6948 >                         || test ! -s conftest.err'
6949 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950 >  (eval $ac_try) 2>&5
6951 >  ac_status=$?
6952 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953 >  (exit $ac_status); }; } &&
6954 >         { ac_try='test -s conftest.$ac_objext'
6955 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6956 >  (eval $ac_try) 2>&5
6957 >  ac_status=$?
6958 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6959 >  (exit $ac_status); }; }; then
6960 >  ac_cv_c_inline=$ac_kw; break
6961 > else
6962 >  echo "$as_me: failed program was:" >&5
6963 > sed 's/^/| /' conftest.$ac_ext >&5
6964 >
6965 > fi
6966 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6967 > done
6968 >
6969 > fi
6970 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
6971 > echo "${ECHO_T}$ac_cv_c_inline" >&6
6972 >
6973 >
6974 > case $ac_cv_c_inline in
6975 >  inline | yes) ;;
6976 >  *)
6977 >    case $ac_cv_c_inline in
6978 >      no) ac_val=;;
6979 >      *) ac_val=$ac_cv_c_inline;;
6980 >    esac
6981 >    cat >>confdefs.h <<_ACEOF
6982 > #ifndef __cplusplus
6983 > #define inline $ac_val
6984 > #endif
6985 > _ACEOF
6986 >    ;;
6987 > esac
6988 >
6989 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
6990 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
6991 > if test "${ac_cv_c_restrict+set}" = set; then
6992 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6993 > else
6994 >  ac_cv_c_restrict=no
6995 >   # Try the official restrict keyword, then gcc's __restrict, and
6996 >   # the less common variants.
6997 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
6998 >     cat >conftest.$ac_ext <<_ACEOF
6999 > /* confdefs.h.  */
7000 > _ACEOF
7001 > cat confdefs.h >>conftest.$ac_ext
7002 > cat >>conftest.$ac_ext <<_ACEOF
7003 > /* end confdefs.h.  */
7004 > float * $ac_kw x;
7005 > _ACEOF
7006 > rm -f conftest.$ac_objext
7007 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7008 >  (eval $ac_compile) 2>conftest.er1
7009 >  ac_status=$?
7010 >  grep -v '^ *+' conftest.er1 >conftest.err
7011 >  rm -f conftest.er1
7012 >  cat conftest.err >&5
7013 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7014 >  (exit $ac_status); } &&
7015 >         { ac_try='test -z "$ac_c_werror_flag"
7016 >                         || test ! -s conftest.err'
7017 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7018 >  (eval $ac_try) 2>&5
7019 >  ac_status=$?
7020 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7021 >  (exit $ac_status); }; } &&
7022 >         { ac_try='test -s conftest.$ac_objext'
7023 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7024 >  (eval $ac_try) 2>&5
7025 >  ac_status=$?
7026 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7027 >  (exit $ac_status); }; }; then
7028 >  ac_cv_c_restrict=$ac_kw; break
7029 > else
7030 >  echo "$as_me: failed program was:" >&5
7031 > sed 's/^/| /' conftest.$ac_ext >&5
7032 >
7033 > fi
7034 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7035 >   done
7036 >
7037 > fi
7038 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7039 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7040 > case $ac_cv_c_restrict in
7041 >   restrict) ;;
7042 >   no)
7043 > cat >>confdefs.h <<\_ACEOF
7044 > #define restrict
7045 > _ACEOF
7046 > ;;
7047 >   *)  cat >>confdefs.h <<_ACEOF
7048 > #define restrict $ac_cv_c_restrict
7049 > _ACEOF
7050 > ;;
7051 > esac
7052 >
7053 > echo "$as_me:$LINENO: checking for size_t" >&5
7054 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7055 > if test "${ac_cv_type_size_t+set}" = set; then
7056 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7057 > else
7058 >  cat >conftest.$ac_ext <<_ACEOF
7059 > /* confdefs.h.  */
7060 > _ACEOF
7061 > cat confdefs.h >>conftest.$ac_ext
7062 > cat >>conftest.$ac_ext <<_ACEOF
7063 > /* end confdefs.h.  */
7064 > $ac_includes_default
7065 > #ifdef FC_DUMMY_MAIN
7066 > #ifndef FC_DUMMY_MAIN_EQ_F77
7067 > #  ifdef __cplusplus
7068 >     extern "C"
7069 > #  endif
7070 >   int FC_DUMMY_MAIN() { return 1; }
7071 > #endif
7072 > #endif
7073 > int
7074 > main ()
7075 > {
7076 > if ((size_t *) 0)
7077 >  return 0;
7078 > if (sizeof (size_t))
7079 >  return 0;
7080 >  ;
7081 >  return 0;
7082 > }
7083 > _ACEOF
7084 > rm -f conftest.$ac_objext
7085 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7086 >  (eval $ac_compile) 2>conftest.er1
7087 >  ac_status=$?
7088 >  grep -v '^ *+' conftest.er1 >conftest.err
7089 >  rm -f conftest.er1
7090 >  cat conftest.err >&5
7091 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7092 >  (exit $ac_status); } &&
7093 >         { ac_try='test -z "$ac_c_werror_flag"
7094 >                         || test ! -s conftest.err'
7095 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7096 >  (eval $ac_try) 2>&5
7097 >  ac_status=$?
7098 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7099 >  (exit $ac_status); }; } &&
7100 >         { ac_try='test -s conftest.$ac_objext'
7101 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7102 >  (eval $ac_try) 2>&5
7103 >  ac_status=$?
7104 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7105 >  (exit $ac_status); }; }; then
7106 >  ac_cv_type_size_t=yes
7107 > else
7108 >  echo "$as_me: failed program was:" >&5
7109 > sed 's/^/| /' conftest.$ac_ext >&5
7110 >
7111 > ac_cv_type_size_t=no
7112 > fi
7113 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7114 > fi
7115 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7116 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7117 > if test $ac_cv_type_size_t = yes; then
7118 >  :
7119 > else
7120 >
7121 > cat >>confdefs.h <<_ACEOF
7122 > #define size_t unsigned
7123 > _ACEOF
7124 >
7125 > fi
7126 >
7127 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7128 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7129 > if test "${ac_cv_header_time+set}" = set; then
7130 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7131 > else
7132 >  cat >conftest.$ac_ext <<_ACEOF
7133 > /* confdefs.h.  */
7134 > _ACEOF
7135 > cat confdefs.h >>conftest.$ac_ext
7136 > cat >>conftest.$ac_ext <<_ACEOF
7137 > /* end confdefs.h.  */
7138 > #include <sys/types.h>
7139 > #include <sys/time.h>
7140 > #include <time.h>
7141 >
7142 > #ifdef FC_DUMMY_MAIN
7143 > #ifndef FC_DUMMY_MAIN_EQ_F77
7144 > #  ifdef __cplusplus
7145 >     extern "C"
7146 > #  endif
7147 >   int FC_DUMMY_MAIN() { return 1; }
7148 > #endif
7149 > #endif
7150 > int
7151 > main ()
7152 > {
7153 > if ((struct tm *) 0)
7154 > return 0;
7155 >  ;
7156 >  return 0;
7157 > }
7158 > _ACEOF
7159 > rm -f conftest.$ac_objext
7160 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7161 >  (eval $ac_compile) 2>conftest.er1
7162 >  ac_status=$?
7163 >  grep -v '^ *+' conftest.er1 >conftest.err
7164 >  rm -f conftest.er1
7165 >  cat conftest.err >&5
7166 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7167 >  (exit $ac_status); } &&
7168 >         { ac_try='test -z "$ac_c_werror_flag"
7169 >                         || test ! -s conftest.err'
7170 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171 >  (eval $ac_try) 2>&5
7172 >  ac_status=$?
7173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174 >  (exit $ac_status); }; } &&
7175 >         { ac_try='test -s conftest.$ac_objext'
7176 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7177 >  (eval $ac_try) 2>&5
7178 >  ac_status=$?
7179 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7180 >  (exit $ac_status); }; }; then
7181 >  ac_cv_header_time=yes
7182 > else
7183 >  echo "$as_me: failed program was:" >&5
7184 > sed 's/^/| /' conftest.$ac_ext >&5
7185 >
7186 > ac_cv_header_time=no
7187 > fi
7188 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7189 > fi
7190 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7191 > echo "${ECHO_T}$ac_cv_header_time" >&6
7192 > if test $ac_cv_header_time = yes; then
7193 >
7194 > cat >>confdefs.h <<\_ACEOF
7195 > #define TIME_WITH_SYS_TIME 1
7196 > _ACEOF
7197 >
7198 > fi
7199 >
7200 > echo "$as_me:$LINENO: checking for clock_t" >&5
7201 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7202 > if test "${ac_cv_type_clock_t+set}" = set; then
7203 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7204 > else
7205 >  cat >conftest.$ac_ext <<_ACEOF
7206 > /* confdefs.h.  */
7207 > _ACEOF
7208 > cat confdefs.h >>conftest.$ac_ext
7209 > cat >>conftest.$ac_ext <<_ACEOF
7210 > /* end confdefs.h.  */
7211 > $ac_includes_default
7212 > #ifdef FC_DUMMY_MAIN
7213 > #ifndef FC_DUMMY_MAIN_EQ_F77
7214 > #  ifdef __cplusplus
7215 >     extern "C"
7216 > #  endif
7217 >   int FC_DUMMY_MAIN() { return 1; }
7218 > #endif
7219 > #endif
7220 > int
7221 > main ()
7222 > {
7223 > if ((clock_t *) 0)
7224 >  return 0;
7225 > if (sizeof (clock_t))
7226 >  return 0;
7227 >  ;
7228 >  return 0;
7229 > }
7230 > _ACEOF
7231 > rm -f conftest.$ac_objext
7232 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7233 >  (eval $ac_compile) 2>conftest.er1
7234 >  ac_status=$?
7235 >  grep -v '^ *+' conftest.er1 >conftest.err
7236 >  rm -f conftest.er1
7237 >  cat conftest.err >&5
7238 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7239 >  (exit $ac_status); } &&
7240 >         { ac_try='test -z "$ac_c_werror_flag"
7241 >                         || test ! -s conftest.err'
7242 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7243 >  (eval $ac_try) 2>&5
7244 >  ac_status=$?
7245 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7246 >  (exit $ac_status); }; } &&
7247 >         { ac_try='test -s conftest.$ac_objext'
7248 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7249 >  (eval $ac_try) 2>&5
7250 >  ac_status=$?
7251 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7252 >  (exit $ac_status); }; }; then
7253 >  ac_cv_type_clock_t=yes
7254 > else
7255 >  echo "$as_me: failed program was:" >&5
7256 > sed 's/^/| /' conftest.$ac_ext >&5
7257 >
7258 > ac_cv_type_clock_t=no
7259 > fi
7260 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7261 > fi
7262 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7263 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7264 > if test $ac_cv_type_clock_t = yes; then
7265 >
7266 > cat >>confdefs.h <<_ACEOF
7267 > #define HAVE_CLOCK_T 1
7268 > _ACEOF
7269 >
7270 >
7271 > fi
7272 >
7273 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7274 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7275 > if test "${ac_cv_c_const+set}" = set; then
7276 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7277 > else
7278 >  cat >conftest.$ac_ext <<_ACEOF
7279 > /* confdefs.h.  */
7280 > _ACEOF
7281 > cat confdefs.h >>conftest.$ac_ext
7282 > cat >>conftest.$ac_ext <<_ACEOF
7283 > /* end confdefs.h.  */
7284 >
7285 > #ifdef FC_DUMMY_MAIN
7286 > #ifndef FC_DUMMY_MAIN_EQ_F77
7287 > #  ifdef __cplusplus
7288 >     extern "C"
7289 > #  endif
7290 >   int FC_DUMMY_MAIN() { return 1; }
7291 > #endif
7292 > #endif
7293 > int
7294 > main ()
7295 > {
7296 > /* FIXME: Include the comments suggested by Paul. */
7297 > #ifndef __cplusplus
7298 >  /* Ultrix mips cc rejects this.  */
7299 >  typedef int charset[2];
7300 >  const charset x;
7301 >  /* SunOS 4.1.1 cc rejects this.  */
7302 >  char const *const *ccp;
7303 >  char **p;
7304 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7305 >  struct point {int x, y;};
7306 >  static struct point const zero = {0,0};
7307 >  /* AIX XL C 1.02.0.0 rejects this.
7308 >     It does not let you subtract one const X* pointer from another in
7309 >     an arm of an if-expression whose if-part is not a constant
7310 >     expression */
7311 >  const char *g = "string";
7312 >  ccp = &g + (g ? g-g : 0);
7313 >  /* HPUX 7.0 cc rejects these. */
7314 >  ++ccp;
7315 >  p = (char**) ccp;
7316 >  ccp = (char const *const *) p;
7317 >  { /* SCO 3.2v4 cc rejects this.  */
7318 >    char *t;
7319 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7320 >
7321 >    *t++ = 0;
7322 >  }
7323 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7324 >    int x[] = {25, 17};
7325 >    const int *foo = &x[0];
7326 >    ++foo;
7327 >  }
7328 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7329 >    typedef const int *iptr;
7330 >    iptr p = 0;
7331 >    ++p;
7332 >  }
7333 >  { /* AIX XL C 1.02.0.0 rejects this saying
7334 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7335 >    struct s { int j; const int *ap[3]; };
7336 >    struct s *b; b->j = 5;
7337 >  }
7338 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7339 >    const int foo = 10;
7340 >  }
7341 > #endif
7342 >
7343 >  ;
7344 >  return 0;
7345 > }
7346 > _ACEOF
7347 > rm -f conftest.$ac_objext
7348 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7349 >  (eval $ac_compile) 2>conftest.er1
7350 >  ac_status=$?
7351 >  grep -v '^ *+' conftest.er1 >conftest.err
7352 >  rm -f conftest.er1
7353 >  cat conftest.err >&5
7354 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7355 >  (exit $ac_status); } &&
7356 >         { ac_try='test -z "$ac_c_werror_flag"
7357 >                         || test ! -s conftest.err'
7358 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7359 >  (eval $ac_try) 2>&5
7360 >  ac_status=$?
7361 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7362 >  (exit $ac_status); }; } &&
7363 >         { ac_try='test -s conftest.$ac_objext'
7364 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7365 >  (eval $ac_try) 2>&5
7366 >  ac_status=$?
7367 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7368 >  (exit $ac_status); }; }; then
7369 >  ac_cv_c_const=yes
7370 > else
7371 >  echo "$as_me: failed program was:" >&5
7372 > sed 's/^/| /' conftest.$ac_ext >&5
7373 >
7374 > ac_cv_c_const=no
7375 > fi
7376 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7377 > fi
7378 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7379 > echo "${ECHO_T}$ac_cv_c_const" >&6
7380 > if test $ac_cv_c_const = no; then
7381 >
7382 > cat >>confdefs.h <<\_ACEOF
7383 > #define const
7384 > _ACEOF
7385 >
7386 > fi
7387 >
7388 > echo "$as_me:$LINENO: checking for inline" >&5
7389 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7390 > if test "${ac_cv_c_inline+set}" = set; then
7391 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7392 > else
7393 >  ac_cv_c_inline=no
7394 > for ac_kw in inline __inline__ __inline; do
7395 >  cat >conftest.$ac_ext <<_ACEOF
7396 > /* confdefs.h.  */
7397 > _ACEOF
7398 > cat confdefs.h >>conftest.$ac_ext
7399 > cat >>conftest.$ac_ext <<_ACEOF
7400 > /* end confdefs.h.  */
7401 > #ifndef __cplusplus
7402 > typedef int foo_t;
7403 > static $ac_kw foo_t static_foo () {return 0; }
7404 > $ac_kw foo_t foo () {return 0; }
7405 > #endif
7406 >
7407 > _ACEOF
7408 > rm -f conftest.$ac_objext
7409 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7410 >  (eval $ac_compile) 2>conftest.er1
7411 >  ac_status=$?
7412 >  grep -v '^ *+' conftest.er1 >conftest.err
7413 >  rm -f conftest.er1
7414 >  cat conftest.err >&5
7415 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7416 >  (exit $ac_status); } &&
7417 >         { ac_try='test -z "$ac_c_werror_flag"
7418 >                         || test ! -s conftest.err'
7419 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7420 >  (eval $ac_try) 2>&5
7421 >  ac_status=$?
7422 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7423 >  (exit $ac_status); }; } &&
7424 >         { ac_try='test -s conftest.$ac_objext'
7425 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7426 >  (eval $ac_try) 2>&5
7427 >  ac_status=$?
7428 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7429 >  (exit $ac_status); }; }; then
7430 >  ac_cv_c_inline=$ac_kw; break
7431 > else
7432 >  echo "$as_me: failed program was:" >&5
7433 > sed 's/^/| /' conftest.$ac_ext >&5
7434 >
7435 > fi
7436 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7437 > done
7438 >
7439 > fi
7440 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7441 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7442 >
7443 >
7444 > case $ac_cv_c_inline in
7445 >  inline | yes) ;;
7446 >  *)
7447 >    case $ac_cv_c_inline in
7448 >      no) ac_val=;;
7449 >      *) ac_val=$ac_cv_c_inline;;
7450 >    esac
7451 >    cat >>confdefs.h <<_ACEOF
7452 > #ifndef __cplusplus
7453 > #define inline $ac_val
7454 > #endif
7455 > _ACEOF
7456 >    ;;
7457 > esac
7458 >
7459 >
7460 > # Checks for library functions.
7461 >
7462 > for ac_header in stdlib.h
7463 > do
7464 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7465 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7466 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7467 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7468 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7469 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7470 > fi
7471 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7472 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7473 > else
7474 >  # Is the header compilable?
7475 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7476 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7477 > cat >conftest.$ac_ext <<_ACEOF
7478 > /* confdefs.h.  */
7479 > _ACEOF
7480 > cat confdefs.h >>conftest.$ac_ext
7481 > cat >>conftest.$ac_ext <<_ACEOF
7482 > /* end confdefs.h.  */
7483 > $ac_includes_default
7484 > #include <$ac_header>
7485 > _ACEOF
7486 > rm -f conftest.$ac_objext
7487 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7488 >  (eval $ac_compile) 2>conftest.er1
7489 >  ac_status=$?
7490 >  grep -v '^ *+' conftest.er1 >conftest.err
7491 >  rm -f conftest.er1
7492 >  cat conftest.err >&5
7493 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7494 >  (exit $ac_status); } &&
7495 >         { ac_try='test -z "$ac_c_werror_flag"
7496 >                         || test ! -s conftest.err'
7497 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7498 >  (eval $ac_try) 2>&5
7499 >  ac_status=$?
7500 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7501 >  (exit $ac_status); }; } &&
7502 >         { ac_try='test -s conftest.$ac_objext'
7503 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7504 >  (eval $ac_try) 2>&5
7505 >  ac_status=$?
7506 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7507 >  (exit $ac_status); }; }; then
7508 >  ac_header_compiler=yes
7509 > else
7510 >  echo "$as_me: failed program was:" >&5
7511 > sed 's/^/| /' conftest.$ac_ext >&5
7512 >
7513 > ac_header_compiler=no
7514 > fi
7515 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7516 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7517 > echo "${ECHO_T}$ac_header_compiler" >&6
7518 >
7519 > # Is the header present?
7520 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7521 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7522 > cat >conftest.$ac_ext <<_ACEOF
7523 > /* confdefs.h.  */
7524 > _ACEOF
7525 > cat confdefs.h >>conftest.$ac_ext
7526 > cat >>conftest.$ac_ext <<_ACEOF
7527 > /* end confdefs.h.  */
7528 > #include <$ac_header>
7529 > _ACEOF
7530 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7531 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7532 >  ac_status=$?
7533 >  grep -v '^ *+' conftest.er1 >conftest.err
7534 >  rm -f conftest.er1
7535 >  cat conftest.err >&5
7536 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7537 >  (exit $ac_status); } >/dev/null; then
7538 >  if test -s conftest.err; then
7539 >    ac_cpp_err=$ac_c_preproc_warn_flag
7540 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7541 >  else
7542 >    ac_cpp_err=
7543 >  fi
7544 > else
7545 >  ac_cpp_err=yes
7546 > fi
7547 > if test -z "$ac_cpp_err"; then
7548 >  ac_header_preproc=yes
7549 > else
7550 >  echo "$as_me: failed program was:" >&5
7551 > sed 's/^/| /' conftest.$ac_ext >&5
7552 >
7553 >  ac_header_preproc=no
7554 > fi
7555 > rm -f conftest.err conftest.$ac_ext
7556 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7557 > echo "${ECHO_T}$ac_header_preproc" >&6
7558 >
7559 > # So?  What about this header?
7560 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7561 >  yes:no: )
7562 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7563 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7564 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7565 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7566 >    ac_header_preproc=yes
7567 >    ;;
7568 >  no:yes:* )
7569 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7570 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7571 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7572 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7573 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7574 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7575 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7576 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7577 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7578 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7579 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7580 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7581 >    (
7582 >      cat <<\_ASBOX
7583 > ## ------------------------------ ##
7584 > ## Report this to gezelter@nd.edu ##
7585 > ## ------------------------------ ##
7586 > _ASBOX
7587 >    ) |
7588 >      sed "s/^/$as_me: WARNING:     /" >&2
7589 >    ;;
7590 > esac
7591 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7592 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7593 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7594 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7595 > else
7596 >  eval "$as_ac_Header=\$ac_header_preproc"
7597 > fi
7598 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7599 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7600 >
7601 > fi
7602 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7603 >  cat >>confdefs.h <<_ACEOF
7604 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7605 > _ACEOF
7606 >
7607 > fi
7608 >
7609 > done
7610 >
7611 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
7612 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
7613 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
7614 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7615 > else
7616 >  if test "$cross_compiling" = yes; then
7617 >  ac_cv_func_malloc_0_nonnull=no
7618 > else
7619 >  cat >conftest.$ac_ext <<_ACEOF
7620 > /* confdefs.h.  */
7621 > _ACEOF
7622 > cat confdefs.h >>conftest.$ac_ext
7623 > cat >>conftest.$ac_ext <<_ACEOF
7624 > /* end confdefs.h.  */
7625 > #if STDC_HEADERS || HAVE_STDLIB_H
7626 > # include <stdlib.h>
7627 > #else
7628 > char *malloc ();
7629 > #endif
7630 >
7631 > #ifdef FC_DUMMY_MAIN
7632 > #ifndef FC_DUMMY_MAIN_EQ_F77
7633 > #  ifdef __cplusplus
7634 >     extern "C"
7635 > #  endif
7636 >   int FC_DUMMY_MAIN() { return 1; }
7637 > #endif
7638 > #endif
7639 > int
7640 > main ()
7641 > {
7642 > exit (malloc (0) ? 0 : 1);
7643 >  ;
7644 >  return 0;
7645 > }
7646 > _ACEOF
7647 > rm -f conftest$ac_exeext
7648 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7649 >  (eval $ac_link) 2>&5
7650 >  ac_status=$?
7651 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7652 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7653 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654 >  (eval $ac_try) 2>&5
7655 >  ac_status=$?
7656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657 >  (exit $ac_status); }; }; then
7658 >  ac_cv_func_malloc_0_nonnull=yes
7659 > else
7660 >  echo "$as_me: program exited with status $ac_status" >&5
7661 > echo "$as_me: failed program was:" >&5
7662 > sed 's/^/| /' conftest.$ac_ext >&5
7663 >
7664 > ( exit $ac_status )
7665 > ac_cv_func_malloc_0_nonnull=no
7666 > fi
7667 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7668 > fi
7669 > fi
7670 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
7671 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
7672 > if test $ac_cv_func_malloc_0_nonnull = yes; then
7673 >
7674 > cat >>confdefs.h <<\_ACEOF
7675 > #define HAVE_MALLOC 1
7676 > _ACEOF
7677 >
7678 > else
7679 >  cat >>confdefs.h <<\_ACEOF
7680 > #define HAVE_MALLOC 0
7681 > _ACEOF
7682 >
7683 >   case $LIBOBJS in
7684 >    "malloc.$ac_objext"   | \
7685 >  *" malloc.$ac_objext"   | \
7686 >    "malloc.$ac_objext "* | \
7687 >  *" malloc.$ac_objext "* ) ;;
7688 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
7689 > esac
7690 >
7691 >
7692 > cat >>confdefs.h <<\_ACEOF
7693 > #define malloc rpl_malloc
7694 > _ACEOF
7695 >
7696 > fi
7697 >
7698 >
7699 >
7700 > echo "$as_me:$LINENO: checking for working memcmp" >&5
7701 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
7702 > if test "${ac_cv_func_memcmp_working+set}" = set; then
7703 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7704 > else
7705 >  if test "$cross_compiling" = yes; then
7706 >  ac_cv_func_memcmp_working=no
7707 > else
7708 >  cat >conftest.$ac_ext <<_ACEOF
7709 > /* confdefs.h.  */
7710 > _ACEOF
7711 > cat confdefs.h >>conftest.$ac_ext
7712 > cat >>conftest.$ac_ext <<_ACEOF
7713 > /* end confdefs.h.  */
7714 > $ac_includes_default
7715 > #ifdef FC_DUMMY_MAIN
7716 > #ifndef FC_DUMMY_MAIN_EQ_F77
7717 > #  ifdef __cplusplus
7718 >     extern "C"
7719 > #  endif
7720 >   int FC_DUMMY_MAIN() { return 1; }
7721 > #endif
7722 > #endif
7723 > int
7724 > main ()
7725 > {
7726 >
7727 >  /* Some versions of memcmp are not 8-bit clean.  */
7728 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
7729 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
7730 >    exit (1);
7731 >
7732 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
7733 >     or more and with at least one buffer not starting on a 4-byte boundary.
7734 >     William Lewis provided this test program.   */
7735 >  {
7736 >    char foo[21];
7737 >    char bar[21];
7738 >    int i;
7739 >    for (i = 0; i < 4; i++)
7740 >      {
7741 >        char *a = foo + i;
7742 >        char *b = bar + i;
7743 >        strcpy (a, "--------01111111");
7744 >        strcpy (b, "--------10000000");
7745 >        if (memcmp (a, b, 16) >= 0)
7746 >          exit (1);
7747 >      }
7748 >    exit (0);
7749 >  }
7750 >
7751 >  ;
7752 >  return 0;
7753 > }
7754 > _ACEOF
7755 > rm -f conftest$ac_exeext
7756 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7757 >  (eval $ac_link) 2>&5
7758 >  ac_status=$?
7759 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7760 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7761 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7762 >  (eval $ac_try) 2>&5
7763 >  ac_status=$?
7764 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7765 >  (exit $ac_status); }; }; then
7766 >  ac_cv_func_memcmp_working=yes
7767 > else
7768 >  echo "$as_me: program exited with status $ac_status" >&5
7769 > echo "$as_me: failed program was:" >&5
7770 > sed 's/^/| /' conftest.$ac_ext >&5
7771 >
7772 > ( exit $ac_status )
7773 > ac_cv_func_memcmp_working=no
7774 > fi
7775 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7776 > fi
7777 > fi
7778 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
7779 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
7780 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
7781 >    "memcmp.$ac_objext"   | \
7782 >  *" memcmp.$ac_objext"   | \
7783 >    "memcmp.$ac_objext "* | \
7784 >  *" memcmp.$ac_objext "* ) ;;
7785 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
7786 > esac
7787 >
7788 >
7789 >
7790 > for ac_header in stdlib.h
7791 > do
7792 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7793 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7794 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7795 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7796 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7797 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7798 > fi
7799 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7800 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7801 > else
7802 >  # Is the header compilable?
7803 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7804 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7805 > cat >conftest.$ac_ext <<_ACEOF
7806 > /* confdefs.h.  */
7807 > _ACEOF
7808 > cat confdefs.h >>conftest.$ac_ext
7809 > cat >>conftest.$ac_ext <<_ACEOF
7810 > /* end confdefs.h.  */
7811 > $ac_includes_default
7812 > #include <$ac_header>
7813 > _ACEOF
7814 > rm -f conftest.$ac_objext
7815 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7816 >  (eval $ac_compile) 2>conftest.er1
7817 >  ac_status=$?
7818 >  grep -v '^ *+' conftest.er1 >conftest.err
7819 >  rm -f conftest.er1
7820 >  cat conftest.err >&5
7821 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7822 >  (exit $ac_status); } &&
7823 >         { ac_try='test -z "$ac_c_werror_flag"
7824 >                         || test ! -s conftest.err'
7825 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7826 >  (eval $ac_try) 2>&5
7827 >  ac_status=$?
7828 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7829 >  (exit $ac_status); }; } &&
7830 >         { ac_try='test -s conftest.$ac_objext'
7831 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7832 >  (eval $ac_try) 2>&5
7833 >  ac_status=$?
7834 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7835 >  (exit $ac_status); }; }; then
7836 >  ac_header_compiler=yes
7837 > else
7838 >  echo "$as_me: failed program was:" >&5
7839 > sed 's/^/| /' conftest.$ac_ext >&5
7840 >
7841 > ac_header_compiler=no
7842 > fi
7843 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7844 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7845 > echo "${ECHO_T}$ac_header_compiler" >&6
7846 >
7847 > # Is the header present?
7848 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7849 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7850 > cat >conftest.$ac_ext <<_ACEOF
7851 > /* confdefs.h.  */
7852 > _ACEOF
7853 > cat confdefs.h >>conftest.$ac_ext
7854 > cat >>conftest.$ac_ext <<_ACEOF
7855 > /* end confdefs.h.  */
7856 > #include <$ac_header>
7857 > _ACEOF
7858 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7859 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7860 >  ac_status=$?
7861 >  grep -v '^ *+' conftest.er1 >conftest.err
7862 >  rm -f conftest.er1
7863 >  cat conftest.err >&5
7864 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7865 >  (exit $ac_status); } >/dev/null; then
7866 >  if test -s conftest.err; then
7867 >    ac_cpp_err=$ac_c_preproc_warn_flag
7868 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7869 >  else
7870 >    ac_cpp_err=
7871 >  fi
7872 > else
7873 >  ac_cpp_err=yes
7874 > fi
7875 > if test -z "$ac_cpp_err"; then
7876 >  ac_header_preproc=yes
7877 > else
7878 >  echo "$as_me: failed program was:" >&5
7879 > sed 's/^/| /' conftest.$ac_ext >&5
7880 >
7881 >  ac_header_preproc=no
7882 > fi
7883 > rm -f conftest.err conftest.$ac_ext
7884 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7885 > echo "${ECHO_T}$ac_header_preproc" >&6
7886 >
7887 > # So?  What about this header?
7888 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7889 >  yes:no: )
7890 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7891 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7892 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7893 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7894 >    ac_header_preproc=yes
7895 >    ;;
7896 >  no:yes:* )
7897 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7898 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7899 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7900 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7901 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7902 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7903 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7904 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7905 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7906 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7907 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7908 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7909 >    (
7910 >      cat <<\_ASBOX
7911 > ## ------------------------------ ##
7912 > ## Report this to gezelter@nd.edu ##
7913 > ## ------------------------------ ##
7914 > _ASBOX
7915 >    ) |
7916 >      sed "s/^/$as_me: WARNING:     /" >&2
7917 >    ;;
7918 > esac
7919 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7920 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7921 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7922 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7923 > else
7924 >  eval "$as_ac_Header=\$ac_header_preproc"
7925 > fi
7926 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7927 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7928 >
7929 > fi
7930 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7931 >  cat >>confdefs.h <<_ACEOF
7932 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7933 > _ACEOF
7934 >
7935 > fi
7936 >
7937 > done
7938 >
7939 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
7940 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
7941 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
7942 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7943 > else
7944 >  if test "$cross_compiling" = yes; then
7945 >  ac_cv_func_realloc_0_nonnull=no
7946 > else
7947 >  cat >conftest.$ac_ext <<_ACEOF
7948 > /* confdefs.h.  */
7949 > _ACEOF
7950 > cat confdefs.h >>conftest.$ac_ext
7951 > cat >>conftest.$ac_ext <<_ACEOF
7952 > /* end confdefs.h.  */
7953 > #if STDC_HEADERS || HAVE_STDLIB_H
7954 > # include <stdlib.h>
7955 > #else
7956 > char *realloc ();
7957 > #endif
7958 >
7959 > #ifdef FC_DUMMY_MAIN
7960 > #ifndef FC_DUMMY_MAIN_EQ_F77
7961 > #  ifdef __cplusplus
7962 >     extern "C"
7963 > #  endif
7964 >   int FC_DUMMY_MAIN() { return 1; }
7965 > #endif
7966 > #endif
7967 > int
7968 > main ()
7969 > {
7970 > exit (realloc (0, 0) ? 0 : 1);
7971 >  ;
7972 >  return 0;
7973 > }
7974 > _ACEOF
7975 > rm -f conftest$ac_exeext
7976 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7977 >  (eval $ac_link) 2>&5
7978 >  ac_status=$?
7979 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7980 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7981 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7982 >  (eval $ac_try) 2>&5
7983 >  ac_status=$?
7984 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7985 >  (exit $ac_status); }; }; then
7986 >  ac_cv_func_realloc_0_nonnull=yes
7987 > else
7988 >  echo "$as_me: program exited with status $ac_status" >&5
7989 > echo "$as_me: failed program was:" >&5
7990 > sed 's/^/| /' conftest.$ac_ext >&5
7991 >
7992 > ( exit $ac_status )
7993 > ac_cv_func_realloc_0_nonnull=no
7994 > fi
7995 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7996 > fi
7997 > fi
7998 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
7999 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8000 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8001 >
8002 > cat >>confdefs.h <<\_ACEOF
8003 > #define HAVE_REALLOC 1
8004 > _ACEOF
8005 >
8006 > else
8007 >  cat >>confdefs.h <<\_ACEOF
8008 > #define HAVE_REALLOC 0
8009 > _ACEOF
8010 >
8011 >   case $LIBOBJS in
8012 >    "realloc.$ac_objext"   | \
8013 >  *" realloc.$ac_objext"   | \
8014 >    "realloc.$ac_objext "* | \
8015 >  *" realloc.$ac_objext "* ) ;;
8016 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8017 > esac
8018 >
8019 >
8020 > cat >>confdefs.h <<\_ACEOF
8021 > #define realloc rpl_realloc
8022 > _ACEOF
8023 >
8024 > fi
8025 >
8026 >
8027 >
8028 >
8029 >
8030 > for ac_header in sys/select.h sys/socket.h
8031 > do
8032 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8033 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8034 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8035 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8036 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8037 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8038 > fi
8039 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8040 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8041 > else
8042 >  # Is the header compilable?
8043 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8044 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8045 > cat >conftest.$ac_ext <<_ACEOF
8046 > /* confdefs.h.  */
8047 > _ACEOF
8048 > cat confdefs.h >>conftest.$ac_ext
8049 > cat >>conftest.$ac_ext <<_ACEOF
8050 > /* end confdefs.h.  */
8051 > $ac_includes_default
8052 > #include <$ac_header>
8053 > _ACEOF
8054 > rm -f conftest.$ac_objext
8055 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8056 >  (eval $ac_compile) 2>conftest.er1
8057 >  ac_status=$?
8058 >  grep -v '^ *+' conftest.er1 >conftest.err
8059 >  rm -f conftest.er1
8060 >  cat conftest.err >&5
8061 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8062 >  (exit $ac_status); } &&
8063 >         { ac_try='test -z "$ac_c_werror_flag"
8064 >                         || test ! -s conftest.err'
8065 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8066 >  (eval $ac_try) 2>&5
8067 >  ac_status=$?
8068 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8069 >  (exit $ac_status); }; } &&
8070 >         { ac_try='test -s conftest.$ac_objext'
8071 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8072 >  (eval $ac_try) 2>&5
8073 >  ac_status=$?
8074 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8075 >  (exit $ac_status); }; }; then
8076 >  ac_header_compiler=yes
8077 > else
8078 >  echo "$as_me: failed program was:" >&5
8079 > sed 's/^/| /' conftest.$ac_ext >&5
8080 >
8081 > ac_header_compiler=no
8082 > fi
8083 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8084 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8085 > echo "${ECHO_T}$ac_header_compiler" >&6
8086 >
8087 > # Is the header present?
8088 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8089 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8090 > cat >conftest.$ac_ext <<_ACEOF
8091 > /* confdefs.h.  */
8092 > _ACEOF
8093 > cat confdefs.h >>conftest.$ac_ext
8094 > cat >>conftest.$ac_ext <<_ACEOF
8095 > /* end confdefs.h.  */
8096 > #include <$ac_header>
8097 > _ACEOF
8098 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8099 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8100 >  ac_status=$?
8101 >  grep -v '^ *+' conftest.er1 >conftest.err
8102 >  rm -f conftest.er1
8103 >  cat conftest.err >&5
8104 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8105 >  (exit $ac_status); } >/dev/null; then
8106 >  if test -s conftest.err; then
8107 >    ac_cpp_err=$ac_c_preproc_warn_flag
8108 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8109 >  else
8110 >    ac_cpp_err=
8111 >  fi
8112 > else
8113 >  ac_cpp_err=yes
8114 > fi
8115 > if test -z "$ac_cpp_err"; then
8116 >  ac_header_preproc=yes
8117 > else
8118 >  echo "$as_me: failed program was:" >&5
8119 > sed 's/^/| /' conftest.$ac_ext >&5
8120 >
8121 >  ac_header_preproc=no
8122 > fi
8123 > rm -f conftest.err conftest.$ac_ext
8124 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8125 > echo "${ECHO_T}$ac_header_preproc" >&6
8126 >
8127 > # So?  What about this header?
8128 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8129 >  yes:no: )
8130 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8131 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8132 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8133 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8134 >    ac_header_preproc=yes
8135 >    ;;
8136 >  no:yes:* )
8137 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8138 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8139 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8140 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8141 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8142 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8143 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8144 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8145 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8146 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8147 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8148 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8149 >    (
8150 >      cat <<\_ASBOX
8151 > ## ------------------------------ ##
8152 > ## Report this to gezelter@nd.edu ##
8153 > ## ------------------------------ ##
8154 > _ASBOX
8155 >    ) |
8156 >      sed "s/^/$as_me: WARNING:     /" >&2
8157 >    ;;
8158 > esac
8159 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8160 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8161 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8162 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8163 > else
8164 >  eval "$as_ac_Header=\$ac_header_preproc"
8165 > fi
8166 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8167 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8168 >
8169 > fi
8170 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8171 >  cat >>confdefs.h <<_ACEOF
8172 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8173 > _ACEOF
8174 >
8175 > fi
8176 >
8177 > done
8178 >
8179 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8180 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8181 > if test "${ac_cv_func_select_args+set}" = set; then
8182 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8183 > else
8184 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8185 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8186 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8187 >   cat >conftest.$ac_ext <<_ACEOF
8188 > /* confdefs.h.  */
8189 > _ACEOF
8190 > cat confdefs.h >>conftest.$ac_ext
8191 > cat >>conftest.$ac_ext <<_ACEOF
8192 > /* end confdefs.h.  */
8193 > $ac_includes_default
8194 > #if HAVE_SYS_SELECT_H
8195 > # include <sys/select.h>
8196 > #endif
8197 > #if HAVE_SYS_SOCKET_H
8198 > # include <sys/socket.h>
8199 > #endif
8200 >
8201 > #ifdef FC_DUMMY_MAIN
8202 > #ifndef FC_DUMMY_MAIN_EQ_F77
8203 > #  ifdef __cplusplus
8204 >     extern "C"
8205 > #  endif
8206 >   int FC_DUMMY_MAIN() { return 1; }
8207 > #endif
8208 > #endif
8209 > int
8210 > main ()
8211 > {
8212 > extern int select ($ac_arg1,
8213 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8214 >                                            $ac_arg5);
8215 >  ;
8216 >  return 0;
8217 > }
8218 > _ACEOF
8219 > rm -f conftest.$ac_objext
8220 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8221 >  (eval $ac_compile) 2>conftest.er1
8222 >  ac_status=$?
8223 >  grep -v '^ *+' conftest.er1 >conftest.err
8224 >  rm -f conftest.er1
8225 >  cat conftest.err >&5
8226 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8227 >  (exit $ac_status); } &&
8228 >         { ac_try='test -z "$ac_c_werror_flag"
8229 >                         || test ! -s conftest.err'
8230 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8231 >  (eval $ac_try) 2>&5
8232 >  ac_status=$?
8233 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8234 >  (exit $ac_status); }; } &&
8235 >         { ac_try='test -s conftest.$ac_objext'
8236 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8237 >  (eval $ac_try) 2>&5
8238 >  ac_status=$?
8239 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8240 >  (exit $ac_status); }; }; then
8241 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8242 > else
8243 >  echo "$as_me: failed program was:" >&5
8244 > sed 's/^/| /' conftest.$ac_ext >&5
8245 >
8246 > fi
8247 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8248 >  done
8249 > done
8250 > done
8251 > # Provide a safe default value.
8252 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8253 >
8254 > fi
8255 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8256 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8257 > ac_save_IFS=$IFS; IFS=','
8258 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8259 > IFS=$ac_save_IFS
8260 > shift
8261 >
8262 > cat >>confdefs.h <<_ACEOF
8263 > #define SELECT_TYPE_ARG1 $1
8264 > _ACEOF
8265 >
8266 >
8267 > cat >>confdefs.h <<_ACEOF
8268 > #define SELECT_TYPE_ARG234 ($2)
8269 > _ACEOF
8270 >
8271 >
8272 > cat >>confdefs.h <<_ACEOF
8273 > #define SELECT_TYPE_ARG5 ($3)
8274 > _ACEOF
8275 >
8276 > rm -f conftest*
8277 >
8278 >
8279 > for ac_func in strftime
8280 > do
8281 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8282 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8283 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8284 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8285 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8286 > else
8287 >  cat >conftest.$ac_ext <<_ACEOF
8288 > /* confdefs.h.  */
8289 > _ACEOF
8290 > cat confdefs.h >>conftest.$ac_ext
8291 > cat >>conftest.$ac_ext <<_ACEOF
8292 > /* end confdefs.h.  */
8293 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8294 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8295 > #define $ac_func innocuous_$ac_func
8296 >
8297 > /* System header to define __stub macros and hopefully few prototypes,
8298 >    which can conflict with char $ac_func (); below.
8299 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8300 >    <limits.h> exists even on freestanding compilers.  */
8301 >
8302 > #ifdef __STDC__
8303 > # include <limits.h>
8304 > #else
8305 > # include <assert.h>
8306 > #endif
8307 >
8308 > #undef $ac_func
8309 >
8310 > /* Override any gcc2 internal prototype to avoid an error.  */
8311 > #ifdef __cplusplus
8312 > extern "C"
8313 > {
8314 > #endif
8315 > /* We use char because int might match the return type of a gcc2
8316 >   builtin and then its argument prototype would still apply.  */
8317 > char $ac_func ();
8318 > /* The GNU C library defines this for functions which it implements
8319 >    to always fail with ENOSYS.  Some functions are actually named
8320 >    something starting with __ and the normal name is an alias.  */
8321 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8322 > choke me
8323 > #else
8324 > char (*f) () = $ac_func;
8325 > #endif
8326 > #ifdef __cplusplus
8327 > }
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 > return f != $ac_func;
8342 >  ;
8343 >  return 0;
8344 > }
8345 > _ACEOF
8346 > rm -f conftest.$ac_objext conftest$ac_exeext
8347 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8348 >  (eval $ac_link) 2>conftest.er1
8349 >  ac_status=$?
8350 >  grep -v '^ *+' conftest.er1 >conftest.err
8351 >  rm -f conftest.er1
8352 >  cat conftest.err >&5
8353 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8354 >  (exit $ac_status); } &&
8355 >         { ac_try='test -z "$ac_c_werror_flag"
8356 >                         || test ! -s conftest.err'
8357 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8358 >  (eval $ac_try) 2>&5
8359 >  ac_status=$?
8360 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8361 >  (exit $ac_status); }; } &&
8362 >         { ac_try='test -s conftest$ac_exeext'
8363 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8364 >  (eval $ac_try) 2>&5
8365 >  ac_status=$?
8366 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8367 >  (exit $ac_status); }; }; then
8368 >  eval "$as_ac_var=yes"
8369 > else
8370 >  echo "$as_me: failed program was:" >&5
8371 > sed 's/^/| /' conftest.$ac_ext >&5
8372 >
8373 > eval "$as_ac_var=no"
8374 > fi
8375 > rm -f conftest.err conftest.$ac_objext \
8376 >      conftest$ac_exeext conftest.$ac_ext
8377 > fi
8378 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8379 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8380 > if test `eval echo '${'$as_ac_var'}'` = yes; then
8381 >  cat >>confdefs.h <<_ACEOF
8382 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8383 > _ACEOF
8384 >
8385 > else
8386 >  # strftime is in -lintl on SCO UNIX.
8387 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
8388 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
8389 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
8390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8391 > else
8392 >  ac_check_lib_save_LIBS=$LIBS
8393 > LIBS="-lintl  $LIBS"
8394 > cat >conftest.$ac_ext <<_ACEOF
8395 > /* confdefs.h.  */
8396 > _ACEOF
8397 > cat confdefs.h >>conftest.$ac_ext
8398 > cat >>conftest.$ac_ext <<_ACEOF
8399 > /* end confdefs.h.  */
8400 >
8401 > /* Override any gcc2 internal prototype to avoid an error.  */
8402 > #ifdef __cplusplus
8403 > extern "C"
8404 > #endif
8405 > /* We use char because int might match the return type of a gcc2
8406 >   builtin and then its argument prototype would still apply.  */
8407 > char strftime ();
8408 > #ifdef FC_DUMMY_MAIN
8409 > #ifndef FC_DUMMY_MAIN_EQ_F77
8410 > #  ifdef __cplusplus
8411 >     extern "C"
8412 > #  endif
8413 >   int FC_DUMMY_MAIN() { return 1; }
8414 > #endif
8415 > #endif
8416 > int
8417 > main ()
8418 > {
8419 > strftime ();
8420 >  ;
8421 >  return 0;
8422 > }
8423 > _ACEOF
8424 > rm -f conftest.$ac_objext conftest$ac_exeext
8425 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8426 >  (eval $ac_link) 2>conftest.er1
8427 >  ac_status=$?
8428 >  grep -v '^ *+' conftest.er1 >conftest.err
8429 >  rm -f conftest.er1
8430 >  cat conftest.err >&5
8431 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8432 >  (exit $ac_status); } &&
8433 >         { ac_try='test -z "$ac_c_werror_flag"
8434 >                         || test ! -s conftest.err'
8435 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8436 >  (eval $ac_try) 2>&5
8437 >  ac_status=$?
8438 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8439 >  (exit $ac_status); }; } &&
8440 >         { ac_try='test -s conftest$ac_exeext'
8441 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8442 >  (eval $ac_try) 2>&5
8443 >  ac_status=$?
8444 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8445 >  (exit $ac_status); }; }; then
8446 >  ac_cv_lib_intl_strftime=yes
8447 > else
8448 >  echo "$as_me: failed program was:" >&5
8449 > sed 's/^/| /' conftest.$ac_ext >&5
8450 >
8451 > ac_cv_lib_intl_strftime=no
8452 > fi
8453 > rm -f conftest.err conftest.$ac_objext \
8454 >      conftest$ac_exeext conftest.$ac_ext
8455 > LIBS=$ac_check_lib_save_LIBS
8456 > fi
8457 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
8458 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
8459 > if test $ac_cv_lib_intl_strftime = yes; then
8460 >  cat >>confdefs.h <<\_ACEOF
8461 > #define HAVE_STRFTIME 1
8462 > _ACEOF
8463 >
8464 > LIBS="-lintl $LIBS"
8465 > fi
8466 >
8467 > fi
8468 > done
8469 >
8470 > echo "$as_me:$LINENO: checking for working strtod" >&5
8471 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
8472 > if test "${ac_cv_func_strtod+set}" = set; then
8473 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8474 > else
8475 >  if test "$cross_compiling" = yes; then
8476 >  ac_cv_func_strtod=no
8477 > else
8478 >  cat >conftest.$ac_ext <<_ACEOF
8479 > /* confdefs.h.  */
8480 > _ACEOF
8481 > cat confdefs.h >>conftest.$ac_ext
8482 > cat >>conftest.$ac_ext <<_ACEOF
8483 > /* end confdefs.h.  */
8484 >
8485 > double strtod ();
8486 > int
8487 > main()
8488 > {
8489 >  {
8490 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
8491 >    char *string = " +69";
8492 >    char *term;
8493 >    double value;
8494 >    value = strtod (string, &term);
8495 >    if (value != 69 || term != (string + 4))
8496 >      exit (1);
8497 >  }
8498 >
8499 >  {
8500 >    /* Under Solaris 2.4, strtod returns the wrong value for the
8501 >       terminating character under some conditions.  */
8502 >    char *string = "NaN";
8503 >    char *term;
8504 >    strtod (string, &term);
8505 >    if (term != string && *(term - 1) == 0)
8506 >      exit (1);
8507 >  }
8508 >  exit (0);
8509 > }
8510 >
8511 > _ACEOF
8512 > rm -f conftest$ac_exeext
8513 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8514 >  (eval $ac_link) 2>&5
8515 >  ac_status=$?
8516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8517 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8518 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8519 >  (eval $ac_try) 2>&5
8520 >  ac_status=$?
8521 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8522 >  (exit $ac_status); }; }; then
8523 >  ac_cv_func_strtod=yes
8524 > else
8525 >  echo "$as_me: program exited with status $ac_status" >&5
8526 > echo "$as_me: failed program was:" >&5
8527 > sed 's/^/| /' conftest.$ac_ext >&5
8528 >
8529 > ( exit $ac_status )
8530 > ac_cv_func_strtod=no
8531 > fi
8532 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8533 > fi
8534 > fi
8535 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
8536 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
8537 > if test $ac_cv_func_strtod = no; then
8538 >  case $LIBOBJS in
8539 >    "strtod.$ac_objext"   | \
8540 >  *" strtod.$ac_objext"   | \
8541 >    "strtod.$ac_objext "* | \
8542 >  *" strtod.$ac_objext "* ) ;;
8543 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
8544 > esac
8545 >
8546 > echo "$as_me:$LINENO: checking for pow" >&5
8547 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
8548 > if test "${ac_cv_func_pow+set}" = set; then
8549 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8550 > else
8551 >  cat >conftest.$ac_ext <<_ACEOF
8552 > /* confdefs.h.  */
8553 > _ACEOF
8554 > cat confdefs.h >>conftest.$ac_ext
8555 > cat >>conftest.$ac_ext <<_ACEOF
8556 > /* end confdefs.h.  */
8557 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
8558 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8559 > #define pow innocuous_pow
8560 >
8561 > /* System header to define __stub macros and hopefully few prototypes,
8562 >    which can conflict with char pow (); below.
8563 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8564 >    <limits.h> exists even on freestanding compilers.  */
8565 >
8566 > #ifdef __STDC__
8567 > # include <limits.h>
8568 > #else
8569 > # include <assert.h>
8570 > #endif
8571 >
8572 > #undef pow
8573 >
8574 > /* Override any gcc2 internal prototype to avoid an error.  */
8575 > #ifdef __cplusplus
8576 > extern "C"
8577 > {
8578 > #endif
8579 > /* We use char because int might match the return type of a gcc2
8580 >   builtin and then its argument prototype would still apply.  */
8581 > char pow ();
8582 > /* The GNU C library defines this for functions which it implements
8583 >    to always fail with ENOSYS.  Some functions are actually named
8584 >    something starting with __ and the normal name is an alias.  */
8585 > #if defined (__stub_pow) || defined (__stub___pow)
8586 > choke me
8587 > #else
8588 > char (*f) () = pow;
8589 > #endif
8590 > #ifdef __cplusplus
8591 > }
8592 > #endif
8593 >
8594 > #ifdef FC_DUMMY_MAIN
8595 > #ifndef FC_DUMMY_MAIN_EQ_F77
8596 > #  ifdef __cplusplus
8597 >     extern "C"
8598 > #  endif
8599 >   int FC_DUMMY_MAIN() { return 1; }
8600 > #endif
8601 > #endif
8602 > int
8603 > main ()
8604 > {
8605 > return f != pow;
8606 >  ;
8607 >  return 0;
8608 > }
8609 > _ACEOF
8610 > rm -f conftest.$ac_objext conftest$ac_exeext
8611 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8612 >  (eval $ac_link) 2>conftest.er1
8613 >  ac_status=$?
8614 >  grep -v '^ *+' conftest.er1 >conftest.err
8615 >  rm -f conftest.er1
8616 >  cat conftest.err >&5
8617 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8618 >  (exit $ac_status); } &&
8619 >         { ac_try='test -z "$ac_c_werror_flag"
8620 >                         || test ! -s conftest.err'
8621 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8622 >  (eval $ac_try) 2>&5
8623 >  ac_status=$?
8624 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8625 >  (exit $ac_status); }; } &&
8626 >         { ac_try='test -s conftest$ac_exeext'
8627 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8628 >  (eval $ac_try) 2>&5
8629 >  ac_status=$?
8630 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8631 >  (exit $ac_status); }; }; then
8632 >  ac_cv_func_pow=yes
8633 > else
8634 >  echo "$as_me: failed program was:" >&5
8635 > sed 's/^/| /' conftest.$ac_ext >&5
8636 >
8637 > ac_cv_func_pow=no
8638 > fi
8639 > rm -f conftest.err conftest.$ac_objext \
8640 >      conftest$ac_exeext conftest.$ac_ext
8641 > fi
8642 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
8643 > echo "${ECHO_T}$ac_cv_func_pow" >&6
8644 >
8645 > if test $ac_cv_func_pow = no; then
8646 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
8647 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
8648 > if test "${ac_cv_lib_m_pow+set}" = set; then
8649 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8650 > else
8651 >  ac_check_lib_save_LIBS=$LIBS
8652 > LIBS="-lm  $LIBS"
8653 > cat >conftest.$ac_ext <<_ACEOF
8654 > /* confdefs.h.  */
8655 > _ACEOF
8656 > cat confdefs.h >>conftest.$ac_ext
8657 > cat >>conftest.$ac_ext <<_ACEOF
8658 > /* end confdefs.h.  */
8659 >
8660 > /* Override any gcc2 internal prototype to avoid an error.  */
8661 > #ifdef __cplusplus
8662 > extern "C"
8663 > #endif
8664 > /* We use char because int might match the return type of a gcc2
8665 >   builtin and then its argument prototype would still apply.  */
8666 > char pow ();
8667 > #ifdef FC_DUMMY_MAIN
8668 > #ifndef FC_DUMMY_MAIN_EQ_F77
8669 > #  ifdef __cplusplus
8670 >     extern "C"
8671 > #  endif
8672 >   int FC_DUMMY_MAIN() { return 1; }
8673 > #endif
8674 > #endif
8675 > int
8676 > main ()
8677 > {
8678 > pow ();
8679 >  ;
8680 >  return 0;
8681 > }
8682 > _ACEOF
8683 > rm -f conftest.$ac_objext conftest$ac_exeext
8684 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8685 >  (eval $ac_link) 2>conftest.er1
8686 >  ac_status=$?
8687 >  grep -v '^ *+' conftest.er1 >conftest.err
8688 >  rm -f conftest.er1
8689 >  cat conftest.err >&5
8690 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8691 >  (exit $ac_status); } &&
8692 >         { ac_try='test -z "$ac_c_werror_flag"
8693 >                         || test ! -s conftest.err'
8694 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8695 >  (eval $ac_try) 2>&5
8696 >  ac_status=$?
8697 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8698 >  (exit $ac_status); }; } &&
8699 >         { ac_try='test -s conftest$ac_exeext'
8700 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8701 >  (eval $ac_try) 2>&5
8702 >  ac_status=$?
8703 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8704 >  (exit $ac_status); }; }; then
8705 >  ac_cv_lib_m_pow=yes
8706 > else
8707 >  echo "$as_me: failed program was:" >&5
8708 > sed 's/^/| /' conftest.$ac_ext >&5
8709 >
8710 > ac_cv_lib_m_pow=no
8711 > fi
8712 > rm -f conftest.err conftest.$ac_objext \
8713 >      conftest$ac_exeext conftest.$ac_ext
8714 > LIBS=$ac_check_lib_save_LIBS
8715 > fi
8716 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
8717 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
8718 > if test $ac_cv_lib_m_pow = yes; then
8719 >  POW_LIB=-lm
8720 > else
8721 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
8722 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
8723 > fi
8724 >
8725 > fi
8726 >
8727 > fi
8728 >
8729 >
8730 >
8731 >
8732 >
8733 >
8734 >
8735 >
8736 >
8737 >
8738 >
8739 >
8740 >
8741 >
8742 >
8743 >
8744 >
8745 >
8746 >
8747 >
8748 >
8749 >
8750 >
8751 >
8752 >
8753 >
8754 >
8755 > for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
8756 > do
8757 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8758 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8759 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8760 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8761 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8762 > else
8763 >  cat >conftest.$ac_ext <<_ACEOF
8764 > /* confdefs.h.  */
8765 > _ACEOF
8766 > cat confdefs.h >>conftest.$ac_ext
8767 > cat >>conftest.$ac_ext <<_ACEOF
8768 > /* end confdefs.h.  */
8769 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8770 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8771 > #define $ac_func innocuous_$ac_func
8772 >
8773 > /* System header to define __stub macros and hopefully few prototypes,
8774 >    which can conflict with char $ac_func (); below.
8775 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8776 >    <limits.h> exists even on freestanding compilers.  */
8777 >
8778 > #ifdef __STDC__
8779 > # include <limits.h>
8780 > #else
8781 > # include <assert.h>
8782 > #endif
8783 >
8784 > #undef $ac_func
8785 >
8786 > /* Override any gcc2 internal prototype to avoid an error.  */
8787 > #ifdef __cplusplus
8788 > extern "C"
8789 > {
8790 > #endif
8791 > /* We use char because int might match the return type of a gcc2
8792 >   builtin and then its argument prototype would still apply.  */
8793 > char $ac_func ();
8794 > /* The GNU C library defines this for functions which it implements
8795 >    to always fail with ENOSYS.  Some functions are actually named
8796 >    something starting with __ and the normal name is an alias.  */
8797 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8798 > choke me
8799 > #else
8800 > char (*f) () = $ac_func;
8801 > #endif
8802 > #ifdef __cplusplus
8803 > }
8804 > #endif
8805 >
8806 > #ifdef FC_DUMMY_MAIN
8807 > #ifndef FC_DUMMY_MAIN_EQ_F77
8808 > #  ifdef __cplusplus
8809 >     extern "C"
8810 > #  endif
8811 >   int FC_DUMMY_MAIN() { return 1; }
8812 > #endif
8813 > #endif
8814 > int
8815 > main ()
8816 > {
8817 > return f != $ac_func;
8818 >  ;
8819 >  return 0;
8820 > }
8821 > _ACEOF
8822 > rm -f conftest.$ac_objext conftest$ac_exeext
8823 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8824 >  (eval $ac_link) 2>conftest.er1
8825 >  ac_status=$?
8826 >  grep -v '^ *+' conftest.er1 >conftest.err
8827 >  rm -f conftest.er1
8828 >  cat conftest.err >&5
8829 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8830 >  (exit $ac_status); } &&
8831 >         { ac_try='test -z "$ac_c_werror_flag"
8832 >                         || test ! -s conftest.err'
8833 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8834 >  (eval $ac_try) 2>&5
8835 >  ac_status=$?
8836 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8837 >  (exit $ac_status); }; } &&
8838 >         { ac_try='test -s conftest$ac_exeext'
8839 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8840 >  (eval $ac_try) 2>&5
8841 >  ac_status=$?
8842 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8843 >  (exit $ac_status); }; }; then
8844 >  eval "$as_ac_var=yes"
8845 > else
8846 >  echo "$as_me: failed program was:" >&5
8847 > sed 's/^/| /' conftest.$ac_ext >&5
8848 >
8849 > eval "$as_ac_var=no"
8850 > fi
8851 > rm -f conftest.err conftest.$ac_objext \
8852 >      conftest$ac_exeext conftest.$ac_ext
8853 > fi
8854 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8855 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8856 > if test `eval echo '${'$as_ac_var'}'` = yes; then
8857 >  cat >>confdefs.h <<_ACEOF
8858 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8859 > _ACEOF
8860 >
8861 > fi
8862 > done
8863 >
8864 >
8865 > # special check for _system_configuration because AIX <4.3.2 do not
8866 > # contain the `physmem' member.
8867 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
8868 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
8869 > cat >conftest.$ac_ext <<_ACEOF
8870 > /* confdefs.h.  */
8871 > _ACEOF
8872 > cat confdefs.h >>conftest.$ac_ext
8873 > cat >>conftest.$ac_ext <<_ACEOF
8874 > /* end confdefs.h.  */
8875 > #include <sys/systemcfg.h>
8876 > #ifdef FC_DUMMY_MAIN
8877 > #ifndef FC_DUMMY_MAIN_EQ_F77
8878 > #  ifdef __cplusplus
8879 >     extern "C"
8880 > #  endif
8881 >   int FC_DUMMY_MAIN() { return 1; }
8882 > #endif
8883 > #endif
8884 > int
8885 > main ()
8886 > {
8887 > double x = _system_configuration.physmem;
8888 >  ;
8889 >  return 0;
8890 > }
8891 > _ACEOF
8892 > rm -f conftest.$ac_objext
8893 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8894 >  (eval $ac_compile) 2>conftest.er1
8895 >  ac_status=$?
8896 >  grep -v '^ *+' conftest.er1 >conftest.err
8897 >  rm -f conftest.er1
8898 >  cat conftest.err >&5
8899 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8900 >  (exit $ac_status); } &&
8901 >         { ac_try='test -z "$ac_c_werror_flag"
8902 >                         || test ! -s conftest.err'
8903 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8904 >  (eval $ac_try) 2>&5
8905 >  ac_status=$?
8906 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8907 >  (exit $ac_status); }; } &&
8908 >         { ac_try='test -s conftest.$ac_objext'
8909 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8910 >  (eval $ac_try) 2>&5
8911 >  ac_status=$?
8912 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8913 >  (exit $ac_status); }; }; then
8914 >  echo "$as_me:$LINENO: result: yes" >&5
8915 > echo "${ECHO_T}yes" >&6
8916 >
8917 > cat >>confdefs.h <<\_ACEOF
8918 > #define HAVE__SYSTEM_CONFIGURATION 1
8919 > _ACEOF
8920 >
8921 > else
8922 >  echo "$as_me: failed program was:" >&5
8923 > sed 's/^/| /' conftest.$ac_ext >&5
8924 >
8925 > echo "$as_me:$LINENO: result: no" >&5
8926 > echo "${ECHO_T}no" >&6
8927 > fi
8928 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8929 >
8930 >  # clean out junk possibly left behind by a previous configuration
8931 >  rm -f src/getopt.h
8932 >  # Check for getopt_long support
8933 >
8934 > for ac_header in getopt.h
8935 > do
8936 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8937 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8938 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8939 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8940 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8941 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8942 > fi
8943 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8944 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8945 > else
8946 >  # Is the header compilable?
8947 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8948 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8949 > cat >conftest.$ac_ext <<_ACEOF
8950 > /* confdefs.h.  */
8951 > _ACEOF
8952 > cat confdefs.h >>conftest.$ac_ext
8953 > cat >>conftest.$ac_ext <<_ACEOF
8954 > /* end confdefs.h.  */
8955 > $ac_includes_default
8956 > #include <$ac_header>
8957 > _ACEOF
8958 > rm -f conftest.$ac_objext
8959 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8960 >  (eval $ac_compile) 2>conftest.er1
8961 >  ac_status=$?
8962 >  grep -v '^ *+' conftest.er1 >conftest.err
8963 >  rm -f conftest.er1
8964 >  cat conftest.err >&5
8965 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8966 >  (exit $ac_status); } &&
8967 >         { ac_try='test -z "$ac_c_werror_flag"
8968 >                         || test ! -s conftest.err'
8969 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8970 >  (eval $ac_try) 2>&5
8971 >  ac_status=$?
8972 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8973 >  (exit $ac_status); }; } &&
8974 >         { ac_try='test -s conftest.$ac_objext'
8975 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8976 >  (eval $ac_try) 2>&5
8977 >  ac_status=$?
8978 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8979 >  (exit $ac_status); }; }; then
8980 >  ac_header_compiler=yes
8981 > else
8982 >  echo "$as_me: failed program was:" >&5
8983 > sed 's/^/| /' conftest.$ac_ext >&5
8984 >
8985 > ac_header_compiler=no
8986 > fi
8987 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8988 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8989 > echo "${ECHO_T}$ac_header_compiler" >&6
8990 >
8991 > # Is the header present?
8992 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8993 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8994 > cat >conftest.$ac_ext <<_ACEOF
8995 > /* confdefs.h.  */
8996 > _ACEOF
8997 > cat confdefs.h >>conftest.$ac_ext
8998 > cat >>conftest.$ac_ext <<_ACEOF
8999 > /* end confdefs.h.  */
9000 > #include <$ac_header>
9001 > _ACEOF
9002 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9003 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9004 >  ac_status=$?
9005 >  grep -v '^ *+' conftest.er1 >conftest.err
9006 >  rm -f conftest.er1
9007 >  cat conftest.err >&5
9008 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009 >  (exit $ac_status); } >/dev/null; then
9010 >  if test -s conftest.err; then
9011 >    ac_cpp_err=$ac_c_preproc_warn_flag
9012 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9013 >  else
9014 >    ac_cpp_err=
9015 >  fi
9016 > else
9017 >  ac_cpp_err=yes
9018 > fi
9019 > if test -z "$ac_cpp_err"; then
9020 >  ac_header_preproc=yes
9021 > else
9022 >  echo "$as_me: failed program was:" >&5
9023 > sed 's/^/| /' conftest.$ac_ext >&5
9024 >
9025 >  ac_header_preproc=no
9026 > fi
9027 > rm -f conftest.err conftest.$ac_ext
9028 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9029 > echo "${ECHO_T}$ac_header_preproc" >&6
9030 >
9031 > # So?  What about this header?
9032 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9033 >  yes:no: )
9034 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9035 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9036 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9037 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9038 >    ac_header_preproc=yes
9039 >    ;;
9040 >  no:yes:* )
9041 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9042 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9043 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9044 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9045 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9046 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9047 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9048 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9049 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9050 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9051 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9052 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9053 >    (
9054 >      cat <<\_ASBOX
9055 > ## ------------------------------ ##
9056 > ## Report this to gezelter@nd.edu ##
9057 > ## ------------------------------ ##
9058 > _ASBOX
9059 >    ) |
9060 >      sed "s/^/$as_me: WARNING:     /" >&2
9061 >    ;;
9062 > esac
9063 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9064 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9065 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9066 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9067 > else
9068 >  eval "$as_ac_Header=\$ac_header_preproc"
9069 > fi
9070 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9071 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9072 >
9073 > fi
9074 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9075 >  cat >>confdefs.h <<_ACEOF
9076 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9077 > _ACEOF
9078 >
9079 > fi
9080 >
9081 > done
9082 >
9083 >
9084 > for ac_func in getopt_long
9085 > do
9086 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9087 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9088 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9089 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9090 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9091 > else
9092 >  cat >conftest.$ac_ext <<_ACEOF
9093 > /* confdefs.h.  */
9094 > _ACEOF
9095 > cat confdefs.h >>conftest.$ac_ext
9096 > cat >>conftest.$ac_ext <<_ACEOF
9097 > /* end confdefs.h.  */
9098 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9099 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9100 > #define $ac_func innocuous_$ac_func
9101 >
9102 > /* System header to define __stub macros and hopefully few prototypes,
9103 >    which can conflict with char $ac_func (); below.
9104 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9105 >    <limits.h> exists even on freestanding compilers.  */
9106 >
9107 > #ifdef __STDC__
9108 > # include <limits.h>
9109 > #else
9110 > # include <assert.h>
9111 > #endif
9112 >
9113 > #undef $ac_func
9114 >
9115 > /* Override any gcc2 internal prototype to avoid an error.  */
9116 > #ifdef __cplusplus
9117 > extern "C"
9118 > {
9119 > #endif
9120 > /* We use char because int might match the return type of a gcc2
9121 >   builtin and then its argument prototype would still apply.  */
9122 > char $ac_func ();
9123 > /* The GNU C library defines this for functions which it implements
9124 >    to always fail with ENOSYS.  Some functions are actually named
9125 >    something starting with __ and the normal name is an alias.  */
9126 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9127 > choke me
9128 > #else
9129 > char (*f) () = $ac_func;
9130 > #endif
9131 > #ifdef __cplusplus
9132 > }
9133 > #endif
9134 >
9135 > #ifdef FC_DUMMY_MAIN
9136 > #ifndef FC_DUMMY_MAIN_EQ_F77
9137 > #  ifdef __cplusplus
9138 >     extern "C"
9139 > #  endif
9140 >   int FC_DUMMY_MAIN() { return 1; }
9141 > #endif
9142 > #endif
9143 > int
9144 > main ()
9145 > {
9146 > return f != $ac_func;
9147 >  ;
9148 >  return 0;
9149 > }
9150 > _ACEOF
9151 > rm -f conftest.$ac_objext conftest$ac_exeext
9152 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9153 >  (eval $ac_link) 2>conftest.er1
9154 >  ac_status=$?
9155 >  grep -v '^ *+' conftest.er1 >conftest.err
9156 >  rm -f conftest.er1
9157 >  cat conftest.err >&5
9158 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9159 >  (exit $ac_status); } &&
9160 >         { ac_try='test -z "$ac_c_werror_flag"
9161 >                         || test ! -s conftest.err'
9162 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9163 >  (eval $ac_try) 2>&5
9164 >  ac_status=$?
9165 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9166 >  (exit $ac_status); }; } &&
9167 >         { ac_try='test -s conftest$ac_exeext'
9168 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9169 >  (eval $ac_try) 2>&5
9170 >  ac_status=$?
9171 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9172 >  (exit $ac_status); }; }; then
9173 >  eval "$as_ac_var=yes"
9174 > else
9175 >  echo "$as_me: failed program was:" >&5
9176 > sed 's/^/| /' conftest.$ac_ext >&5
9177 >
9178 > eval "$as_ac_var=no"
9179 > fi
9180 > rm -f conftest.err conftest.$ac_objext \
9181 >      conftest$ac_exeext conftest.$ac_ext
9182 > fi
9183 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9184 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9185 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9186 >  cat >>confdefs.h <<_ACEOF
9187 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9188 > _ACEOF
9189 >
9190 > else
9191 >  # FreeBSD has a gnugetopt library for this
9192 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9193 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9194 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9196 > else
9197 >  ac_check_lib_save_LIBS=$LIBS
9198 > LIBS="-lgnugetopt  $LIBS"
9199 > cat >conftest.$ac_ext <<_ACEOF
9200 > /* confdefs.h.  */
9201 > _ACEOF
9202 > cat confdefs.h >>conftest.$ac_ext
9203 > cat >>conftest.$ac_ext <<_ACEOF
9204 > /* end confdefs.h.  */
9205 >
9206 > /* Override any gcc2 internal prototype to avoid an error.  */
9207 > #ifdef __cplusplus
9208 > extern "C"
9209 > #endif
9210 > /* We use char because int might match the return type of a gcc2
9211 >   builtin and then its argument prototype would still apply.  */
9212 > char getopt_long ();
9213 > #ifdef FC_DUMMY_MAIN
9214 > #ifndef FC_DUMMY_MAIN_EQ_F77
9215 > #  ifdef __cplusplus
9216 >     extern "C"
9217 > #  endif
9218 >   int FC_DUMMY_MAIN() { return 1; }
9219 > #endif
9220 > #endif
9221 > int
9222 > main ()
9223 > {
9224 > getopt_long ();
9225 >  ;
9226 >  return 0;
9227 > }
9228 > _ACEOF
9229 > rm -f conftest.$ac_objext conftest$ac_exeext
9230 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9231 >  (eval $ac_link) 2>conftest.er1
9232 >  ac_status=$?
9233 >  grep -v '^ *+' conftest.er1 >conftest.err
9234 >  rm -f conftest.er1
9235 >  cat conftest.err >&5
9236 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9237 >  (exit $ac_status); } &&
9238 >         { ac_try='test -z "$ac_c_werror_flag"
9239 >                         || test ! -s conftest.err'
9240 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9241 >  (eval $ac_try) 2>&5
9242 >  ac_status=$?
9243 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9244 >  (exit $ac_status); }; } &&
9245 >         { ac_try='test -s conftest$ac_exeext'
9246 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9247 >  (eval $ac_try) 2>&5
9248 >  ac_status=$?
9249 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9250 >  (exit $ac_status); }; }; then
9251 >  ac_cv_lib_gnugetopt_getopt_long=yes
9252 > else
9253 >  echo "$as_me: failed program was:" >&5
9254 > sed 's/^/| /' conftest.$ac_ext >&5
9255 >
9256 > ac_cv_lib_gnugetopt_getopt_long=no
9257 > fi
9258 > rm -f conftest.err conftest.$ac_objext \
9259 >      conftest$ac_exeext conftest.$ac_ext
9260 > LIBS=$ac_check_lib_save_LIBS
9261 > fi
9262 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9263 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9264 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9265 >  cat >>confdefs.h <<\_ACEOF
9266 > #define HAVE_GETOPT_LONG 1
9267 > _ACEOF
9268 >
9269 > else
9270 >  # use the GNU replacement
9271 >      case $LIBOBJS in
9272 >    "getopt.$ac_objext"   | \
9273 >  *" getopt.$ac_objext"   | \
9274 >    "getopt.$ac_objext "* | \
9275 >  *" getopt.$ac_objext "* ) ;;
9276 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9277 > esac
9278 >
9279 >      case $LIBOBJS in
9280 >    "getopt1.$ac_objext"   | \
9281 >  *" getopt1.$ac_objext"   | \
9282 >    "getopt1.$ac_objext "* | \
9283 >  *" getopt1.$ac_objext "* ) ;;
9284 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9285 > esac
9286 >
9287 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9288 >
9289 > fi
9290 >
9291 > fi
9292 > done
9293 >
9294 >
9295 > ac_ext=cc
9296 > ac_cpp='$CXXCPP $CPPFLAGS'
9297 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9298 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9299 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9300 >
9301 >
9302 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9303 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9304 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9305 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9306 > else
9307 >
9308 >
9309 > ac_ext=cc
9310 > ac_cpp='$CXXCPP $CPPFLAGS'
9311 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9312 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9313 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9314 >
9315 > cat >conftest.$ac_ext <<_ACEOF
9316 > /* confdefs.h.  */
9317 > _ACEOF
9318 > cat confdefs.h >>conftest.$ac_ext
9319 > cat >>conftest.$ac_ext <<_ACEOF
9320 > /* end confdefs.h.  */
9321 > namespace Outer { namespace Inner { int i = 0; }}
9322 > #ifdef FC_DUMMY_MAIN
9323 > #ifndef FC_DUMMY_MAIN_EQ_F77
9324 > #  ifdef __cplusplus
9325 >     extern "C"
9326 > #  endif
9327 >   int FC_DUMMY_MAIN() { return 1; }
9328 > #endif
9329 > #endif
9330 > int
9331 > main ()
9332 > {
9333 > using namespace Outer::Inner; return i;
9334 >  ;
9335 >  return 0;
9336 > }
9337 > _ACEOF
9338 > rm -f conftest.$ac_objext
9339 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9340 >  (eval $ac_compile) 2>conftest.er1
9341 >  ac_status=$?
9342 >  grep -v '^ *+' conftest.er1 >conftest.err
9343 >  rm -f conftest.er1
9344 >  cat conftest.err >&5
9345 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9346 >  (exit $ac_status); } &&
9347 >         { ac_try='test -z "$ac_cxx_werror_flag"
9348 >                         || test ! -s conftest.err'
9349 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9350 >  (eval $ac_try) 2>&5
9351 >  ac_status=$?
9352 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9353 >  (exit $ac_status); }; } &&
9354 >         { ac_try='test -s conftest.$ac_objext'
9355 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9356 >  (eval $ac_try) 2>&5
9357 >  ac_status=$?
9358 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9359 >  (exit $ac_status); }; }; then
9360 >  ac_cv_cxx_namespaces=yes
9361 > else
9362 >  echo "$as_me: failed program was:" >&5
9363 > sed 's/^/| /' conftest.$ac_ext >&5
9364 >
9365 > ac_cv_cxx_namespaces=no
9366 > fi
9367 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9368 > ac_ext=cc
9369 > ac_cpp='$CXXCPP $CPPFLAGS'
9370 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9371 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9372 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9373 >
9374 >
9375 > fi
9376 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
9377 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
9378 > if test "$ac_cv_cxx_namespaces" = yes; then
9379 >
9380 > cat >>confdefs.h <<\_ACEOF
9381 > #define HAVE_NAMESPACES
9382 > _ACEOF
9383 >
9384 > fi
9385 >
9386 > ac_ext=cc
9387 > ac_cpp='$CXXCPP $CPPFLAGS'
9388 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9389 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9390 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9391 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
9392 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
9393 > if test -z "$CXXCPP"; then
9394 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
9395 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9396 > else
9397 >      # Double quotes because CXXCPP needs to be expanded
9398 >    for CXXCPP in "$CXX -E" "/lib/cpp"
9399 >    do
9400 >      ac_preproc_ok=false
9401 > for ac_cxx_preproc_warn_flag in '' yes
9402 > do
9403 >  # Use a header file that comes with gcc, so configuring glibc
9404 >  # with a fresh cross-compiler works.
9405 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9406 >  # <limits.h> exists even on freestanding compilers.
9407 >  # On the NeXT, cc -E runs the code through the compiler's parser,
9408 >  # not just through cpp. "Syntax error" is here to catch this case.
9409 >  cat >conftest.$ac_ext <<_ACEOF
9410 > /* confdefs.h.  */
9411 > _ACEOF
9412 > cat confdefs.h >>conftest.$ac_ext
9413 > cat >>conftest.$ac_ext <<_ACEOF
9414 > /* end confdefs.h.  */
9415 > #ifdef __STDC__
9416 > # include <limits.h>
9417 > #else
9418 > # include <assert.h>
9419 > #endif
9420 >                     Syntax error
9421 > _ACEOF
9422 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9423 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9424 >  ac_status=$?
9425 >  grep -v '^ *+' conftest.er1 >conftest.err
9426 >  rm -f conftest.er1
9427 >  cat conftest.err >&5
9428 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9429 >  (exit $ac_status); } >/dev/null; then
9430 >  if test -s conftest.err; then
9431 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9432 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9433 >  else
9434 >    ac_cpp_err=
9435 >  fi
9436 > else
9437 >  ac_cpp_err=yes
9438 > fi
9439 > if test -z "$ac_cpp_err"; then
9440 >  :
9441 > else
9442 >  echo "$as_me: failed program was:" >&5
9443 > sed 's/^/| /' conftest.$ac_ext >&5
9444 >
9445 >  # Broken: fails on valid input.
9446 > continue
9447 > fi
9448 > rm -f conftest.err conftest.$ac_ext
9449 >
9450 >  # OK, works on sane cases.  Now check whether non-existent headers
9451 >  # can be detected and how.
9452 >  cat >conftest.$ac_ext <<_ACEOF
9453 > /* confdefs.h.  */
9454 > _ACEOF
9455 > cat confdefs.h >>conftest.$ac_ext
9456 > cat >>conftest.$ac_ext <<_ACEOF
9457 > /* end confdefs.h.  */
9458 > #include <ac_nonexistent.h>
9459 > _ACEOF
9460 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9461 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9462 >  ac_status=$?
9463 >  grep -v '^ *+' conftest.er1 >conftest.err
9464 >  rm -f conftest.er1
9465 >  cat conftest.err >&5
9466 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9467 >  (exit $ac_status); } >/dev/null; then
9468 >  if test -s conftest.err; then
9469 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9470 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9471 >  else
9472 >    ac_cpp_err=
9473 >  fi
9474 > else
9475 >  ac_cpp_err=yes
9476 > fi
9477 > if test -z "$ac_cpp_err"; then
9478 >  # Broken: success on invalid input.
9479 > continue
9480 > else
9481 >  echo "$as_me: failed program was:" >&5
9482 > sed 's/^/| /' conftest.$ac_ext >&5
9483 >
9484 >  # Passes both tests.
9485 > ac_preproc_ok=:
9486 > break
9487 > fi
9488 > rm -f conftest.err conftest.$ac_ext
9489 >
9490 > done
9491 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9492 > rm -f conftest.err conftest.$ac_ext
9493 > if $ac_preproc_ok; then
9494 >  break
9495 > fi
9496 >
9497 >    done
9498 >    ac_cv_prog_CXXCPP=$CXXCPP
9499 >
9500 > fi
9501 >  CXXCPP=$ac_cv_prog_CXXCPP
9502 > else
9503 >  ac_cv_prog_CXXCPP=$CXXCPP
9504 > fi
9505 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
9506 > echo "${ECHO_T}$CXXCPP" >&6
9507 > ac_preproc_ok=false
9508 > for ac_cxx_preproc_warn_flag in '' yes
9509 > do
9510 >  # Use a header file that comes with gcc, so configuring glibc
9511 >  # with a fresh cross-compiler works.
9512 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9513 >  # <limits.h> exists even on freestanding compilers.
9514 >  # On the NeXT, cc -E runs the code through the compiler's parser,
9515 >  # not just through cpp. "Syntax error" is here to catch this case.
9516 >  cat >conftest.$ac_ext <<_ACEOF
9517 > /* confdefs.h.  */
9518 > _ACEOF
9519 > cat confdefs.h >>conftest.$ac_ext
9520 > cat >>conftest.$ac_ext <<_ACEOF
9521 > /* end confdefs.h.  */
9522 > #ifdef __STDC__
9523 > # include <limits.h>
9524 > #else
9525 > # include <assert.h>
9526 > #endif
9527 >                     Syntax error
9528 > _ACEOF
9529 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9530 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9531 >  ac_status=$?
9532 >  grep -v '^ *+' conftest.er1 >conftest.err
9533 >  rm -f conftest.er1
9534 >  cat conftest.err >&5
9535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9536 >  (exit $ac_status); } >/dev/null; then
9537 >  if test -s conftest.err; then
9538 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9539 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9540 >  else
9541 >    ac_cpp_err=
9542 >  fi
9543 > else
9544 >  ac_cpp_err=yes
9545 > fi
9546 > if test -z "$ac_cpp_err"; then
9547 >  :
9548 > else
9549 >  echo "$as_me: failed program was:" >&5
9550 > sed 's/^/| /' conftest.$ac_ext >&5
9551 >
9552 >  # Broken: fails on valid input.
9553 > continue
9554 > fi
9555 > rm -f conftest.err conftest.$ac_ext
9556 >
9557 >  # OK, works on sane cases.  Now check whether non-existent headers
9558 >  # can be detected and how.
9559 >  cat >conftest.$ac_ext <<_ACEOF
9560 > /* confdefs.h.  */
9561 > _ACEOF
9562 > cat confdefs.h >>conftest.$ac_ext
9563 > cat >>conftest.$ac_ext <<_ACEOF
9564 > /* end confdefs.h.  */
9565 > #include <ac_nonexistent.h>
9566 > _ACEOF
9567 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9568 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9569 >  ac_status=$?
9570 >  grep -v '^ *+' conftest.er1 >conftest.err
9571 >  rm -f conftest.er1
9572 >  cat conftest.err >&5
9573 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9574 >  (exit $ac_status); } >/dev/null; then
9575 >  if test -s conftest.err; then
9576 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9577 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9578 >  else
9579 >    ac_cpp_err=
9580 >  fi
9581 > else
9582 >  ac_cpp_err=yes
9583 > fi
9584 > if test -z "$ac_cpp_err"; then
9585 >  # Broken: success on invalid input.
9586 > continue
9587 > else
9588 >  echo "$as_me: failed program was:" >&5
9589 > sed 's/^/| /' conftest.$ac_ext >&5
9590 >
9591 >  # Passes both tests.
9592 > ac_preproc_ok=:
9593 > break
9594 > fi
9595 > rm -f conftest.err conftest.$ac_ext
9596 >
9597 > done
9598 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9599 > rm -f conftest.err conftest.$ac_ext
9600 > if $ac_preproc_ok; then
9601 >  :
9602 > else
9603 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9604 > See \`config.log' for more details." >&5
9605 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9606 > See \`config.log' for more details." >&2;}
9607 >   { (exit 1); exit 1; }; }
9608 > fi
9609 >
9610 > ac_ext=cc
9611 > ac_cpp='$CXXCPP $CPPFLAGS'
9612 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9613 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9614 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9615 >
9616 >
9617 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
9618 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
9619 > if test "${ac_cv_cxx_have_stl+set}" = set; then
9620 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9621 > else
9622 >
9623 >
9624 >
9625 > ac_ext=cc
9626 > ac_cpp='$CXXCPP $CPPFLAGS'
9627 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9628 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9629 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9630 >
9631 > cat >conftest.$ac_ext <<_ACEOF
9632 > /* confdefs.h.  */
9633 > _ACEOF
9634 > cat confdefs.h >>conftest.$ac_ext
9635 > cat >>conftest.$ac_ext <<_ACEOF
9636 > /* end confdefs.h.  */
9637 > #include <list>
9638 > #include <deque>
9639 > #ifdef HAVE_NAMESPACES
9640 > using namespace std;
9641 > #endif
9642 > #ifdef FC_DUMMY_MAIN
9643 > #ifndef FC_DUMMY_MAIN_EQ_F77
9644 > #  ifdef __cplusplus
9645 >     extern "C"
9646 > #  endif
9647 >   int FC_DUMMY_MAIN() { return 1; }
9648 > #endif
9649 > #endif
9650 > int
9651 > main ()
9652 > {
9653 > list<int> x; x.push_back(5);
9654 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
9655 >  ;
9656 >  return 0;
9657 > }
9658 > _ACEOF
9659 > rm -f conftest.$ac_objext
9660 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9661 >  (eval $ac_compile) 2>conftest.er1
9662 >  ac_status=$?
9663 >  grep -v '^ *+' conftest.er1 >conftest.err
9664 >  rm -f conftest.er1
9665 >  cat conftest.err >&5
9666 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9667 >  (exit $ac_status); } &&
9668 >         { ac_try='test -z "$ac_cxx_werror_flag"
9669 >                         || test ! -s conftest.err'
9670 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9671 >  (eval $ac_try) 2>&5
9672 >  ac_status=$?
9673 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9674 >  (exit $ac_status); }; } &&
9675 >         { ac_try='test -s conftest.$ac_objext'
9676 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9677 >  (eval $ac_try) 2>&5
9678 >  ac_status=$?
9679 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9680 >  (exit $ac_status); }; }; then
9681 >  ac_cv_cxx_have_stl=yes
9682 > else
9683 >  echo "$as_me: failed program was:" >&5
9684 > sed 's/^/| /' conftest.$ac_ext >&5
9685 >
9686 > ac_cv_cxx_have_stl=no
9687 > fi
9688 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9689 > ac_ext=cc
9690 > ac_cpp='$CXXCPP $CPPFLAGS'
9691 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9692 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9693 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9694 >
9695 >
9696 > fi
9697 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
9698 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
9699 > if test "$ac_cv_cxx_have_stl" = yes; then
9700 >
9701 > cat >>confdefs.h <<\_ACEOF
9702 > #define HAVE_STL
9703 > _ACEOF
9704 >
9705 > fi
9706 >
9707 >
9708 >
9709 >  if test "${ac_cv_header_iostream+set}" = set; then
9710 >  echo "$as_me:$LINENO: checking for iostream" >&5
9711 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
9712 > if test "${ac_cv_header_iostream+set}" = set; then
9713 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9714 > fi
9715 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
9716 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
9717 > else
9718 >  # Is the header compilable?
9719 > echo "$as_me:$LINENO: checking iostream usability" >&5
9720 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
9721 > cat >conftest.$ac_ext <<_ACEOF
9722 > /* confdefs.h.  */
9723 > _ACEOF
9724 > cat confdefs.h >>conftest.$ac_ext
9725 > cat >>conftest.$ac_ext <<_ACEOF
9726 > /* end confdefs.h.  */
9727 > $ac_includes_default
9728 > #include <iostream>
9729 > _ACEOF
9730 > rm -f conftest.$ac_objext
9731 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9732 >  (eval $ac_compile) 2>conftest.er1
9733 >  ac_status=$?
9734 >  grep -v '^ *+' conftest.er1 >conftest.err
9735 >  rm -f conftest.er1
9736 >  cat conftest.err >&5
9737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9738 >  (exit $ac_status); } &&
9739 >         { ac_try='test -z "$ac_cxx_werror_flag"
9740 >                         || test ! -s conftest.err'
9741 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9742 >  (eval $ac_try) 2>&5
9743 >  ac_status=$?
9744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9745 >  (exit $ac_status); }; } &&
9746 >         { ac_try='test -s conftest.$ac_objext'
9747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9748 >  (eval $ac_try) 2>&5
9749 >  ac_status=$?
9750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9751 >  (exit $ac_status); }; }; then
9752 >  ac_header_compiler=yes
9753 > else
9754 >  echo "$as_me: failed program was:" >&5
9755 > sed 's/^/| /' conftest.$ac_ext >&5
9756 >
9757 > ac_header_compiler=no
9758 > fi
9759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9760 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9761 > echo "${ECHO_T}$ac_header_compiler" >&6
9762 >
9763 > # Is the header present?
9764 > echo "$as_me:$LINENO: checking iostream presence" >&5
9765 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
9766 > cat >conftest.$ac_ext <<_ACEOF
9767 > /* confdefs.h.  */
9768 > _ACEOF
9769 > cat confdefs.h >>conftest.$ac_ext
9770 > cat >>conftest.$ac_ext <<_ACEOF
9771 > /* end confdefs.h.  */
9772 > #include <iostream>
9773 > _ACEOF
9774 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9775 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9776 >  ac_status=$?
9777 >  grep -v '^ *+' conftest.er1 >conftest.err
9778 >  rm -f conftest.er1
9779 >  cat conftest.err >&5
9780 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9781 >  (exit $ac_status); } >/dev/null; then
9782 >  if test -s conftest.err; then
9783 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9784 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9785 >  else
9786 >    ac_cpp_err=
9787 >  fi
9788 > else
9789 >  ac_cpp_err=yes
9790 > fi
9791 > if test -z "$ac_cpp_err"; then
9792 >  ac_header_preproc=yes
9793 > else
9794 >  echo "$as_me: failed program was:" >&5
9795 > sed 's/^/| /' conftest.$ac_ext >&5
9796 >
9797 >  ac_header_preproc=no
9798 > fi
9799 > rm -f conftest.err conftest.$ac_ext
9800 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9801 > echo "${ECHO_T}$ac_header_preproc" >&6
9802 >
9803 > # So?  What about this header?
9804 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9805 >  yes:no: )
9806 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
9807 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
9808 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
9809 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
9810 >    ac_header_preproc=yes
9811 >    ;;
9812 >  no:yes:* )
9813 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
9814 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
9815 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
9816 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
9817 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
9818 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
9819 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
9820 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
9821 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
9822 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
9823 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
9824 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
9825 >    (
9826 >      cat <<\_ASBOX
9827 > ## ------------------------------ ##
9828 > ## Report this to gezelter@nd.edu ##
9829 > ## ------------------------------ ##
9830 > _ASBOX
9831 >    ) |
9832 >      sed "s/^/$as_me: WARNING:     /" >&2
9833 >    ;;
9834 > esac
9835 > echo "$as_me:$LINENO: checking for iostream" >&5
9836 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
9837 > if test "${ac_cv_header_iostream+set}" = set; then
9838 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9839 > else
9840 >  ac_cv_header_iostream=$ac_header_preproc
9841 > fi
9842 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
9843 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
9844 >
9845 > fi
9846 > if test $ac_cv_header_iostream = yes; then
9847 >
9848 >
9849 > cat >>confdefs.h <<\_ACEOF
9850 > #define HAVE_IOSTREAM 1
9851 > _ACEOF
9852 >
9853 >
9854 > else
9855 >
9856 >
9857 > for ac_header in iostream.h
9858 > do
9859 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9860 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9861 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9862 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9863 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9864 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9865 > fi
9866 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9867 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9868 > else
9869 >  # Is the header compilable?
9870 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9871 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9872 > cat >conftest.$ac_ext <<_ACEOF
9873 > /* confdefs.h.  */
9874 > _ACEOF
9875 > cat confdefs.h >>conftest.$ac_ext
9876 > cat >>conftest.$ac_ext <<_ACEOF
9877 > /* end confdefs.h.  */
9878 > $ac_includes_default
9879 > #include <$ac_header>
9880 > _ACEOF
9881 > rm -f conftest.$ac_objext
9882 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9883 >  (eval $ac_compile) 2>conftest.er1
9884 >  ac_status=$?
9885 >  grep -v '^ *+' conftest.er1 >conftest.err
9886 >  rm -f conftest.er1
9887 >  cat conftest.err >&5
9888 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9889 >  (exit $ac_status); } &&
9890 >         { ac_try='test -z "$ac_cxx_werror_flag"
9891 >                         || test ! -s conftest.err'
9892 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9893 >  (eval $ac_try) 2>&5
9894 >  ac_status=$?
9895 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9896 >  (exit $ac_status); }; } &&
9897 >         { ac_try='test -s conftest.$ac_objext'
9898 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9899 >  (eval $ac_try) 2>&5
9900 >  ac_status=$?
9901 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9902 >  (exit $ac_status); }; }; then
9903 >  ac_header_compiler=yes
9904 > else
9905 >  echo "$as_me: failed program was:" >&5
9906 > sed 's/^/| /' conftest.$ac_ext >&5
9907 >
9908 > ac_header_compiler=no
9909 > fi
9910 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9911 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9912 > echo "${ECHO_T}$ac_header_compiler" >&6
9913 >
9914 > # Is the header present?
9915 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9916 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9917 > cat >conftest.$ac_ext <<_ACEOF
9918 > /* confdefs.h.  */
9919 > _ACEOF
9920 > cat confdefs.h >>conftest.$ac_ext
9921 > cat >>conftest.$ac_ext <<_ACEOF
9922 > /* end confdefs.h.  */
9923 > #include <$ac_header>
9924 > _ACEOF
9925 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9926 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9927 >  ac_status=$?
9928 >  grep -v '^ *+' conftest.er1 >conftest.err
9929 >  rm -f conftest.er1
9930 >  cat conftest.err >&5
9931 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9932 >  (exit $ac_status); } >/dev/null; then
9933 >  if test -s conftest.err; then
9934 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
9935 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
9936 >  else
9937 >    ac_cpp_err=
9938 >  fi
9939 > else
9940 >  ac_cpp_err=yes
9941 > fi
9942 > if test -z "$ac_cpp_err"; then
9943 >  ac_header_preproc=yes
9944 > else
9945 >  echo "$as_me: failed program was:" >&5
9946 > sed 's/^/| /' conftest.$ac_ext >&5
9947 >
9948 >  ac_header_preproc=no
9949 > fi
9950 > rm -f conftest.err conftest.$ac_ext
9951 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9952 > echo "${ECHO_T}$ac_header_preproc" >&6
9953 >
9954 > # So?  What about this header?
9955 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9956 >  yes:no: )
9957 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9958 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9959 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9960 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9961 >    ac_header_preproc=yes
9962 >    ;;
9963 >  no:yes:* )
9964 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9965 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9966 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9967 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9968 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9969 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9970 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9971 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9972 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9973 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9974 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9975 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9976 >    (
9977 >      cat <<\_ASBOX
9978 > ## ------------------------------ ##
9979 > ## Report this to gezelter@nd.edu ##
9980 > ## ------------------------------ ##
9981 > _ASBOX
9982 >    ) |
9983 >      sed "s/^/$as_me: WARNING:     /" >&2
9984 >    ;;
9985 > esac
9986 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9987 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9988 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9989 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9990 > else
9991 >  eval "$as_ac_Header=\$ac_header_preproc"
9992 > fi
9993 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9994 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9995 >
9996 > fi
9997 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9998 >  cat >>confdefs.h <<_ACEOF
9999 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10000 > _ACEOF
10001 >
10002 > fi
10003 >
10004 > done
10005 >
10006 >
10007 > fi
10008 >
10009 >
10010 >
10011 >
10012 >  if test "${ac_cv_header_iomanip+set}" = set; then
10013 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10014 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10015 > if test "${ac_cv_header_iomanip+set}" = set; then
10016 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10017 > fi
10018 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10019 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10020 > else
10021 >  # Is the header compilable?
10022 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10023 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10024 > cat >conftest.$ac_ext <<_ACEOF
10025 > /* confdefs.h.  */
10026 > _ACEOF
10027 > cat confdefs.h >>conftest.$ac_ext
10028 > cat >>conftest.$ac_ext <<_ACEOF
10029 > /* end confdefs.h.  */
10030 > $ac_includes_default
10031 > #include <iomanip>
10032 > _ACEOF
10033 > rm -f conftest.$ac_objext
10034 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10035 >  (eval $ac_compile) 2>conftest.er1
10036 >  ac_status=$?
10037 >  grep -v '^ *+' conftest.er1 >conftest.err
10038 >  rm -f conftest.er1
10039 >  cat conftest.err >&5
10040 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10041 >  (exit $ac_status); } &&
10042 >         { ac_try='test -z "$ac_cxx_werror_flag"
10043 >                         || test ! -s conftest.err'
10044 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10045 >  (eval $ac_try) 2>&5
10046 >  ac_status=$?
10047 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10048 >  (exit $ac_status); }; } &&
10049 >         { ac_try='test -s conftest.$ac_objext'
10050 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10051 >  (eval $ac_try) 2>&5
10052 >  ac_status=$?
10053 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10054 >  (exit $ac_status); }; }; then
10055 >  ac_header_compiler=yes
10056 > else
10057 >  echo "$as_me: failed program was:" >&5
10058 > sed 's/^/| /' conftest.$ac_ext >&5
10059  
10060 <        else
4188 <            # The version of the Intel compiler that I have refuses to let
4189 <            # you put the "work catalog" list anywhere but the current
4190 <            # directory. For example, you cannot in
4191 <         :
4192 <        fi
4193 <   fi
4194 <   if test -z "MODDIRFLAG" ; then
4195 <       echo "$as_me:$LINENO: result: unknown" >&5
4196 < echo "${ECHO_T}unknown" >&6
4197 <   fi
4198 <
4199 <
4200 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4201 <   if test $madedir = 1 ; then rmdir conf ; fi
10060 > ac_header_compiler=no
10061   fi
10062 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10063 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10064 + echo "${ECHO_T}$ac_header_compiler" >&6
10065  
10066 <
10067 < ac_ext=c
10068 < ac_cpp='$CPP $CPPFLAGS'
10069 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4208 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4209 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4210 <
4211 <
4212 < ac_ext=c
4213 < ac_cpp='$CPP $CPPFLAGS'
4214 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4215 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4216 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4217 <
4218 < ac_ext=c
4219 < ac_cpp='$CPP $CPPFLAGS'
4220 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4221 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4222 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4223 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4224 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4225 < # On Suns, sometimes $CPP names a directory.
4226 < if test -n "$CPP" && test -d "$CPP"; then
4227 <  CPP=
4228 < fi
4229 < if test -z "$CPP"; then
4230 <  if test "${ac_cv_prog_CPP+set}" = set; then
4231 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4232 < else
4233 <      # Double quotes because CPP needs to be expanded
4234 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4235 <    do
4236 <      ac_preproc_ok=false
4237 < for ac_c_preproc_warn_flag in '' yes
4238 < do
4239 <  # Use a header file that comes with gcc, so configuring glibc
4240 <  # with a fresh cross-compiler works.
4241 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4242 <  # <limits.h> exists even on freestanding compilers.
4243 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4244 <  # not just through cpp. "Syntax error" is here to catch this case.
4245 <  cat >conftest.$ac_ext <<_ACEOF
10066 > # Is the header present?
10067 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10068 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10069 > cat >conftest.$ac_ext <<_ACEOF
10070   /* confdefs.h.  */
10071   _ACEOF
10072   cat confdefs.h >>conftest.$ac_ext
10073   cat >>conftest.$ac_ext <<_ACEOF
10074   /* end confdefs.h.  */
10075 < #ifdef __STDC__
4252 < # include <limits.h>
4253 < #else
4254 < # include <assert.h>
4255 < #endif
4256 <                     Syntax error
10075 > #include <iomanip>
10076   _ACEOF
10077   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10078    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4264 | Line 10083 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10083    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10084    (exit $ac_status); } >/dev/null; then
10085    if test -s conftest.err; then
10086 <    ac_cpp_err=$ac_c_preproc_warn_flag
10087 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10086 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10087 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10088    else
10089      ac_cpp_err=
10090    fi
# Line 4273 | Line 10092 | if test -z "$ac_cpp_err"; then
10092    ac_cpp_err=yes
10093   fi
10094   if test -z "$ac_cpp_err"; then
10095 <  :
10095 >  ac_header_preproc=yes
10096   else
10097    echo "$as_me: failed program was:" >&5
10098   sed 's/^/| /' conftest.$ac_ext >&5
10099  
10100 <  # Broken: fails on valid input.
4282 < continue
10100 >  ac_header_preproc=no
10101   fi
10102   rm -f conftest.err conftest.$ac_ext
10103 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10104 + echo "${ECHO_T}$ac_header_preproc" >&6
10105  
10106 <  # OK, works on sane cases.  Now check whether non-existent headers
10107 <  # can be detected and how.
10108 <  cat >conftest.$ac_ext <<_ACEOF
10106 > # So?  What about this header?
10107 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10108 >  yes:no: )
10109 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10110 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10111 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10112 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10113 >    ac_header_preproc=yes
10114 >    ;;
10115 >  no:yes:* )
10116 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10117 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10118 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10119 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10120 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10121 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10122 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10123 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10124 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10125 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10126 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10127 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10128 >    (
10129 >      cat <<\_ASBOX
10130 > ## ------------------------------ ##
10131 > ## Report this to gezelter@nd.edu ##
10132 > ## ------------------------------ ##
10133 > _ASBOX
10134 >    ) |
10135 >      sed "s/^/$as_me: WARNING:     /" >&2
10136 >    ;;
10137 > esac
10138 > echo "$as_me:$LINENO: checking for iomanip" >&5
10139 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10140 > if test "${ac_cv_header_iomanip+set}" = set; then
10141 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10142 > else
10143 >  ac_cv_header_iomanip=$ac_header_preproc
10144 > fi
10145 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10146 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10147 >
10148 > fi
10149 > if test $ac_cv_header_iomanip = yes; then
10150 >
10151 >
10152 > cat >>confdefs.h <<\_ACEOF
10153 > #define HAVE_IOMANIP 1
10154 > _ACEOF
10155 >
10156 >
10157 > else
10158 >
10159 >
10160 > for ac_header in iomanip.h
10161 > do
10162 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10163 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10164 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10165 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10166 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10167 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10168 > fi
10169 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10170 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10171 > else
10172 >  # Is the header compilable?
10173 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10174 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10175 > cat >conftest.$ac_ext <<_ACEOF
10176   /* confdefs.h.  */
10177   _ACEOF
10178   cat confdefs.h >>conftest.$ac_ext
10179   cat >>conftest.$ac_ext <<_ACEOF
10180   /* end confdefs.h.  */
10181 < #include <ac_nonexistent.h>
10181 > $ac_includes_default
10182 > #include <$ac_header>
10183   _ACEOF
10184 + rm -f conftest.$ac_objext
10185 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10186 +  (eval $ac_compile) 2>conftest.er1
10187 +  ac_status=$?
10188 +  grep -v '^ *+' conftest.er1 >conftest.err
10189 +  rm -f conftest.er1
10190 +  cat conftest.err >&5
10191 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192 +  (exit $ac_status); } &&
10193 +         { ac_try='test -z "$ac_cxx_werror_flag"
10194 +                         || test ! -s conftest.err'
10195 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10196 +  (eval $ac_try) 2>&5
10197 +  ac_status=$?
10198 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10199 +  (exit $ac_status); }; } &&
10200 +         { ac_try='test -s conftest.$ac_objext'
10201 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10202 +  (eval $ac_try) 2>&5
10203 +  ac_status=$?
10204 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10205 +  (exit $ac_status); }; }; then
10206 +  ac_header_compiler=yes
10207 + else
10208 +  echo "$as_me: failed program was:" >&5
10209 + sed 's/^/| /' conftest.$ac_ext >&5
10210 +
10211 + ac_header_compiler=no
10212 + fi
10213 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10214 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10215 + echo "${ECHO_T}$ac_header_compiler" >&6
10216 +
10217 + # Is the header present?
10218 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
10219 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10220 + cat >conftest.$ac_ext <<_ACEOF
10221 + /* confdefs.h.  */
10222 + _ACEOF
10223 + cat confdefs.h >>conftest.$ac_ext
10224 + cat >>conftest.$ac_ext <<_ACEOF
10225 + /* end confdefs.h.  */
10226 + #include <$ac_header>
10227 + _ACEOF
10228   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10229    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10230    ac_status=$?
# Line 4302 | Line 10234 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10234    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10235    (exit $ac_status); } >/dev/null; then
10236    if test -s conftest.err; then
10237 <    ac_cpp_err=$ac_c_preproc_warn_flag
10238 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10237 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10238 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10239    else
10240      ac_cpp_err=
10241    fi
# Line 4311 | Line 10243 | if test -z "$ac_cpp_err"; then
10243    ac_cpp_err=yes
10244   fi
10245   if test -z "$ac_cpp_err"; then
10246 <  # Broken: success on invalid input.
4315 < continue
10246 >  ac_header_preproc=yes
10247   else
10248    echo "$as_me: failed program was:" >&5
10249   sed 's/^/| /' conftest.$ac_ext >&5
10250  
10251 <  # Passes both tests.
4321 < ac_preproc_ok=:
4322 < break
10251 >  ac_header_preproc=no
10252   fi
10253   rm -f conftest.err conftest.$ac_ext
10254 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10255 + echo "${ECHO_T}$ac_header_preproc" >&6
10256  
10257 < done
10258 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10259 < rm -f conftest.err conftest.$ac_ext
10260 < if $ac_preproc_ok; then
10261 <  break
10257 > # So?  What about this header?
10258 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10259 >  yes:no: )
10260 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10261 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10262 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10263 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10264 >    ac_header_preproc=yes
10265 >    ;;
10266 >  no:yes:* )
10267 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10268 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10269 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10270 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10271 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10272 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10273 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10274 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10275 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10276 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10277 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10278 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10279 >    (
10280 >      cat <<\_ASBOX
10281 > ## ------------------------------ ##
10282 > ## Report this to gezelter@nd.edu ##
10283 > ## ------------------------------ ##
10284 > _ASBOX
10285 >    ) |
10286 >      sed "s/^/$as_me: WARNING:     /" >&2
10287 >    ;;
10288 > esac
10289 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10290 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10291 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10292 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10293 > else
10294 >  eval "$as_ac_Header=\$ac_header_preproc"
10295   fi
10296 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10297 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10298  
10299 <    done
10300 <    ac_cv_prog_CPP=$CPP
10299 > fi
10300 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10301 >  cat >>confdefs.h <<_ACEOF
10302 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10303 > _ACEOF
10304  
10305   fi
10306 <  CPP=$ac_cv_prog_CPP
10307 < else
10308 <  ac_cv_prog_CPP=$CPP
10306 >
10307 > done
10308 >
10309 >
10310   fi
10311 < echo "$as_me:$LINENO: result: $CPP" >&5
10312 < echo "${ECHO_T}$CPP" >&6
10313 < ac_preproc_ok=false
10314 < for ac_c_preproc_warn_flag in '' yes
10311 >
10312 >
10313 >
10314 >
10315 > for ac_header in cmath
10316   do
10317 <  # Use a header file that comes with gcc, so configuring glibc
10318 <  # with a fresh cross-compiler works.
10319 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10320 <  # <limits.h> exists even on freestanding compilers.
10321 <  # On the NeXT, cc -E runs the code through the compiler's parser,
10322 <  # not just through cpp. "Syntax error" is here to catch this case.
10323 <  cat >conftest.$ac_ext <<_ACEOF
10317 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10318 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10319 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10320 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10321 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10322 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10323 > fi
10324 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10325 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10326 > else
10327 >  # Is the header compilable?
10328 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10329 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10330 > cat >conftest.$ac_ext <<_ACEOF
10331   /* confdefs.h.  */
10332   _ACEOF
10333   cat confdefs.h >>conftest.$ac_ext
10334   cat >>conftest.$ac_ext <<_ACEOF
10335   /* end confdefs.h.  */
10336 < #ifdef __STDC__
10337 < # include <limits.h>
4360 < #else
4361 < # include <assert.h>
4362 < #endif
4363 <                     Syntax error
10336 > $ac_includes_default
10337 > #include <$ac_header>
10338   _ACEOF
10339 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10340 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10339 > rm -f conftest.$ac_objext
10340 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10341 >  (eval $ac_compile) 2>conftest.er1
10342    ac_status=$?
10343    grep -v '^ *+' conftest.er1 >conftest.err
10344    rm -f conftest.er1
10345    cat conftest.err >&5
10346    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10347 <  (exit $ac_status); } >/dev/null; then
10348 <  if test -s conftest.err; then
10349 <    ac_cpp_err=$ac_c_preproc_warn_flag
10350 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10351 <  else
10352 <    ac_cpp_err=
10353 <  fi
10347 >  (exit $ac_status); } &&
10348 >         { ac_try='test -z "$ac_cxx_werror_flag"
10349 >                         || test ! -s conftest.err'
10350 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10351 >  (eval $ac_try) 2>&5
10352 >  ac_status=$?
10353 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10354 >  (exit $ac_status); }; } &&
10355 >         { ac_try='test -s conftest.$ac_objext'
10356 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10357 >  (eval $ac_try) 2>&5
10358 >  ac_status=$?
10359 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10360 >  (exit $ac_status); }; }; then
10361 >  ac_header_compiler=yes
10362   else
4380 –  ac_cpp_err=yes
4381 – fi
4382 – if test -z "$ac_cpp_err"; then
4383 –  :
4384 – else
10363    echo "$as_me: failed program was:" >&5
10364   sed 's/^/| /' conftest.$ac_ext >&5
10365  
10366 <  # Broken: fails on valid input.
4389 < continue
10366 > ac_header_compiler=no
10367   fi
10368 < rm -f conftest.err conftest.$ac_ext
10368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10369 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10370 > echo "${ECHO_T}$ac_header_compiler" >&6
10371  
10372 <  # OK, works on sane cases.  Now check whether non-existent headers
10373 <  # can be detected and how.
10374 <  cat >conftest.$ac_ext <<_ACEOF
10372 > # Is the header present?
10373 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10374 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10375 > cat >conftest.$ac_ext <<_ACEOF
10376   /* confdefs.h.  */
10377   _ACEOF
10378   cat confdefs.h >>conftest.$ac_ext
10379   cat >>conftest.$ac_ext <<_ACEOF
10380   /* end confdefs.h.  */
10381 < #include <ac_nonexistent.h>
10381 > #include <$ac_header>
10382   _ACEOF
10383   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10384    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4409 | Line 10389 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10389    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10390    (exit $ac_status); } >/dev/null; then
10391    if test -s conftest.err; then
10392 <    ac_cpp_err=$ac_c_preproc_warn_flag
10393 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10392 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10393 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10394    else
10395      ac_cpp_err=
10396    fi
# Line 4418 | Line 10398 | if test -z "$ac_cpp_err"; then
10398    ac_cpp_err=yes
10399   fi
10400   if test -z "$ac_cpp_err"; then
10401 <  # Broken: success on invalid input.
4422 < continue
10401 >  ac_header_preproc=yes
10402   else
10403    echo "$as_me: failed program was:" >&5
10404   sed 's/^/| /' conftest.$ac_ext >&5
10405  
10406 <  # Passes both tests.
4428 < ac_preproc_ok=:
4429 < break
10406 >  ac_header_preproc=no
10407   fi
10408   rm -f conftest.err conftest.$ac_ext
10409 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10410 + echo "${ECHO_T}$ac_header_preproc" >&6
10411  
10412 < done
10413 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10414 < rm -f conftest.err conftest.$ac_ext
10415 < if $ac_preproc_ok; then
10416 <  :
10412 > # So?  What about this header?
10413 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10414 >  yes:no: )
10415 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10416 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10417 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10418 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10419 >    ac_header_preproc=yes
10420 >    ;;
10421 >  no:yes:* )
10422 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10423 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10424 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10425 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10426 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10427 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10428 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10429 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10430 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10431 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10432 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10433 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10434 >    (
10435 >      cat <<\_ASBOX
10436 > ## ------------------------------ ##
10437 > ## Report this to gezelter@nd.edu ##
10438 > ## ------------------------------ ##
10439 > _ASBOX
10440 >    ) |
10441 >      sed "s/^/$as_me: WARNING:     /" >&2
10442 >    ;;
10443 > esac
10444 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10445 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10446 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10447 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10448   else
10449 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4440 < See \`config.log' for more details." >&5
4441 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4442 < See \`config.log' for more details." >&2;}
4443 <   { (exit 1); exit 1; }; }
10449 >  eval "$as_ac_Header=\$ac_header_preproc"
10450   fi
10451 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10452 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10453  
10454 < ac_ext=c
10455 < ac_cpp='$CPP $CPPFLAGS'
10456 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10457 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10458 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10454 > fi
10455 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10456 >  cat >>confdefs.h <<_ACEOF
10457 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10458 > _ACEOF
10459  
4452 –
4453 – echo "$as_me:$LINENO: checking for egrep" >&5
4454 – echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4455 – if test "${ac_cv_prog_egrep+set}" = set; then
4456 –  echo $ECHO_N "(cached) $ECHO_C" >&6
4457 – else
4458 –  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4459 –    then ac_cv_prog_egrep='grep -E'
4460 –    else ac_cv_prog_egrep='egrep'
4461 –    fi
10460   fi
4463 – echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4464 – echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4465 – EGREP=$ac_cv_prog_egrep
10461  
10462 + done
10463  
10464 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10465 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10466 < if test "${ac_cv_header_stdc+set}" = set; then
10464 >
10465 >
10466 >
10467 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
10468 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
10469 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
10470    echo $ECHO_N "(cached) $ECHO_C" >&6
10471   else
10472 <  cat >conftest.$ac_ext <<_ACEOF
10472 >
10473 >      ac_cv_cxx_have_std_iostream=no
10474 >      ac_cv_cxx_need_use_std_iostream=no
10475 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
10476 >
10477 >
10478 >        ac_ext=cc
10479 > ac_cpp='$CXXCPP $CPPFLAGS'
10480 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10481 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10482 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10483 >
10484 >        cat >conftest.$ac_ext <<_ACEOF
10485   /* confdefs.h.  */
10486   _ACEOF
10487   cat confdefs.h >>conftest.$ac_ext
10488   cat >>conftest.$ac_ext <<_ACEOF
10489   /* end confdefs.h.  */
4479 – #include <stdlib.h>
4480 – #include <stdarg.h>
4481 – #include <string.h>
4482 – #include <float.h>
10490  
10491 + #ifdef HAVE_IOSTREAM
10492 + #include <iostream>
10493 + #else
10494 + #include <iostream.h>
10495 + #endif
10496 +
10497 + #ifdef FC_DUMMY_MAIN
10498 + #ifndef FC_DUMMY_MAIN_EQ_F77
10499 + #  ifdef __cplusplus
10500 +     extern "C"
10501 + #  endif
10502 +   int FC_DUMMY_MAIN() { return 1; }
10503 + #endif
10504 + #endif
10505   int
10506   main ()
10507   {
10508 <
10508 > std::cout<<"Hello World"<<std::endl;return 0;
10509    ;
10510    return 0;
10511   }
# Line 4498 | Line 10519 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10519    cat conftest.err >&5
10520    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10521    (exit $ac_status); } &&
10522 <         { ac_try='test -z "$ac_c_werror_flag"
10522 >         { ac_try='test -z "$ac_cxx_werror_flag"
10523                           || test ! -s conftest.err'
10524    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10525    (eval $ac_try) 2>&5
# Line 4511 | Line 10532 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10532    ac_status=$?
10533    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10534    (exit $ac_status); }; }; then
10535 <  ac_cv_header_stdc=yes
10535 >  ac_cv_cxx_have_std_iostream=yes
10536   else
10537    echo "$as_me: failed program was:" >&5
10538   sed 's/^/| /' conftest.$ac_ext >&5
10539  
4519 – ac_cv_header_stdc=no
10540   fi
10541   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10542 <
4523 < if test $ac_cv_header_stdc = yes; then
4524 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4525 <  cat >conftest.$ac_ext <<_ACEOF
10542 >        cat >conftest.$ac_ext <<_ACEOF
10543   /* confdefs.h.  */
10544   _ACEOF
10545   cat confdefs.h >>conftest.$ac_ext
10546   cat >>conftest.$ac_ext <<_ACEOF
10547   /* end confdefs.h.  */
4531 – #include <string.h>
10548  
10549 + #define __USE_STD_IOSTREAM 1
10550 + #ifdef HAVE_IOSTREAM
10551 + #include <iostream>
10552 + #else
10553 + #include <iostream.h>
10554 + #endif
10555 +
10556 + #ifdef FC_DUMMY_MAIN
10557 + #ifndef FC_DUMMY_MAIN_EQ_F77
10558 + #  ifdef __cplusplus
10559 +     extern "C"
10560 + #  endif
10561 +   int FC_DUMMY_MAIN() { return 1; }
10562 + #endif
10563 + #endif
10564 + int
10565 + main ()
10566 + {
10567 + std::cout<<"Hello World"<<std::endl;return 0;
10568 +  ;
10569 +  return 0;
10570 + }
10571   _ACEOF
10572 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10573 <  $EGREP "memchr" >/dev/null 2>&1; then
10574 <  :
10572 > rm -f conftest.$ac_objext
10573 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10574 >  (eval $ac_compile) 2>conftest.er1
10575 >  ac_status=$?
10576 >  grep -v '^ *+' conftest.er1 >conftest.err
10577 >  rm -f conftest.er1
10578 >  cat conftest.err >&5
10579 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10580 >  (exit $ac_status); } &&
10581 >         { ac_try='test -z "$ac_cxx_werror_flag"
10582 >                         || test ! -s conftest.err'
10583 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10584 >  (eval $ac_try) 2>&5
10585 >  ac_status=$?
10586 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10587 >  (exit $ac_status); }; } &&
10588 >         { ac_try='test -s conftest.$ac_objext'
10589 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10590 >  (eval $ac_try) 2>&5
10591 >  ac_status=$?
10592 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10593 >  (exit $ac_status); }; }; then
10594 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
10595   else
10596 <  ac_cv_header_stdc=no
10596 >  echo "$as_me: failed program was:" >&5
10597 > sed 's/^/| /' conftest.$ac_ext >&5
10598 >
10599   fi
10600 < rm -f conftest*
10600 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10601 >        ac_ext=cc
10602 > ac_cpp='$CXXCPP $CPPFLAGS'
10603 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10604 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10605 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10606  
10607 +      fi
10608 +
10609   fi
10610 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
10611 + echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
10612 +  if test "$ac_cv_cxx_have_std_iostream" = yes; then
10613  
10614 < if test $ac_cv_header_stdc = yes; then
10615 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
10616 <  cat >conftest.$ac_ext <<_ACEOF
10614 > cat >>confdefs.h <<\_ACEOF
10615 > #define HAVE_STD_IOSTREAM 1
10616 > _ACEOF
10617 >
10618 >  fi
10619 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
10620 >
10621 > cat >>confdefs.h <<\_ACEOF
10622 > #define __USE_STD_IOSTREAM 1
10623 > _ACEOF
10624 >
10625 >  fi
10626 >
10627 >
10628 >
10629 >
10630 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
10631 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
10632 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
10633 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10634 > else
10635 >
10636 >      ac_cv_cxx_have_std_stl=no
10637 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
10638 >
10639 >
10640 >        ac_ext=cc
10641 > ac_cpp='$CXXCPP $CPPFLAGS'
10642 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10643 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10644 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10645 >
10646 >        cat >conftest.$ac_ext <<_ACEOF
10647   /* confdefs.h.  */
10648   _ACEOF
10649   cat confdefs.h >>conftest.$ac_ext
10650   cat >>conftest.$ac_ext <<_ACEOF
10651   /* end confdefs.h.  */
10652 < #include <stdlib.h>
10652 > #include <list>
10653  
10654 + #ifdef FC_DUMMY_MAIN
10655 + #ifndef FC_DUMMY_MAIN_EQ_F77
10656 + #  ifdef __cplusplus
10657 +     extern "C"
10658 + #  endif
10659 +   int FC_DUMMY_MAIN() { return 1; }
10660 + #endif
10661 + #endif
10662 + int
10663 + main ()
10664 + {
10665 + std::list<int> foo;return 0;
10666 +  ;
10667 +  return 0;
10668 + }
10669   _ACEOF
10670 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10671 <  $EGREP "free" >/dev/null 2>&1; then
10672 <  :
10670 > rm -f conftest.$ac_objext
10671 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10672 >  (eval $ac_compile) 2>conftest.er1
10673 >  ac_status=$?
10674 >  grep -v '^ *+' conftest.er1 >conftest.err
10675 >  rm -f conftest.er1
10676 >  cat conftest.err >&5
10677 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10678 >  (exit $ac_status); } &&
10679 >         { ac_try='test -z "$ac_cxx_werror_flag"
10680 >                         || test ! -s conftest.err'
10681 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10682 >  (eval $ac_try) 2>&5
10683 >  ac_status=$?
10684 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10685 >  (exit $ac_status); }; } &&
10686 >         { ac_try='test -s conftest.$ac_objext'
10687 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10688 >  (eval $ac_try) 2>&5
10689 >  ac_status=$?
10690 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10691 >  (exit $ac_status); }; }; then
10692 >  ac_cv_cxx_have_std_stl=yes
10693   else
10694 <  ac_cv_header_stdc=no
10694 >  echo "$as_me: failed program was:" >&5
10695 > sed 's/^/| /' conftest.$ac_ext >&5
10696 >
10697   fi
10698 < rm -f conftest*
10698 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10699 >        ac_ext=cc
10700 > ac_cpp='$CXXCPP $CPPFLAGS'
10701 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10702 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10703 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10704  
10705 +      fi
10706 +
10707   fi
10708 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
10709 + echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
10710 +  if test "$ac_cv_cxx_have_std_stl" = yes; then
10711  
10712 < if test $ac_cv_header_stdc = yes; then
10713 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
10714 <  if test "$cross_compiling" = yes; then
10715 <  :
10712 > cat >>confdefs.h <<\_ACEOF
10713 > #define HAVE_STD_STL 1
10714 > _ACEOF
10715 >
10716 >  fi
10717 >
10718 >
10719 >
10720 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
10721 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
10722 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
10723 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10724   else
10725 <  cat >conftest.$ac_ext <<_ACEOF
10725 >
10726 >    ac_cv_cxx_have_fstream_attach=no
10727 >
10728 >
10729 >    ac_ext=cc
10730 > ac_cpp='$CXXCPP $CPPFLAGS'
10731 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10732 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10733 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10734 >
10735 >    cat >conftest.$ac_ext <<_ACEOF
10736   /* confdefs.h.  */
10737   _ACEOF
10738   cat confdefs.h >>conftest.$ac_ext
10739   cat >>conftest.$ac_ext <<_ACEOF
10740   /* end confdefs.h.  */
10741 < #include <ctype.h>
10742 < #if ((' ' & 0x0FF) == 0x020)
10743 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4579 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
10741 >
10742 > #ifdef HAVE_IOSTREAM
10743 > #include <fstream>
10744   #else
10745 < # define ISLOWER(c) \
4582 <                   (('a' <= (c) && (c) <= 'i') \
4583 <                     || ('j' <= (c) && (c) <= 'r') \
4584 <                     || ('s' <= (c) && (c) <= 'z'))
4585 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
10745 > #include <fstream.h>
10746   #endif
10747 + #ifdef HAVE_STD_IOSTREAM
10748 + using namespace std;
10749 + #endif
10750  
10751 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
10751 > #ifdef FC_DUMMY_MAIN
10752 > #ifndef FC_DUMMY_MAIN_EQ_F77
10753 > #  ifdef __cplusplus
10754 >     extern "C"
10755 > #  endif
10756 >   int FC_DUMMY_MAIN() { return 1; }
10757 > #endif
10758 > #endif
10759   int
10760   main ()
10761   {
10762 <  int i;
10763 <  for (i = 0; i < 256; i++)
10764 <    if (XOR (islower (i), ISLOWER (i))
4595 <        || toupper (i) != TOUPPER (i))
4596 <      exit(2);
4597 <  exit (0);
10762 > int fd=0;ofstream s;s.attach(fd);
10763 >  ;
10764 >  return 0;
10765   }
10766   _ACEOF
10767 < rm -f conftest$ac_exeext
10768 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10769 <  (eval $ac_link) 2>&5
10767 > rm -f conftest.$ac_objext
10768 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10769 >  (eval $ac_compile) 2>conftest.er1
10770    ac_status=$?
10771 +  grep -v '^ *+' conftest.er1 >conftest.err
10772 +  rm -f conftest.er1
10773 +  cat conftest.err >&5
10774    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10775 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10775 >  (exit $ac_status); } &&
10776 >         { ac_try='test -z "$ac_cxx_werror_flag"
10777 >                         || test ! -s conftest.err'
10778    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10779    (eval $ac_try) 2>&5
10780    ac_status=$?
10781    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10782 <  (exit $ac_status); }; }; then
10783 <  :
10782 >  (exit $ac_status); }; } &&
10783 >         { ac_try='test -s conftest.$ac_objext'
10784 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10785 >  (eval $ac_try) 2>&5
10786 >  ac_status=$?
10787 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10788 >  (exit $ac_status); }; }; then
10789 >  ac_cv_cxx_have_fstream_attach=yes
10790   else
10791 <  echo "$as_me: program exited with status $ac_status" >&5
4614 < echo "$as_me: failed program was:" >&5
10791 >  echo "$as_me: failed program was:" >&5
10792   sed 's/^/| /' conftest.$ac_ext >&5
10793  
4617 – ( exit $ac_status )
4618 – ac_cv_header_stdc=no
10794   fi
10795 < rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10795 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10796 >    ac_ext=cc
10797 > ac_cpp='$CXXCPP $CPPFLAGS'
10798 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10799 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10800 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10801 >
10802 >
10803   fi
10804 < fi
10805 < fi
10806 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4625 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
4626 < if test $ac_cv_header_stdc = yes; then
10804 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
10805 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
10806 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
10807  
10808   cat >>confdefs.h <<\_ACEOF
10809 < #define STDC_HEADERS 1
10809 > #define HAVE_FSTREAM_ATTACH 1
10810   _ACEOF
10811  
10812 < fi
10812 >  fi
10813  
4634 – # On IRIX 5.3, sys/types and inttypes.h are conflicting.
10814  
10815  
10816 +  echo "$as_me:$LINENO: checking for fstream::open()" >&5
10817 + echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
10818 + if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
10819 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10820 + else
10821  
10822 +    ac_cv_cxx_have_fstream_open=no
10823 +    ac_cv_cxx_fstream_open_prot=no
10824  
10825  
10826 +    ac_ext=cc
10827 + ac_cpp='$CXXCPP $CPPFLAGS'
10828 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10829 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10830 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10831  
10832 +    # Try with 2 parameters
10833 +    cat >conftest.$ac_ext <<_ACEOF
10834 + /* confdefs.h.  */
10835 + _ACEOF
10836 + cat confdefs.h >>conftest.$ac_ext
10837 + cat >>conftest.$ac_ext <<_ACEOF
10838 + /* end confdefs.h.  */
10839  
10840 + #ifdef HAVE_IOSTREAM
10841 + #include <fstream>
10842 + #else
10843 + #include <fstream.h>
10844 + #endif
10845 + #ifdef HAVE_STD_IOSTREAM
10846 + using namespace std;
10847 + #endif
10848  
10849 <
10850 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
10851 <                  inttypes.h stdint.h unistd.h
10852 < do
10853 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10854 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10855 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10856 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10857 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10849 > #ifdef FC_DUMMY_MAIN
10850 > #ifndef FC_DUMMY_MAIN_EQ_F77
10851 > #  ifdef __cplusplus
10852 >     extern "C"
10853 > #  endif
10854 >   int FC_DUMMY_MAIN() { return 1; }
10855 > #endif
10856 > #endif
10857 > int
10858 > main ()
10859 > {
10860 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
10861 >  ;
10862 >  return 0;
10863 > }
10864 > _ACEOF
10865 > rm -f conftest.$ac_objext
10866 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10867 >  (eval $ac_compile) 2>conftest.er1
10868 >  ac_status=$?
10869 >  grep -v '^ *+' conftest.er1 >conftest.err
10870 >  rm -f conftest.er1
10871 >  cat conftest.err >&5
10872 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10873 >  (exit $ac_status); } &&
10874 >         { ac_try='test -z "$ac_cxx_werror_flag"
10875 >                         || test ! -s conftest.err'
10876 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10877 >  (eval $ac_try) 2>&5
10878 >  ac_status=$?
10879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880 >  (exit $ac_status); }; } &&
10881 >         { ac_try='test -s conftest.$ac_objext'
10882 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10883 >  (eval $ac_try) 2>&5
10884 >  ac_status=$?
10885 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10886 >  (exit $ac_status); }; }; then
10887 >  ac_cv_cxx_have_fstream_open=yes
10888   else
10889 <  cat >conftest.$ac_ext <<_ACEOF
10889 >  echo "$as_me: failed program was:" >&5
10890 > sed 's/^/| /' conftest.$ac_ext >&5
10891 >
10892 > fi
10893 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10894 >    # Try with mode parameter
10895 >    cat >conftest.$ac_ext <<_ACEOF
10896   /* confdefs.h.  */
10897   _ACEOF
10898   cat confdefs.h >>conftest.$ac_ext
10899   cat >>conftest.$ac_ext <<_ACEOF
10900   /* end confdefs.h.  */
4659 – $ac_includes_default
10901  
10902 < #include <$ac_header>
10902 > #ifdef HAVE_IOSTREAM
10903 > #include <fstream>
10904 > #else
10905 > #include <fstream.h>
10906 > #endif
10907 > #ifdef HAVE_STD_IOSTREAM
10908 > using namespace std;
10909 > #endif
10910 >
10911 > #ifdef FC_DUMMY_MAIN
10912 > #ifndef FC_DUMMY_MAIN_EQ_F77
10913 > #  ifdef __cplusplus
10914 >     extern "C"
10915 > #  endif
10916 >   int FC_DUMMY_MAIN() { return 1; }
10917 > #endif
10918 > #endif
10919 > int
10920 > main ()
10921 > {
10922 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
10923 >  ;
10924 >  return 0;
10925 > }
10926   _ACEOF
10927   rm -f conftest.$ac_objext
10928   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 4669 | Line 10933 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10933    cat conftest.err >&5
10934    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10935    (exit $ac_status); } &&
10936 <         { ac_try='test -z "$ac_c_werror_flag"
10936 >         { ac_try='test -z "$ac_cxx_werror_flag"
10937                           || test ! -s conftest.err'
10938    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10939    (eval $ac_try) 2>&5
# Line 4682 | Line 10946 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10946    ac_status=$?
10947    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10948    (exit $ac_status); }; }; then
10949 <  eval "$as_ac_Header=yes"
10949 >  ac_cv_cxx_fstream_open_prot=yes
10950   else
10951    echo "$as_me: failed program was:" >&5
10952   sed 's/^/| /' conftest.$ac_ext >&5
10953  
4690 – eval "$as_ac_Header=no"
10954   fi
10955   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10956 +    ac_ext=cc
10957 + ac_cpp='$CXXCPP $CPPFLAGS'
10958 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10959 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10960 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10961 +
10962 +
10963   fi
10964 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10965 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10966 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10967 <  cat >>confdefs.h <<_ACEOF
10968 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10964 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
10965 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
10966 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
10967 >
10968 > cat >>confdefs.h <<\_ACEOF
10969 > #define HAVE_FSTREAM_OPEN 1
10970   _ACEOF
10971  
10972 < fi
10972 >  fi
10973 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
10974  
10975 < done
10975 > cat >>confdefs.h <<\_ACEOF
10976 > #define FSTREAM_OPEN_PROT 1
10977 > _ACEOF
10978  
10979 +  fi
10980  
4706 –  # clean out junk possibly left behind by a previous configuration
4707 –  rm -f utils/getopt.h
4708 –  # Check for getopt_long support
10981  
10982 < for ac_header in getopt.h
10982 >
10983 >
10984 >
10985 >
10986 >
10987 > for ac_header in ctype.h iostream fstream sstream strstream
10988   do
10989   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10990   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 4740 | Line 11017 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11017    cat conftest.err >&5
11018    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11019    (exit $ac_status); } &&
11020 <         { ac_try='test -z "$ac_c_werror_flag"
11020 >         { ac_try='test -z "$ac_cxx_werror_flag"
11021                           || test ! -s conftest.err'
11022    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11023    (eval $ac_try) 2>&5
# Line 4784 | Line 11061 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11061    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11062    (exit $ac_status); } >/dev/null; then
11063    if test -s conftest.err; then
11064 <    ac_cpp_err=$ac_c_preproc_warn_flag
11065 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11064 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11065 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11066    else
11067      ac_cpp_err=
11068    fi
# Line 4805 | Line 11082 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11082   echo "${ECHO_T}$ac_header_preproc" >&6
11083  
11084   # So?  What about this header?
11085 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11085 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11086    yes:no: )
11087      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11088   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 4856 | Line 11133 | done
11133  
11134   done
11135  
11136 + # AC_CPP_FUNC
11137 + # ------------------ #
11138 + # Checks to see if ANSI C99 CPP variable __func__ works.
11139 + # If not, perhaps __FUNCTION__ works instead.
11140 + # If not, we'll just define __func__ to "".
11141 + # AC_CPP_FUNC
11142  
11143 < for ac_func in getopt_long
11144 < do
11145 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11146 < echo "$as_me:$LINENO: checking for $ac_func" >&5
4864 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
4865 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11143 >
11144 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11145 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11146 > if test "${ac_cv_cpp_func+set}" = set; then
11147    echo $ECHO_N "(cached) $ECHO_C" >&6
11148   else
11149    cat >conftest.$ac_ext <<_ACEOF
# Line 4871 | Line 11152 | cat >>conftest.$ac_ext <<_ACEOF
11152   cat confdefs.h >>conftest.$ac_ext
11153   cat >>conftest.$ac_ext <<_ACEOF
11154   /* end confdefs.h.  */
4874 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
4875 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
4876 – #define $ac_func innocuous_$ac_func
11155  
11156 < /* System header to define __stub macros and hopefully few prototypes,
11157 <    which can conflict with char $ac_func (); below.
11158 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11159 <    <limits.h> exists even on freestanding compilers.  */
11160 <
11161 < #ifdef __STDC__
4884 < # include <limits.h>
4885 < #else
4886 < # include <assert.h>
4887 < #endif
4888 <
4889 < #undef $ac_func
4890 <
4891 < /* Override any gcc2 internal prototype to avoid an error.  */
4892 < #ifdef __cplusplus
4893 < extern "C"
4894 < {
11156 > #ifdef FC_DUMMY_MAIN
11157 > #ifndef FC_DUMMY_MAIN_EQ_F77
11158 > #  ifdef __cplusplus
11159 >     extern "C"
11160 > #  endif
11161 >   int FC_DUMMY_MAIN() { return 1; }
11162   #endif
4896 – /* We use char because int might match the return type of a gcc2
4897 –   builtin and then its argument prototype would still apply.  */
4898 – char $ac_func ();
4899 – /* The GNU C library defines this for functions which it implements
4900 –    to always fail with ENOSYS.  Some functions are actually named
4901 –    something starting with __ and the normal name is an alias.  */
4902 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4903 – choke me
4904 – #else
4905 – char (*f) () = $ac_func;
11163   #endif
4907 – #ifdef __cplusplus
4908 – }
4909 – #endif
4910 –
11164   int
11165   main ()
11166   {
11167 < return f != $ac_func;
11167 > const char *foo = __func__;
11168    ;
11169    return 0;
11170   }
11171   _ACEOF
11172 < rm -f conftest.$ac_objext conftest$ac_exeext
11173 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11174 <  (eval $ac_link) 2>conftest.er1
11172 > rm -f conftest.$ac_objext
11173 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11174 >  (eval $ac_compile) 2>conftest.er1
11175    ac_status=$?
11176    grep -v '^ *+' conftest.er1 >conftest.err
11177    rm -f conftest.er1
11178    cat conftest.err >&5
11179    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11180    (exit $ac_status); } &&
11181 <         { ac_try='test -z "$ac_c_werror_flag"
11181 >         { ac_try='test -z "$ac_cxx_werror_flag"
11182                           || test ! -s conftest.err'
11183    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11184    (eval $ac_try) 2>&5
11185    ac_status=$?
11186    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11187    (exit $ac_status); }; } &&
11188 <         { ac_try='test -s conftest$ac_exeext'
11188 >         { ac_try='test -s conftest.$ac_objext'
11189    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11190    (eval $ac_try) 2>&5
11191    ac_status=$?
11192    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11193    (exit $ac_status); }; }; then
11194 <  eval "$as_ac_var=yes"
11194 >  ac_cv_cpp_func=yes
11195   else
11196    echo "$as_me: failed program was:" >&5
11197   sed 's/^/| /' conftest.$ac_ext >&5
11198  
4946 – eval "$as_ac_var=no"
4947 – fi
4948 – rm -f conftest.err conftest.$ac_objext \
4949 –      conftest$ac_exeext conftest.$ac_ext
4950 – fi
4951 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
4952 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
4953 – if test `eval echo '${'$as_ac_var'}'` = yes; then
4954 –  cat >>confdefs.h <<_ACEOF
4955 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
4956 – _ACEOF
4957 –
4958 – else
4959 –  # FreeBSD has a gnugetopt library for this
4960 –    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
4961 – echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
4962 – if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
4963 –  echo $ECHO_N "(cached) $ECHO_C" >&6
4964 – else
4965 –  ac_check_lib_save_LIBS=$LIBS
4966 – LIBS="-lgnugetopt  $LIBS"
11199   cat >conftest.$ac_ext <<_ACEOF
11200   /* confdefs.h.  */
11201   _ACEOF
# Line 4971 | Line 11203 | cat >>conftest.$ac_ext <<_ACEOF
11203   cat >>conftest.$ac_ext <<_ACEOF
11204   /* end confdefs.h.  */
11205  
11206 < /* Override any gcc2 internal prototype to avoid an error.  */
11207 < #ifdef __cplusplus
11208 < extern "C"
11206 > #ifdef FC_DUMMY_MAIN
11207 > #ifndef FC_DUMMY_MAIN_EQ_F77
11208 > #  ifdef __cplusplus
11209 >     extern "C"
11210 > #  endif
11211 >   int FC_DUMMY_MAIN() { return 1; }
11212   #endif
11213 < /* We use char because int might match the return type of a gcc2
4979 <   builtin and then its argument prototype would still apply.  */
4980 < char getopt_long ();
11213 > #endif
11214   int
11215   main ()
11216   {
11217 < getopt_long ();
11217 > const char *foo = __FUNCTION__;
11218    ;
11219    return 0;
11220   }
11221   _ACEOF
11222 < rm -f conftest.$ac_objext conftest$ac_exeext
11223 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11224 <  (eval $ac_link) 2>conftest.er1
11222 > rm -f conftest.$ac_objext
11223 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11224 >  (eval $ac_compile) 2>conftest.er1
11225    ac_status=$?
11226    grep -v '^ *+' conftest.er1 >conftest.err
11227    rm -f conftest.er1
11228    cat conftest.err >&5
11229    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11230    (exit $ac_status); } &&
11231 <         { ac_try='test -z "$ac_c_werror_flag"
11231 >         { ac_try='test -z "$ac_cxx_werror_flag"
11232                           || test ! -s conftest.err'
11233    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11234    (eval $ac_try) 2>&5
11235    ac_status=$?
11236    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11237    (exit $ac_status); }; } &&
11238 <         { ac_try='test -s conftest$ac_exeext'
11238 >         { ac_try='test -s conftest.$ac_objext'
11239    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11240    (eval $ac_try) 2>&5
11241    ac_status=$?
11242    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11243    (exit $ac_status); }; }; then
11244 <  ac_cv_lib_gnugetopt_getopt_long=yes
11244 >  ac_cv_cpp_func=__FUNCTION__
11245   else
11246    echo "$as_me: failed program was:" >&5
11247   sed 's/^/| /' conftest.$ac_ext >&5
11248  
11249 < ac_cv_lib_gnugetopt_getopt_long=no
11249 > ac_cv_cpp_func=no
11250   fi
11251 < rm -f conftest.err conftest.$ac_objext \
5019 <      conftest$ac_exeext conftest.$ac_ext
5020 < LIBS=$ac_check_lib_save_LIBS
11251 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11252   fi
11253 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11254 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11255 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11256 <  cat >>confdefs.h <<\_ACEOF
11257 < #define HAVE_GETOPT_LONG 1
11253 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11254 > fi
11255 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11256 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11257 > if test $ac_cv_cpp_func = __FUNCTION__; then
11258 >
11259 > cat >>confdefs.h <<\_ACEOF
11260 > #define __func__ __FUNCTION__
11261   _ACEOF
11262  
11263 < else
5030 <  # use the GNU replacement
5031 <      case $LIBOBJS in
5032 <    "getopt.$ac_objext"   | \
5033 <  *" getopt.$ac_objext"   | \
5034 <    "getopt.$ac_objext "* | \
5035 <  *" getopt.$ac_objext "* ) ;;
5036 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5037 < esac
11263 > elif test $ac_cv_cpp_func = no; then
11264  
11265 <      case $LIBOBJS in
11266 <    "getopt1.$ac_objext"   | \
11267 <  *" getopt1.$ac_objext"   | \
5042 <    "getopt1.$ac_objext "* | \
5043 <  *" getopt1.$ac_objext "* ) ;;
5044 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5045 < esac
11265 > cat >>confdefs.h <<\_ACEOF
11266 > #define __func__ ""
11267 > _ACEOF
11268  
5047 –                ac_config_links="$ac_config_links utils/getopt.h:utils/gnugetopt.h"
5048 –
11269   fi
11270  
5051 – fi
5052 – done
11271  
11272  
11273  
11274 +
11275   case $debug in
11276    1)
11277       ;;
# Line 5061 | Line 11280 | case $debug in
11280  
11281  
11282  
11283 + # Try to determine "good" native compiler flags if none specified on command
11284 + # line
11285  
11286 + if test "$ac_test_FCFLAGS" != "set"; then
11287 +  FCFLAGS=""
11288 +  case "${host_cpu}-${host_os}" in
11289  
11290 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11291 +                    FCFLAGS="-O"
11292 +                fi;;
11293 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11294 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11295 +                fi;;
11296 +   powerpc*-aix*)
11297 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11298 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11299 +                echo "*******************************************************"
11300 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11301 +                echo "*  recommended that you use                           *"
11302 +                echo "*                                                     *"
11303 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11304 +                echo "*                                 ^^^                 *"
11305 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11306 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11307 +                echo "*******************************************************"
11308 +        fi;;
11309 +   *darwin*)
11310 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11311 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11312 +        fi;;
11313 +  esac
11314 +
11315 +  if test -n "$CPU_FLAGS"; then
11316 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11317 +  fi
11318 +
11319 +  if test -z "$FCFLAGS"; then
11320 +        echo ""
11321 +        echo "*********************************************************"
11322 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11323 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11324 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11325 +        echo "*********************************************************"
11326 +        echo ""
11327 +        FCFLAGS="-O3"
11328 +  fi
11329 +
11330 +
11331 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11332 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11333 + if test "${ac_guessed_f90flags+set}" = set; then
11334 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11335 + else
11336 +
11337 +
11338 +
11339 + ac_ext=${FC_SRCEXT-f}
11340 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11341 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11342 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11343 +
11344 + echo 'program main' > conftest.$ac_ext
11345 + echo 'end program main' >> conftest.$ac_ext
11346 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11347 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11348 +  (eval $ac_compile) 2>&5
11349 +  ac_status=$?
11350 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11351 +  (exit $ac_status); }; then
11352 +        ac_guessed_f90flags=yes
11353 + else
11354 +        ac_guessed_f90flags=no
11355 + fi
11356 + rm -f conftest*
11357 + ac_ext=cc
11358 + ac_cpp='$CXXCPP $CPPFLAGS'
11359 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11360 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11361 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11362 +
11363 +
11364 + fi
11365 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
11366 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
11367 + if test "$ac_guessed_f90flags" = yes; then
11368 +        :
11369 +
11370 + else
11371 +        :
11372 +
11373 +        echo ""
11374 +        echo "**********************************************************"
11375 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
11376 +        echo "* your compiler.                                        *"
11377 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11378 +        echo "*********************************************************"
11379 +        echo ""
11380 +        FCFLAGS=""
11381 +
11382 + fi
11383 +
11384 +
11385 + fi
11386 +
11387 +
11388 +
11389 +
11390 +
11391 +
11392 +
11393   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
11394   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
11395   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5071 | Line 11398 | cat > conftest.c <<EOF
11398  
11399   cat > conftest.c <<EOF
11400   #ifdef __GNUC__
11401 <  #ifndef __INTEL_COMPILER
11401 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
11402 >     no;
11403 >  #else
11404       yes;
11405    #endif
11406   #endif
# Line 5109 | Line 11438 | if test "$ac_test_CFLAGS" != "set"; then
11438                      CFLAGS="-O"
11439                  fi;;
11440    sparc-solaris2*) if test "$CC" = cc; then
11441 <                    CFLAGS="-native -fast -xO5 -dalign"
11441 >                    CFLAGS="-O -dalign"
11442                   fi;;
11443  
11444    alpha*-osf*)  if test "$CC" = cc; then
# Line 5138 | Line 11467 | if test "$ac_test_CFLAGS" != "set"; then
11467          fi;;
11468     *darwin*)
11469          if test "$CC" = xlc -o "$CC" = cc; then
11470 <                CFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
11470 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
11471          fi;;
11472    esac
11473  
# Line 5152 | Line 11481 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11481      # -malign-double for x86 systems
11482  
11483  
11484 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
11485 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
11484 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
11485 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
11486   if test "${ac_align_double+set}" = set; then
11487    echo $ECHO_N "(cached) $ECHO_C" >&6
11488   else
11489    echo 'void f(){}' > conftest.c
11490 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
11490 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
11491          ac_align_double=yes
11492   else
11493          ac_align_double=no
# Line 5179 | Line 11508 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11508      # -fstrict-aliasing for gcc-2.95+
11509  
11510  
11511 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
11512 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
11511 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
11512 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
11513   if test "${ac_fstrict_aliasing+set}" = set; then
11514    echo $ECHO_N "(cached) $ECHO_C" >&6
11515   else
11516    echo 'void f(){}' > conftest.c
11517 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
11517 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
11518          ac_fstrict_aliasing=yes
11519   else
11520          ac_fstrict_aliasing=no
# Line 5210 | Line 11539 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11539                    case "${host_cpu}" in
11540            i586*)
11541  
11542 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
11543 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
11542 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
11543 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
11544   if test "${ac_cpu_pentium+set}" = set; then
11545    echo $ECHO_N "(cached) $ECHO_C" >&6
11546   else
11547    echo 'void f(){}' > conftest.c
11548 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
11548 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
11549          ac_cpu_pentium=yes
11550   else
11551          ac_cpu_pentium=no
# Line 5233 | Line 11562 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11562          :
11563  
11564  
11565 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
11566 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
11565 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
11566 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
11567   if test "${ac_pentium+set}" = set; then
11568    echo $ECHO_N "(cached) $ECHO_C" >&6
11569   else
11570    echo 'void f(){}' > conftest.c
11571 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
11571 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
11572          ac_pentium=yes
11573   else
11574          ac_pentium=no
# Line 5262 | Line 11591 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11591                    ;;
11592            i686*)
11593  
11594 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
11595 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
11594 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
11595 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
11596   if test "${ac_cpu_pentiumpro+set}" = set; then
11597    echo $ECHO_N "(cached) $ECHO_C" >&6
11598   else
11599    echo 'void f(){}' > conftest.c
11600 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
11600 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
11601          ac_cpu_pentiumpro=yes
11602   else
11603          ac_cpu_pentiumpro=no
# Line 5285 | Line 11614 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11614          :
11615  
11616  
11617 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
11618 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
11617 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
11618 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
11619   if test "${ac_pentiumpro+set}" = set; then
11620    echo $ECHO_N "(cached) $ECHO_C" >&6
11621   else
11622    echo 'void f(){}' > conftest.c
11623 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
11623 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
11624          ac_pentiumpro=yes
11625   else
11626          ac_pentiumpro=no
# Line 5318 | Line 11647 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11647                  if test -n "$is60x"; then
11648  
11649  
11650 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
11651 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
11650 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
11651 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
11652   if test "${ac_m_cpu_60x+set}" = set; then
11653    echo $ECHO_N "(cached) $ECHO_C" >&6
11654   else
11655    echo 'void f(){}' > conftest.c
11656 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
11656 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
11657          ac_m_cpu_60x=yes
11658   else
11659          ac_m_cpu_60x=no
# Line 5376 | Line 11705 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11705          :
11706  
11707  
11708 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
11709 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
11708 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
11709 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
11710   if test "${ac_m_cpu_750+set}" = set; then
11711    echo $ECHO_N "(cached) $ECHO_C" >&6
11712   else
11713    echo 'void f(){}' > conftest.c
11714 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
11714 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
11715          ac_m_cpu_750=yes
11716   else
11717          ac_m_cpu_750=no
# Line 5409 | Line 11738 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11738                  if test -z "$CPU_FLAGS"; then
11739  
11740  
11741 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
11742 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
11741 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
11742 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
11743   if test "${ac_m_cpu_powerpc+set}" = set; then
11744    echo $ECHO_N "(cached) $ECHO_C" >&6
11745   else
11746    echo 'void f(){}' > conftest.c
11747 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
11747 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
11748          ac_m_cpu_powerpc=yes
11749   else
11750          ac_m_cpu_powerpc=no
# Line 5437 | Line 11766 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11766                  if test -z "$CPU_FLAGS"; then
11767  
11768  
11769 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
11770 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
11769 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
11770 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
11771   if test "${ac_m_powerpc+set}" = set; then
11772    echo $ECHO_N "(cached) $ECHO_C" >&6
11773   else
11774    echo 'void f(){}' > conftest.c
11775 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
11775 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
11776          ac_m_powerpc=yes
11777   else
11778          ac_m_powerpc=no
# Line 5482 | Line 11811 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
11811  
11812  
11813  
11814 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
11815 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
11814 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
11815 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
11816   if test "${ac_guessed_cflags+set}" = set; then
11817    echo $ECHO_N "(cached) $ECHO_C" >&6
11818   else
11819    echo 'void f(){}' > conftest.c
11820 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
11820 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
11821          ac_guessed_cflags=yes
11822   else
11823          ac_guessed_cflags=no
# Line 5532 | Line 11861 | cat > conftest.cpp <<EOF
11861  
11862   cat > conftest.cpp <<EOF
11863   #ifdef __GNUC__
11864 <  #ifndef __INTEL_COMPILER
11864 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
11865 >     no;
11866 >  #else
11867       yes;
11868    #endif
11869   #endif
# Line 5570 | Line 11901 | if test "$ac_test_CXXFLAGS" != "set"; then
11901                      CXXFLAGS="-O"
11902                  fi;;
11903    sparc-solaris2*) if test "$CXX" = CC; then
11904 <                    CXXFLAGS="-native -fast -xO5 -dalign"
11904 >                    CXXFLAGS="-features=extensions -O -dalign"
11905                   fi;;
11906     rs6000*-aix*)  if test "$CXX" = xlC; then
11907                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 5589 | Line 11920 | if test "$ac_test_CXXFLAGS" != "set"; then
11920                  echo "*******************************************************"
11921          fi;;
11922     *darwin*)
11923 <        if test "$CXX" = xlc++; then
11924 <                CXXFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
11923 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
11924 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
11925          fi;;
11926    esac
11927  
# Line 5604 | Line 11935 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11935      # -malign-double for x86 systems
11936  
11937  
11938 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
11939 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
11938 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
11939 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
11940   if test "${ac_align_double+set}" = set; then
11941    echo $ECHO_N "(cached) $ECHO_C" >&6
11942   else
11943    echo 'void f(){}' > conftest.cpp
11944 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
11944 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
11945          ac_align_double=yes
11946   else
11947          ac_align_double=no
# Line 5631 | Line 11962 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11962      # -fstrict-aliasing for gcc-2.95+
11963  
11964  
11965 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
11966 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
11965 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
11966 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
11967   if test "${ac_fstrict_aliasing+set}" = set; then
11968    echo $ECHO_N "(cached) $ECHO_C" >&6
11969   else
11970    echo 'void f(){}' > conftest.cpp
11971 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
11971 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
11972          ac_fstrict_aliasing=yes
11973   else
11974          ac_fstrict_aliasing=no
# Line 5662 | Line 11993 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
11993                    case "${host_cpu}" in
11994            i586*)
11995  
11996 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
11997 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
11996 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
11997 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
11998   if test "${ac_cpu_pentium+set}" = set; then
11999    echo $ECHO_N "(cached) $ECHO_C" >&6
12000   else
12001    echo 'void f(){}' > conftest.cpp
12002 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12002 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12003          ac_cpu_pentium=yes
12004   else
12005          ac_cpu_pentium=no
# Line 5685 | Line 12016 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12016          :
12017  
12018  
12019 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12020 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12019 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12020 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12021   if test "${ac_pentium+set}" = set; then
12022    echo $ECHO_N "(cached) $ECHO_C" >&6
12023   else
12024    echo 'void f(){}' > conftest.cpp
12025 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12025 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12026          ac_pentium=yes
12027   else
12028          ac_pentium=no
# Line 5714 | Line 12045 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12045                    ;;
12046            i686*)
12047  
12048 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12049 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12048 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12049 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12050   if test "${ac_cpu_pentiumpro+set}" = set; then
12051    echo $ECHO_N "(cached) $ECHO_C" >&6
12052   else
12053    echo 'void f(){}' > conftest.cpp
12054 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12054 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12055          ac_cpu_pentiumpro=yes
12056   else
12057          ac_cpu_pentiumpro=no
# Line 5737 | Line 12068 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12068          :
12069  
12070  
12071 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12072 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12071 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12072 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12073   if test "${ac_pentiumpro+set}" = set; then
12074    echo $ECHO_N "(cached) $ECHO_C" >&6
12075   else
12076    echo 'void f(){}' > conftest.cpp
12077 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12077 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12078          ac_pentiumpro=yes
12079   else
12080          ac_pentiumpro=no
# Line 5770 | Line 12101 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12101                  if test -n "$is60x"; then
12102  
12103  
12104 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12105 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12104 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12105 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12106   if test "${ac_m_cpu_60x+set}" = set; then
12107    echo $ECHO_N "(cached) $ECHO_C" >&6
12108   else
12109    echo 'void f(){}' > conftest.cpp
12110 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12110 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12111          ac_m_cpu_60x=yes
12112   else
12113          ac_m_cpu_60x=no
# Line 5828 | Line 12159 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12159          :
12160  
12161  
12162 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12163 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12162 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12163 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12164   if test "${ac_m_cpu_750+set}" = set; then
12165    echo $ECHO_N "(cached) $ECHO_C" >&6
12166   else
12167    echo 'void f(){}' > conftest.cpp
12168 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12168 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12169          ac_m_cpu_750=yes
12170   else
12171          ac_m_cpu_750=no
# Line 5861 | Line 12192 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12192                  if test -z "$CPU_FLAGS"; then
12193  
12194  
12195 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12196 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12195 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12196 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12197   if test "${ac_m_cpu_powerpc+set}" = set; then
12198    echo $ECHO_N "(cached) $ECHO_C" >&6
12199   else
12200    echo 'void f(){}' > conftest.cpp
12201 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12201 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12202          ac_m_cpu_powerpc=yes
12203   else
12204          ac_m_cpu_powerpc=no
# Line 5889 | Line 12220 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12220                  if test -z "$CPU_FLAGS"; then
12221  
12222  
12223 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12224 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12223 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12224 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12225   if test "${ac_m_powerpc+set}" = set; then
12226    echo $ECHO_N "(cached) $ECHO_C" >&6
12227   else
12228    echo 'void f(){}' > conftest.cpp
12229 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12229 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12230          ac_m_powerpc=yes
12231   else
12232          ac_m_powerpc=no
# Line 5934 | Line 12265 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12265  
12266  
12267  
12268 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12269 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
12268 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12269 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12270   if test "${ac_guessed_cxxflags+set}" = set; then
12271    echo $ECHO_N "(cached) $ECHO_C" >&6
12272   else
12273    echo 'void f(){}' > conftest.cpp
12274 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12274 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12275          ac_guessed_cxxflags=yes
12276   else
12277          ac_guessed_cxxflags=no
# Line 5950 | Line 12281 | if test "$ac_guessed_cxxflags" = yes; then
12281   fi
12282   echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12283   echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12284 < if test "$ac_guessed_cxxflags" = yes; then
12285 <        :
5955 <
5956 < else
5957 <        :
5958 <
5959 <        echo ""
5960 <        echo "**********************************************************"
5961 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
5962 <        echo "* your compiler.                                         *"
5963 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
5964 <        echo "**********************************************************"
5965 <        echo ""
5966 <        CXXFLAGS=""
5967 <
5968 < fi
5969 <
5970 <
5971 < fi
5972 <
5973 <
5974 <
5975 <
5976 <
5977 < # Try to determine "good" native compiler flags if none specified on command
5978 < # line
5979 <
5980 < if test x"$F90FLAGS" = x ; then
5981 <  F90FLAGS=""
5982 <  case "${host_cpu}-${host_os}" in
5983 <
5984 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
5985 <                    F90FLAGS="-O"
5986 <                fi;;
5987 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
5988 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
5989 <                fi;;
5990 <   powerpc*-aix*)
5991 <        if test "$F90" = f90 -o "$F90" = xlf90; then
5992 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
5993 <                echo "*******************************************************"
5994 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
5995 <                echo "*  recommended that you use                           *"
5996 <                echo "*                                                     *"
5997 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
5998 <                echo "*                                 ^^^                 *"
5999 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6000 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6001 <                echo "*******************************************************"
6002 <        fi;;
6003 <   *darwin*)
6004 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6005 <                F90FLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto"
6006 <        fi;;
6007 <  esac
6008 <
6009 <  if test -n "$CPU_FLAGS"; then
6010 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6011 <  fi
6012 <
6013 <  if test -z "$F90FLAGS"; then
6014 <        echo ""
6015 <        echo "**********************************************************"
6016 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6017 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6018 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6019 <        echo "**********************************************************"
6020 <        echo ""
6021 <        F90FLAGS="-O3"
6022 <  fi
6023 <
6024 <
6025 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6026 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6027 < if test "${ac_guessed_f90flags+set}" = set; then
6028 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6029 < else
6030 <
6031 <
6032 <
6033 < ac_ext=f90
6034 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6035 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6036 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6037 <
6038 < echo 'program main' > conftest.$ac_ext
6039 < echo 'end program main' >> conftest.$ac_ext
6040 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6041 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6042 <  (eval $ac_compile) 2>&5
6043 <  ac_status=$?
6044 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6045 <  (exit $ac_status); }; then
6046 <        ac_guessed_f90flags=yes
6047 < else
6048 <        ac_guessed_f90flags=no
6049 < fi
6050 < rm -f conftest*
6051 < ac_ext=c
6052 < ac_cpp='$CPP $CPPFLAGS'
6053 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6054 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6055 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6056 <
6057 <
6058 < fi
6059 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6060 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
6061 < if test "$ac_guessed_f90flags" = yes; then
6062 <        :
6063 <
6064 < else
6065 <        :
6066 <
6067 <        echo ""
6068 <        echo "**********************************************************"
6069 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6070 <        echo "* your compiler.                                         *"
6071 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6072 <        echo "**********************************************************"
6073 <        echo ""
6074 <        F90FLAGS=""
6075 <
6076 < fi
6077 <
6078 <
6079 < fi
6080 <
6081 <     ;;
6082 < esac
6083 <
6084 < # Find a good install program.  We prefer a C program (faster),
6085 < # so one script is as good as another.  But avoid the broken or
6086 < # incompatible versions:
6087 < # SysV /etc/install, /usr/sbin/install
6088 < # SunOS /usr/etc/install
6089 < # IRIX /sbin/install
6090 < # AIX /bin/install
6091 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6092 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6093 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6094 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6095 < # OS/2's system install, which has a completely different semantic
6096 < # ./install, which can be erroneously created by make from ./install.sh.
6097 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6098 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6099 < if test -z "$INSTALL"; then
6100 < if test "${ac_cv_path_install+set}" = set; then
6101 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6102 < else
6103 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6104 < for as_dir in $PATH
6105 < do
6106 <  IFS=$as_save_IFS
6107 <  test -z "$as_dir" && as_dir=.
6108 <  # Account for people who put trailing slashes in PATH elements.
6109 < case $as_dir/ in
6110 <  ./ | .// | /cC/* | \
6111 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6112 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6113 <  /usr/ucb/* ) ;;
6114 <  *)
6115 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6116 <    # Don't use installbsd from OSF since it installs stuff as root
6117 <    # by default.
6118 <    for ac_prog in ginstall scoinst install; do
6119 <      for ac_exec_ext in '' $ac_executable_extensions; do
6120 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6121 <          if test $ac_prog = install &&
6122 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6123 <            # AIX install.  It has an incompatible calling convention.
6124 <            :
6125 <          elif test $ac_prog = install &&
6126 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6127 <            # program-specific install script used by HP pwplus--don't use.
6128 <            :
6129 <          else
6130 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6131 <            break 3
6132 <          fi
6133 <        fi
6134 <      done
6135 <    done
6136 <    ;;
6137 < esac
6138 < done
6139 <
6140 <
6141 < fi
6142 <  if test "${ac_cv_path_install+set}" = set; then
6143 <    INSTALL=$ac_cv_path_install
6144 <  else
6145 <    # As a last resort, use the slow shell script.  We don't cache a
6146 <    # path for INSTALL within a source directory, because that will
6147 <    # break other packages using the cache if that directory is
6148 <    # removed, or if the path is relative.
6149 <    INSTALL=$ac_install_sh
6150 <  fi
6151 < fi
6152 < echo "$as_me:$LINENO: result: $INSTALL" >&5
6153 < echo "${ECHO_T}$INSTALL" >&6
6154 <
6155 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6156 < # It thinks the first close brace ends the variable substitution.
6157 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6158 <
6159 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6160 <
6161 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6162 <
6163 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
6164 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6165 < LN_S=$as_ln_s
6166 < if test "$LN_S" = "ln -s"; then
6167 <  echo "$as_me:$LINENO: result: yes" >&5
6168 < echo "${ECHO_T}yes" >&6
6169 < else
6170 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6171 < echo "${ECHO_T}no, using $LN_S" >&6
6172 < fi
6173 <
6174 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6175 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6176 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6177 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6178 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6179 < else
6180 <  cat >conftest.make <<\_ACEOF
6181 < all:
6182 <        @echo 'ac_maketemp="$(MAKE)"'
6183 < _ACEOF
6184 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6185 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6186 < if test -n "$ac_maketemp"; then
6187 <  eval ac_cv_prog_make_${ac_make}_set=yes
6188 < else
6189 <  eval ac_cv_prog_make_${ac_make}_set=no
6190 < fi
6191 < rm -f conftest.make
6192 < fi
6193 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6194 <  echo "$as_me:$LINENO: result: yes" >&5
6195 < echo "${ECHO_T}yes" >&6
6196 <  SET_MAKE=
6197 < else
6198 <  echo "$as_me:$LINENO: result: no" >&5
6199 < echo "${ECHO_T}no" >&6
6200 <  SET_MAKE="MAKE=${MAKE-make}"
6201 < fi
6202 <
6203 < if test -n "$ac_tool_prefix"; then
6204 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6205 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6206 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6207 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6208 < if test "${ac_cv_prog_RANLIB+set}" = set; then
6209 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6210 < else
6211 <  if test -n "$RANLIB"; then
6212 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6213 < else
6214 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6215 < for as_dir in $PATH
6216 < do
6217 <  IFS=$as_save_IFS
6218 <  test -z "$as_dir" && as_dir=.
6219 <  for ac_exec_ext in '' $ac_executable_extensions; do
6220 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6221 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6222 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6223 <    break 2
6224 <  fi
6225 < done
6226 < done
6227 <
6228 < fi
6229 < fi
6230 < RANLIB=$ac_cv_prog_RANLIB
6231 < if test -n "$RANLIB"; then
6232 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6233 < echo "${ECHO_T}$RANLIB" >&6
6234 < else
6235 <  echo "$as_me:$LINENO: result: no" >&5
6236 < echo "${ECHO_T}no" >&6
6237 < fi
6238 <
6239 < fi
6240 < if test -z "$ac_cv_prog_RANLIB"; then
6241 <  ac_ct_RANLIB=$RANLIB
6242 <  # Extract the first word of "ranlib", so it can be a program name with args.
6243 < set dummy ranlib; ac_word=$2
6244 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6245 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6246 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6247 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6248 < else
6249 <  if test -n "$ac_ct_RANLIB"; then
6250 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6251 < else
6252 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6253 < for as_dir in $PATH
6254 < do
6255 <  IFS=$as_save_IFS
6256 <  test -z "$as_dir" && as_dir=.
6257 <  for ac_exec_ext in '' $ac_executable_extensions; do
6258 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6259 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6260 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6261 <    break 2
6262 <  fi
6263 < done
6264 < done
6265 <
6266 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6267 < fi
6268 < fi
6269 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6270 < if test -n "$ac_ct_RANLIB"; then
6271 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6272 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6273 < else
6274 <  echo "$as_me:$LINENO: result: no" >&5
6275 < echo "${ECHO_T}no" >&6
6276 < fi
6277 <
6278 <  RANLIB=$ac_ct_RANLIB
6279 < else
6280 <  RANLIB="$ac_cv_prog_RANLIB"
6281 < fi
6282 <
6283 < for ac_prog in 'bison -y' byacc
6284 < do
6285 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6286 < set dummy $ac_prog; ac_word=$2
6287 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6288 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6289 < if test "${ac_cv_prog_YACC+set}" = set; then
6290 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6291 < else
6292 <  if test -n "$YACC"; then
6293 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6294 < else
6295 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6296 < for as_dir in $PATH
6297 < do
6298 <  IFS=$as_save_IFS
6299 <  test -z "$as_dir" && as_dir=.
6300 <  for ac_exec_ext in '' $ac_executable_extensions; do
6301 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6302 <    ac_cv_prog_YACC="$ac_prog"
6303 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6304 <    break 2
6305 <  fi
6306 < done
6307 < done
6308 <
6309 < fi
6310 < fi
6311 < YACC=$ac_cv_prog_YACC
6312 < if test -n "$YACC"; then
6313 <  echo "$as_me:$LINENO: result: $YACC" >&5
6314 < echo "${ECHO_T}$YACC" >&6
6315 < else
6316 <  echo "$as_me:$LINENO: result: no" >&5
6317 < echo "${ECHO_T}no" >&6
6318 < fi
6319 <
6320 <  test -n "$YACC" && break
6321 < done
6322 < test -n "$YACC" || YACC="yacc"
6323 <
6324 < for ac_prog in flex lex
6325 < do
6326 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6327 < set dummy $ac_prog; ac_word=$2
6328 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6329 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6330 < if test "${ac_cv_prog_LEX+set}" = set; then
6331 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6332 < else
6333 <  if test -n "$LEX"; then
6334 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6335 < else
6336 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6337 < for as_dir in $PATH
6338 < do
6339 <  IFS=$as_save_IFS
6340 <  test -z "$as_dir" && as_dir=.
6341 <  for ac_exec_ext in '' $ac_executable_extensions; do
6342 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6343 <    ac_cv_prog_LEX="$ac_prog"
6344 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6345 <    break 2
6346 <  fi
6347 < done
6348 < done
6349 <
6350 < fi
6351 < fi
6352 < LEX=$ac_cv_prog_LEX
6353 < if test -n "$LEX"; then
6354 <  echo "$as_me:$LINENO: result: $LEX" >&5
6355 < echo "${ECHO_T}$LEX" >&6
6356 < else
6357 <  echo "$as_me:$LINENO: result: no" >&5
6358 < echo "${ECHO_T}no" >&6
6359 < fi
6360 <
6361 <  test -n "$LEX" && break
6362 < done
6363 < test -n "$LEX" || LEX=":"
6364 <
6365 < if test -z "$LEXLIB"
6366 < then
6367 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6368 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6369 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6370 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6371 < else
6372 <  ac_check_lib_save_LIBS=$LIBS
6373 < LIBS="-lfl  $LIBS"
6374 < cat >conftest.$ac_ext <<_ACEOF
6375 < /* confdefs.h.  */
6376 < _ACEOF
6377 < cat confdefs.h >>conftest.$ac_ext
6378 < cat >>conftest.$ac_ext <<_ACEOF
6379 < /* end confdefs.h.  */
6380 <
6381 < /* Override any gcc2 internal prototype to avoid an error.  */
6382 < #ifdef __cplusplus
6383 < extern "C"
6384 < #endif
6385 < /* We use char because int might match the return type of a gcc2
6386 <   builtin and then its argument prototype would still apply.  */
6387 < char yywrap ();
6388 < int
6389 < main ()
6390 < {
6391 < yywrap ();
6392 <  ;
6393 <  return 0;
6394 < }
6395 < _ACEOF
6396 < rm -f conftest.$ac_objext conftest$ac_exeext
6397 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6398 <  (eval $ac_link) 2>conftest.er1
6399 <  ac_status=$?
6400 <  grep -v '^ *+' conftest.er1 >conftest.err
6401 <  rm -f conftest.er1
6402 <  cat conftest.err >&5
6403 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6404 <  (exit $ac_status); } &&
6405 <         { ac_try='test -z "$ac_c_werror_flag"
6406 <                         || test ! -s conftest.err'
6407 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6408 <  (eval $ac_try) 2>&5
6409 <  ac_status=$?
6410 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6411 <  (exit $ac_status); }; } &&
6412 <         { ac_try='test -s conftest$ac_exeext'
6413 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6414 <  (eval $ac_try) 2>&5
6415 <  ac_status=$?
6416 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6417 <  (exit $ac_status); }; }; then
6418 <  ac_cv_lib_fl_yywrap=yes
6419 < else
6420 <  echo "$as_me: failed program was:" >&5
6421 < sed 's/^/| /' conftest.$ac_ext >&5
6422 <
6423 < ac_cv_lib_fl_yywrap=no
6424 < fi
6425 < rm -f conftest.err conftest.$ac_objext \
6426 <      conftest$ac_exeext conftest.$ac_ext
6427 < LIBS=$ac_check_lib_save_LIBS
6428 < fi
6429 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6430 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6431 < if test $ac_cv_lib_fl_yywrap = yes; then
6432 <  LEXLIB="-lfl"
6433 < else
6434 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6435 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6436 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
6437 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6438 < else
6439 <  ac_check_lib_save_LIBS=$LIBS
6440 < LIBS="-ll  $LIBS"
6441 < cat >conftest.$ac_ext <<_ACEOF
6442 < /* confdefs.h.  */
6443 < _ACEOF
6444 < cat confdefs.h >>conftest.$ac_ext
6445 < cat >>conftest.$ac_ext <<_ACEOF
6446 < /* end confdefs.h.  */
6447 <
6448 < /* Override any gcc2 internal prototype to avoid an error.  */
6449 < #ifdef __cplusplus
6450 < extern "C"
6451 < #endif
6452 < /* We use char because int might match the return type of a gcc2
6453 <   builtin and then its argument prototype would still apply.  */
6454 < char yywrap ();
6455 < int
6456 < main ()
6457 < {
6458 < yywrap ();
6459 <  ;
6460 <  return 0;
6461 < }
6462 < _ACEOF
6463 < rm -f conftest.$ac_objext conftest$ac_exeext
6464 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6465 <  (eval $ac_link) 2>conftest.er1
6466 <  ac_status=$?
6467 <  grep -v '^ *+' conftest.er1 >conftest.err
6468 <  rm -f conftest.er1
6469 <  cat conftest.err >&5
6470 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6471 <  (exit $ac_status); } &&
6472 <         { ac_try='test -z "$ac_c_werror_flag"
6473 <                         || test ! -s conftest.err'
6474 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6475 <  (eval $ac_try) 2>&5
6476 <  ac_status=$?
6477 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6478 <  (exit $ac_status); }; } &&
6479 <         { ac_try='test -s conftest$ac_exeext'
6480 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6481 <  (eval $ac_try) 2>&5
6482 <  ac_status=$?
6483 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6484 <  (exit $ac_status); }; }; then
6485 <  ac_cv_lib_l_yywrap=yes
6486 < else
6487 <  echo "$as_me: failed program was:" >&5
6488 < sed 's/^/| /' conftest.$ac_ext >&5
6489 <
6490 < ac_cv_lib_l_yywrap=no
6491 < fi
6492 < rm -f conftest.err conftest.$ac_objext \
6493 <      conftest$ac_exeext conftest.$ac_ext
6494 < LIBS=$ac_check_lib_save_LIBS
6495 < fi
6496 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
6497 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
6498 < if test $ac_cv_lib_l_yywrap = yes; then
6499 <  LEXLIB="-ll"
6500 < fi
6501 <
6502 < fi
6503 <
6504 < fi
6505 <
6506 < if test "x$LEX" != "x:"; then
6507 <  echo "$as_me:$LINENO: checking lex output file root" >&5
6508 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
6509 < if test "${ac_cv_prog_lex_root+set}" = set; then
6510 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6511 < else
6512 <  # The minimal lex program is just a single line: %%.  But some broken lexes
6513 < # (Solaris, I think it was) want two %% lines, so accommodate them.
6514 < cat >conftest.l <<_ACEOF
6515 < %%
6516 < %%
6517 < _ACEOF
6518 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
6519 <  (eval $LEX conftest.l) 2>&5
6520 <  ac_status=$?
6521 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6522 <  (exit $ac_status); }
6523 < if test -f lex.yy.c; then
6524 <  ac_cv_prog_lex_root=lex.yy
6525 < elif test -f lexyy.c; then
6526 <  ac_cv_prog_lex_root=lexyy
6527 < else
6528 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
6529 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
6530 <   { (exit 1); exit 1; }; }
6531 < fi
6532 < fi
6533 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
6534 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
6535 < rm -f conftest.l
6536 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
6537 <
6538 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
6539 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
6540 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
6541 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6542 < else
6543 <  # POSIX says lex can declare yytext either as a pointer or an array; the
6544 < # default is implementation-dependent. Figure out which it is, since
6545 < # not all implementations provide the %pointer and %array declarations.
6546 < ac_cv_prog_lex_yytext_pointer=no
6547 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
6548 < ac_save_LIBS=$LIBS
6549 < LIBS="$LIBS $LEXLIB"
6550 < cat >conftest.$ac_ext <<_ACEOF
6551 < `cat $LEX_OUTPUT_ROOT.c`
6552 < _ACEOF
6553 < rm -f conftest.$ac_objext conftest$ac_exeext
6554 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6555 <  (eval $ac_link) 2>conftest.er1
6556 <  ac_status=$?
6557 <  grep -v '^ *+' conftest.er1 >conftest.err
6558 <  rm -f conftest.er1
6559 <  cat conftest.err >&5
6560 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6561 <  (exit $ac_status); } &&
6562 <         { ac_try='test -z "$ac_c_werror_flag"
6563 <                         || test ! -s conftest.err'
6564 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6565 <  (eval $ac_try) 2>&5
6566 <  ac_status=$?
6567 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6568 <  (exit $ac_status); }; } &&
6569 <         { ac_try='test -s conftest$ac_exeext'
6570 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6571 <  (eval $ac_try) 2>&5
6572 <  ac_status=$?
6573 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6574 <  (exit $ac_status); }; }; then
6575 <  ac_cv_prog_lex_yytext_pointer=yes
6576 < else
6577 <  echo "$as_me: failed program was:" >&5
6578 < sed 's/^/| /' conftest.$ac_ext >&5
6579 <
6580 < fi
6581 < rm -f conftest.err conftest.$ac_objext \
6582 <      conftest$ac_exeext conftest.$ac_ext
6583 < LIBS=$ac_save_LIBS
6584 < rm -f "${LEX_OUTPUT_ROOT}.c"
12284 > if test "$ac_guessed_cxxflags" = yes; then
12285 >        :
12286  
12287 < fi
12288 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
6588 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
6589 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12287 > else
12288 >        :
12289  
12290 < cat >>confdefs.h <<\_ACEOF
12291 < #define YYTEXT_POINTER 1
12292 < _ACEOF
12290 >        echo ""
12291 >        echo "**********************************************************"
12292 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12293 >        echo "* your compiler.                                         *"
12294 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12295 >        echo "**********************************************************"
12296 >        echo ""
12297 >        CXXFLAGS=""
12298  
12299   fi
12300  
6597 – fi
6598 – # Extract the first word of "ar", so it can be a program name with args.
6599 – set dummy ar; ac_word=$2
6600 – echo "$as_me:$LINENO: checking for $ac_word" >&5
6601 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6602 – if test "${ac_cv_prog_AR+set}" = set; then
6603 –  echo $ECHO_N "(cached) $ECHO_C" >&6
6604 – else
6605 –  if test -n "$AR"; then
6606 –  ac_cv_prog_AR="$AR" # Let the user override the test.
6607 – else
6608 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6609 – for as_dir in $PATH
6610 – do
6611 –  IFS=$as_save_IFS
6612 –  test -z "$as_dir" && as_dir=.
6613 –  for ac_exec_ext in '' $ac_executable_extensions; do
6614 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6615 –    ac_cv_prog_AR="ar"
6616 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6617 –    break 2
6618 –  fi
6619 – done
6620 – done
12301  
6622 –  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12302   fi
6624 – fi
6625 – AR=$ac_cv_prog_AR
6626 – if test -n "$AR"; then
6627 –  echo "$as_me:$LINENO: result: $AR" >&5
6628 – echo "${ECHO_T}$AR" >&6
6629 – else
6630 –  echo "$as_me:$LINENO: result: no" >&5
6631 – echo "${ECHO_T}no" >&6
6632 – fi
12303  
12304 < if test "$AR" = "NONE"; then
12305 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
6636 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
6637 <   { (exit 1); exit 1; }; }
6638 <  cat >confcache <<\_ACEOF
6639 < # This file is a shell script that caches the results of configure
6640 < # tests run on this system so they can be shared between configure
6641 < # scripts and configure runs, see configure's option --config-cache.
6642 < # It is not useful on other systems.  If it contains results you don't
6643 < # want to keep, you may remove or edit it.
6644 < #
6645 < # config.status only pays attention to the cache file if you give it
6646 < # the --recheck option to rerun configure.
6647 < #
6648 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
6649 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
6650 < # following values.
12304 >     ;;
12305 > esac
12306  
12307 +
12308 + cat >>confdefs.h <<\_ACEOF
12309 + #define OBAPI
12310   _ACEOF
12311  
6654 – # The following way of writing the cache mishandles newlines in values,
6655 – # but we know of no workaround that is simple, portable, and efficient.
6656 – # So, don't put newlines in cache variables' values.
6657 – # Ultrix sh set writes to stderr and can't be redirected directly,
6658 – # and sets the high bit in the cache file unless we assign to the vars.
6659 – {
6660 –  (set) 2>&1 |
6661 –    case `(ac_space=' '; set | grep ac_space) 2>&1` in
6662 –    *ac_space=\ *)
6663 –      # `set' does not quote correctly, so add quotes (double-quote
6664 –      # substitution turns \\\\ into \\, and sed turns \\ into \).
6665 –      sed -n \
6666 –        "s/'/'\\\\''/g;
6667 –          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6668 –      ;;
6669 –    *)
6670 –      # `set' quotes correctly as required by POSIX, so do not add quotes.
6671 –      sed -n \
6672 –        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
6673 –      ;;
6674 –    esac;
6675 – } |
6676 –  sed '
6677 –     t clear
6678 –     : clear
6679 –     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6680 –     t end
6681 –     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6682 –     : end' >>confcache
6683 – if diff $cache_file confcache >/dev/null 2>&1; then :; else
6684 –  if test -w $cache_file; then
6685 –    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
6686 –    cat confcache >$cache_file
6687 –  else
6688 –    echo "not updating unwritable cache $cache_file"
6689 –  fi
6690 – fi
6691 – rm -f confcache
6692 –  exit 1
6693 – fi
12312  
12313  
12314  
# Line 6722 | Line 12340 | echo '#include <mpi.h>' > conftest.cc
12340   echo "$as_me:$LINENO: checking for mpi.h" >&5
12341   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
12342   have_mpi_h=0
12343 + rm -f conftest*
12344   echo '#include <mpi.h>' > conftest.cc
12345 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
12345 > if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
12346          echo "$as_me:$LINENO: result: yes" >&5
12347   echo "${ECHO_T}yes" >&6
12348          have_mpi_h=1
12349   else
12350 +        if test -s conftest.out ; then
12351 +                cat conftest.out >> config.log
12352 +        fi
12353          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
12354   echo "${ECHO_T}no! Check MPI include paths" >&6
12355          USE_MPI="no"
# Line 6745 | Line 12367 | cat >conftest.f90 <<EOF
12367   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
12368   have_mpif_h=0
12369   rm -f conftest*
12370 < cat >conftest.f90 <<EOF
12370 > cat >conftest.$ac_ext <<EOF
12371   program main
12372     include 'mpif.h'
12373   end
12374   EOF
12375 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
12375 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
12376          echo "$as_me:$LINENO: result: yes" >&5
12377   echo "${ECHO_T}yes" >&6
12378          MPI_F90_INC="$MPI_INC_DIR"
# Line 6804 | Line 12426 | int
12426   /* We use char because int might match the return type of a gcc2
12427     builtin and then its argument prototype would still apply.  */
12428   char MPI_Init ();
12429 + #ifdef FC_DUMMY_MAIN
12430 + #ifndef FC_DUMMY_MAIN_EQ_F77
12431 + #  ifdef __cplusplus
12432 +     extern "C"
12433 + #  endif
12434 +   int FC_DUMMY_MAIN() { return 1; }
12435 + #endif
12436 + #endif
12437   int
12438   main ()
12439   {
# Line 6874 | Line 12504 | int
12504   /* We use char because int might match the return type of a gcc2
12505     builtin and then its argument prototype would still apply.  */
12506   char MPI_Init ();
12507 + #ifdef FC_DUMMY_MAIN
12508 + #ifndef FC_DUMMY_MAIN_EQ_F77
12509 + #  ifdef __cplusplus
12510 +     extern "C"
12511 + #  endif
12512 +   int FC_DUMMY_MAIN() { return 1; }
12513 + #endif
12514 + #endif
12515   int
12516   main ()
12517   {
# Line 6945 | Line 12583 | int
12583   /* We use char because int might match the return type of a gcc2
12584     builtin and then its argument prototype would still apply.  */
12585   char MPI_Init ();
12586 + #ifdef FC_DUMMY_MAIN
12587 + #ifndef FC_DUMMY_MAIN_EQ_F77
12588 + #  ifdef __cplusplus
12589 +     extern "C"
12590 + #  endif
12591 +   int FC_DUMMY_MAIN() { return 1; }
12592 + #endif
12593 + #endif
12594   int
12595   main ()
12596   {
# Line 6993 | Line 12639 | fi
12639   fi
12640  
12641   fi
12642 <
6997 < $as_unset ac_cv_lib_mpi_MPI_Init
12642 > $as_unset ac_cv_lib_mpich_MPI_Init
12643   if test x = x"$MPI_LIB"; then
12644 < echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
12645 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
12646 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
12644 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
12645 > echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
12646 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
12647    echo $ECHO_N "(cached) $ECHO_C" >&6
12648   else
12649    ac_check_lib_save_LIBS=$LIBS
12650 < LIBS="-lmpi -llam -lpthread $LIBS"
12650 > LIBS="-lmpich "-lpmpich" $LIBS"
12651   cat >conftest.$ac_ext <<_ACEOF
12652   /* confdefs.h.  */
12653   _ACEOF
# Line 7017 | Line 12662 | int
12662   /* We use char because int might match the return type of a gcc2
12663     builtin and then its argument prototype would still apply.  */
12664   char MPI_Init ();
12665 + #ifdef FC_DUMMY_MAIN
12666 + #ifndef FC_DUMMY_MAIN_EQ_F77
12667 + #  ifdef __cplusplus
12668 +     extern "C"
12669 + #  endif
12670 +   int FC_DUMMY_MAIN() { return 1; }
12671 + #endif
12672 + #endif
12673   int
12674   main ()
12675   {
# Line 7047 | Line 12700 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12700    ac_status=$?
12701    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12702    (exit $ac_status); }; }; then
12703 <  ac_cv_lib_mpi_MPI_Init=yes
12703 >  ac_cv_lib_mpich_MPI_Init=yes
12704   else
12705    echo "$as_me: failed program was:" >&5
12706   sed 's/^/| /' conftest.$ac_ext >&5
12707  
12708 < ac_cv_lib_mpi_MPI_Init=no
12708 > ac_cv_lib_mpich_MPI_Init=no
12709   fi
12710   rm -f conftest.err conftest.$ac_objext \
12711        conftest$ac_exeext conftest.$ac_ext
12712   LIBS=$ac_check_lib_save_LIBS
12713   fi
12714 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
12715 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
12716 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
12717 <  MPI_LIB="-lmpi -llam -lpthread"
7065 < else
7066 <
7067 <             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7068 < echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7069 <   { (exit 1); exit 1; }; }
7070 <             USE_MPI="no"
7071 <
7072 < fi
7073 <
7074 < fi
7075 <
7076 <
7077 <
7078 < echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
7079 < echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
7080 < MPI_F90_LIB=""
7081 < if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7082 <        MPI_F90_LIB="-lfmpich"
7083 < elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7084 <        MPI_F90_LIB="-llamf77mpi"
7085 < else
7086 <                        MPI_F90_LIB="  "
12714 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
12715 > echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
12716 > if test $ac_cv_lib_mpich_MPI_Init = yes; then
12717 >  MPI_LIB="-lmpich -lpmpich"
12718   fi
7088 – echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
7089 – echo "${ECHO_T}found $MPI_F90_LIB" >&6
12719  
7091 –
12720   fi
12721  
12722 <
12723 <
12724 < # Check whether --with-sprng or --without-sprng was given.
12725 < if test "${with_sprng+set}" = set; then
12726 <  withval="$with_sprng"
7099 <  with_sprng=$withval
7100 < else
7101 <  with_sprng="/usr/local"
7102 < fi;
7103 <
7104 < case "x$with_sprng" in
7105 <        xyes | "x")  USE_SPRNG=yes;;
7106 <        xno) USE_SPRNG=no ;;
7107 <        *) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7108 < esac
7109 < if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7110 <        SPRNG="/usr/local"
7111 < fi
7112 < if test "$USE_SPRNG" = "yes"; then
7113 <
7114 <
7115 < # Set variables...
7116 < SPRNG_LIB_DIR="$SPRNG/lib"
7117 < SPRNG_INC_DIR="$SPRNG/include"
7118 <
7119 <
7120 <
7121 < echo "$as_me:$LINENO: checking for sprng.h" >&5
7122 < echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
7123 < have_sprng_h=0
7124 < echo '#include <sprng.h>' > conftest.cc
7125 < if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
7126 <        echo "$as_me:$LINENO: result: yes" >&5
7127 < echo "${ECHO_T}yes" >&6
7128 <        have_sprng_h=1
7129 < else
7130 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7131 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
7132 <        USE_SPRNG="no"
7133 < fi
7134 < rm -f conftest*
7135 < if test "$have_sprng_h" = 1; then
7136 <
7137 < cat >>confdefs.h <<\_ACEOF
7138 < #define HAVE_SPRNG_H 1
7139 < _ACEOF
7140 <
7141 < fi
7142 <
7143 < ac_ext=c
7144 < ac_cpp='$CPP $CPPFLAGS'
7145 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7146 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7147 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7148 <
7149 < ac_save_LDFLAGS=$LDFLAGS
7150 < LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
7151 <
7152 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
7153 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
7154 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
12722 > $as_unset ac_cv_lib_mpi_MPI_Init
12723 > if test x = x"$MPI_LIB"; then
12724 > echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
12725 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
12726 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
12727    echo $ECHO_N "(cached) $ECHO_C" >&6
12728   else
12729    ac_check_lib_save_LIBS=$LIBS
12730 < LIBS="-lsprng  $LIBS"
12730 > LIBS="-lmpi -llam -lpthread $LIBS"
12731   cat >conftest.$ac_ext <<_ACEOF
12732   /* confdefs.h.  */
12733   _ACEOF
# Line 7169 | Line 12741 | char init_rng ();
12741   #endif
12742   /* We use char because int might match the return type of a gcc2
12743     builtin and then its argument prototype would still apply.  */
12744 < char init_rng ();
12744 > char MPI_Init ();
12745 > #ifdef FC_DUMMY_MAIN
12746 > #ifndef FC_DUMMY_MAIN_EQ_F77
12747 > #  ifdef __cplusplus
12748 >     extern "C"
12749 > #  endif
12750 >   int FC_DUMMY_MAIN() { return 1; }
12751 > #endif
12752 > #endif
12753   int
12754   main ()
12755   {
12756 < init_rng ();
12756 > MPI_Init ();
12757    ;
12758    return 0;
12759   }
# Line 7200 | Line 12780 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12780    ac_status=$?
12781    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12782    (exit $ac_status); }; }; then
12783 <  ac_cv_lib_sprng_init_rng=yes
12783 >  ac_cv_lib_mpi_MPI_Init=yes
12784   else
12785    echo "$as_me: failed program was:" >&5
12786   sed 's/^/| /' conftest.$ac_ext >&5
12787  
12788 < ac_cv_lib_sprng_init_rng=no
12788 > ac_cv_lib_mpi_MPI_Init=no
12789   fi
12790   rm -f conftest.err conftest.$ac_objext \
12791        conftest$ac_exeext conftest.$ac_ext
12792   LIBS=$ac_check_lib_save_LIBS
12793   fi
12794 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
12795 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
12796 < if test $ac_cv_lib_sprng_init_rng = yes; then
12797 <  SPRNG_LIB="-lsprng"
12794 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
12795 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
12796 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
12797 >  MPI_LIB="-lmpi -llam -lpthread"
12798   else
12799  
12800 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
12801 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
12800 >             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
12801 > echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
12802     { (exit 1); exit 1; }; }
12803 <             USE_SPRNG="no"
12803 >             USE_MPI="no"
12804  
12805   fi
12806  
12807 + fi
12808  
12809 < if test "$USE_SPRNG" = "no"; then
12810 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
12811 < echo "$as_me: error: No working SPRNG library found" >&2;}
12812 <   { (exit 1); exit 1; }; }
12809 >
12810 >
12811 > echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
12812 > echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
12813 > MPI_F90_LIB=""
12814 > if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
12815 >        MPI_F90_LIB="-lfmpich"
12816 > elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
12817 >        MPI_F90_LIB="-llamf77mpi"
12818 > else
12819 >                        MPI_F90_LIB="  "
12820   fi
12821 + echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
12822 + echo "${ECHO_T}found $MPI_F90_LIB" >&6
12823  
12824  
12825   fi
12826  
12827  
12828  
12829 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
12830 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
12829 > USE_CGAL=no
12830 > cgal_makefile=auto
12831  
12832 < # Check whether --with-mkl or --without-mkl was given.
12833 < if test "${with_mkl+set}" = set; then
12834 <  withval="$with_mkl"
12835 <     echo "$as_me:$LINENO: result: yes" >&5
12836 < echo "${ECHO_T}yes" >&6
7247 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7248 <        mkldir="$dir"
7249 <        if test -f "$dir/include/mkl.h"; then
7250 <            found_mkl="yes";
7251 <            break;
7252 <        fi
7253 <    done
7254 <    if test x_$found_mkl != x_yes; then
7255 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7256 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7257 <   { (exit 1); exit 1; }; }
7258 <    else
7259 <        printf "MKL includes found in $mkldir/include\n";
7260 <    fi
12832 > # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
12833 > if test "${with_cgal_makefile+set}" = set; then
12834 >  withval="$with_cgal_makefile"
12835 >  cgal_makefile="$withval"
12836 > fi;
12837  
12838 + if test "x$cgal_makefile" != xno; then
12839  
12840 +  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
12841 +    cgal_makefile="$CGAL_MAKEFILE"
12842 +  fi
12843  
12844 <  ac_ext=c
12845 < ac_cpp='$CPP $CPPFLAGS'
7266 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7267 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7268 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
12844 >  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
12845 > echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
12846  
12847 <  ac_save_CPPFLAGS=$CPPFLAGS
12848 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
12849 <  ac_save_LDFLAGS=$LDFLAGS
12850 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
12851 <  if test "${ac_cv_header_mkl_h+set}" = set; then
12852 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
12853 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
12854 < if test "${ac_cv_header_mkl_h+set}" = set; then
12847 >  if test -f "$cgal_makefile"; then
12848 >
12849 >    cat >config.tmp.Makefile <<EOF
12850 > include $cgal_makefile
12851 > default:
12852 >        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
12853 >        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
12854 >        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
12855 >        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
12856 >        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
12857 >        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
12858 >        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
12859 >        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
12860 >        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
12861 >        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
12862 >        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
12863 >        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
12864 > EOF
12865 >
12866 >    make -s -f config.tmp.Makefile
12867 >    . config.tmp.cgalvariables
12868 >
12869 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
12870 >
12871 >    if test "x$CGAL_INCLDIR" = "x"; then
12872 >      CGAL_INCLDIR=""
12873 >    fi
12874 >
12875 >    if test "x$CGAL_LIBDIR" = "x"; then
12876 >      CGAL_LIBDIR=""
12877 >    fi
12878 >
12879 >    if test "x$CGAL_RLIBDIR" = "x"; then
12880 >      CGAL_RLIBDIR=""
12881 >    fi
12882 >
12883 >    if test "x$LEDA_INCLDIR" = "x"; then
12884 >      LEDA_INCLDIR=""
12885 >    fi
12886 >
12887 >    if test "x$LEDA_LIBDIR" = "x"; then
12888 >      LEDA_LIBDIR=""
12889 >    fi
12890 >
12891 >    if test "x$LEDA_RLIBDIR" = "x"; then
12892 >      LEDA_RLIBDIR=""
12893 >    fi
12894 >
12895 >    if test "x$GMP_INCLDIR" = "x"; then
12896 >      GMP_INCLDIR=""
12897 >    fi
12898 >
12899 >    if test "x$GMP_LIBDIR" = "x"; then
12900 >      GMP_LIBDIR=""
12901 >    fi
12902 >
12903 >    if test "x$GMP_RLIBDIR" = "x"; then
12904 >      GMP_RLIBDIR=""
12905 >    fi
12906 >
12907 >    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
12908 > echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
12909 >    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
12910 > echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
12911 >    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
12912 > echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
12913 >    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
12914 > echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
12915 >    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
12916 > echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
12917 >    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
12918 > echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
12919 >    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
12920 > echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
12921 >    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
12922 > echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
12923 >    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
12924 > echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
12925 >
12926 >    ac_ext=cc
12927 > ac_cpp='$CXXCPP $CPPFLAGS'
12928 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12929 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12930 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12931 >
12932 >    save_CXXFLAGS="$CXXFLAGS"
12933 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
12934 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
12935 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
12936 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
12937 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
12938    echo $ECHO_N "(cached) $ECHO_C" >&6
12939   fi
12940 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
12941 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
12940 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
12941 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
12942   else
12943    # Is the header compilable?
12944 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
12945 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
12944 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
12945 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
12946   cat >conftest.$ac_ext <<_ACEOF
12947   /* confdefs.h.  */
12948   _ACEOF
# Line 7290 | Line 12950 | $ac_includes_default
12950   cat >>conftest.$ac_ext <<_ACEOF
12951   /* end confdefs.h.  */
12952   $ac_includes_default
12953 < #include <mkl.h>
12953 > #include <CGAL/Cartesian.h>
12954   _ACEOF
12955   rm -f conftest.$ac_objext
12956   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7301 | Line 12961 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12961    cat conftest.err >&5
12962    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12963    (exit $ac_status); } &&
12964 <         { ac_try='test -z "$ac_c_werror_flag"
12964 >         { ac_try='test -z "$ac_cxx_werror_flag"
12965                           || test ! -s conftest.err'
12966    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12967    (eval $ac_try) 2>&5
# Line 7326 | Line 12986 | echo "$as_me:$LINENO: checking mkl.h presence" >&5
12986   echo "${ECHO_T}$ac_header_compiler" >&6
12987  
12988   # Is the header present?
12989 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
12990 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
12989 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
12990 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
12991   cat >conftest.$ac_ext <<_ACEOF
12992   /* confdefs.h.  */
12993   _ACEOF
12994   cat confdefs.h >>conftest.$ac_ext
12995   cat >>conftest.$ac_ext <<_ACEOF
12996   /* end confdefs.h.  */
12997 < #include <mkl.h>
12997 > #include <CGAL/Cartesian.h>
12998   _ACEOF
12999   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13000    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 7345 | Line 13005 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13005    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13006    (exit $ac_status); } >/dev/null; then
13007    if test -s conftest.err; then
13008 <    ac_cpp_err=$ac_c_preproc_warn_flag
13009 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13008 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13009 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13010    else
13011      ac_cpp_err=
13012    fi
# Line 7366 | Line 13026 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
13026   echo "${ECHO_T}$ac_header_preproc" >&6
13027  
13028   # So?  What about this header?
13029 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13029 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13030    yes:no: )
13031 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13032 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13033 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
13034 < echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
13031 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13032 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13033 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13034 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13035      ac_header_preproc=yes
13036      ;;
13037    no:yes:* )
13038 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13039 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13040 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
13041 < echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
13042 <    { echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
13043 < echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
13044 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
13045 < echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13046 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13047 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13048 <    { echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
13049 < echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
13038 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13039 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13040 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13041 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13042 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13043 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13044 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13045 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13046 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13047 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13048 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13049 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13050      (
13051        cat <<\_ASBOX
13052   ## ------------------------------ ##
# Line 7397 | Line 13057 | echo "$as_me:$LINENO: checking for mkl.h" >&5
13057        sed "s/^/$as_me: WARNING:     /" >&2
13058      ;;
13059   esac
13060 < echo "$as_me:$LINENO: checking for mkl.h" >&5
13061 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13062 < if test "${ac_cv_header_mkl_h+set}" = set; then
13060 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13061 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13062 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13063    echo $ECHO_N "(cached) $ECHO_C" >&6
13064   else
13065 <  ac_cv_header_mkl_h=$ac_header_preproc
13065 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13066   fi
13067 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13068 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13067 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13068 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13069  
13070   fi
13071 < if test $ac_cv_header_mkl_h = yes; then
13072 <
7413 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
7414 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
7415 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
7416 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13071 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13072 >  cgal=yes
13073   else
13074 <  ac_check_lib_save_LIBS=$LIBS
13075 < LIBS="-lmkl  $LIBS"
13074 >  cgal=no
13075 > fi
13076 >
13077 >
13078 >    CXXFLAGS="$save_CXXFLAGS"
13079 >
13080 >    if test "x$cgal" = xyes; then
13081 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
13082 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
13083 >      LOCATION=${CGAL_INCLDIR}
13084 >      LOCATION=${LOCATION:-/usr/include}
13085 >      if test -f $LOCATION/CGAL/version.h; then
13086 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
13087 >      else
13088 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
13089 >      fi
13090 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
13091 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
13092 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
13093 >      else
13094 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
13095 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
13096 >        cgal=no
13097 >      fi
13098 >    fi
13099 >
13100 >    if test "x$cgal" = xyes; then
13101 >      CGAL_LIBS="-lCGAL"
13102 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13103 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13104 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13105 >        CGAL_USES_LEDA=yes
13106 >        echo "$as_me:$LINENO: result: yes" >&5
13107 > echo "${ECHO_T}yes" >&6
13108 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13109 >      else
13110 >        echo "$as_me:$LINENO: result: no" >&5
13111 > echo "${ECHO_T}no" >&6
13112 >        CGAL_USES_LEDA=no
13113 >      fi
13114 >
13115 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13116 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13117 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13118 >        CGAL_USES_GMP=yes
13119 >        echo "$as_me:$LINENO: result: yes" >&5
13120 > echo "${ECHO_T}yes" >&6
13121 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13122 >      else
13123 >        echo "$as_me:$LINENO: result: no" >&5
13124 > echo "${ECHO_T}no" >&6
13125 >        CGAL_USES_GMP=no
13126 >      fi
13127 >
13128 >      CGAL_LIBS="$CGAL_LIBS -lm"
13129 >
13130 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
13131 >
13132 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13133 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13134 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13135 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13136 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13137 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13138 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13139 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13140 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13141 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13142 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13143 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13144 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13145 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13146 >    fi
13147 >
13148 >    if test "x$cgal" = xyes; then
13149 >      save_LIBS="$LIBS"
13150 >      LIBS="$LIBS -L$CGAL_LIBDIR"
13151 >      if test "x$CGAL_USES_LEDA" = xyes; then
13152 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13153 >      fi
13154 >      # if test "x$CGAL_USES_GMP" = xyes; then
13155 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13156 >      # fi
13157 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13158 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13159 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13160 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13161 > save_LIBS_CHECK_CXX_LIB="$LIBS"
13162 > LIBS="-lCGAL  $LIBS"
13163   cat >conftest.$ac_ext <<_ACEOF
13164   /* confdefs.h.  */
13165   _ACEOF
13166   cat confdefs.h >>conftest.$ac_ext
13167   cat >>conftest.$ac_ext <<_ACEOF
13168   /* end confdefs.h.  */
13169 <
13170 < /* Override any gcc2 internal prototype to avoid an error.  */
13171 < #ifdef __cplusplus
13172 < extern "C"
13169 > #include <CGAL/Cartesian.h>
13170 > #ifdef FC_DUMMY_MAIN
13171 > #ifndef FC_DUMMY_MAIN_EQ_F77
13172 > #  ifdef __cplusplus
13173 >     extern "C"
13174 > #  endif
13175 >   int FC_DUMMY_MAIN() { return 1; }
13176   #endif
13177 < /* We use char because int might match the return type of a gcc2
7432 <   builtin and then its argument prototype would still apply.  */
7433 < char vslNewStream ();
13177 > #endif
13178   int
13179   main ()
13180   {
13181 < vslNewStream ();
13181 > ::CGAL::Cartesian<int>::Point_2 P
13182    ;
13183    return 0;
13184   }
# Line 7448 | Line 13192 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13192    cat conftest.err >&5
13193    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13194    (exit $ac_status); } &&
13195 <         { ac_try='test -z "$ac_c_werror_flag"
13195 >         { ac_try='test -z "$ac_cxx_werror_flag"
13196                           || test ! -s conftest.err'
13197    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13198    (eval $ac_try) 2>&5
# Line 7461 | Line 13205 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13205    ac_status=$?
13206    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13207    (exit $ac_status); }; }; then
13208 <  ac_cv_lib_mkl_vslNewStream=yes
13208 >  echo "$as_me:$LINENO: result: yes" >&5
13209 > echo "${ECHO_T}yes" >&6
13210 > cgal=yes
13211   else
13212    echo "$as_me: failed program was:" >&5
13213   sed 's/^/| /' conftest.$ac_ext >&5
13214  
13215 < ac_cv_lib_mkl_vslNewStream=no
13215 > echo "$as_me:$LINENO: result: no" >&5
13216 > echo "${ECHO_T}no" >&6
13217 > cgal=no
13218   fi
13219   rm -f conftest.err conftest.$ac_objext \
13220        conftest$ac_exeext conftest.$ac_ext
13221 < LIBS=$ac_check_lib_save_LIBS
13222 < fi
13223 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
13224 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
7477 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
7478 <  MKL_LIBDIR="${mkldir}/lib/32",
7479 <                     MKL_LIB="-lmkl -lvml -lguide",
7480 <                     HAVE_MKL="yes"
7481 < fi
13221 > CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13222 > LIBS="$save_LIBS_CHECK_CXX_LIB"
13223 >      LIBS="$save_LIBS"
13224 >    fi
13225  
13226 <
7484 < else
7485 <  MKL_INC="-I${mkldir}/include"
7486 < fi
7487 <
7488 <
7489 <  CPPFLAGS=$ac_save_CPPFLAGS
7490 <  LDFLAGS=$ac_save_LDFLAGS
13226 >  fi
13227    ac_ext=c
13228   ac_cpp='$CPP $CPPFLAGS'
13229   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7495 | Line 13231 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
13231   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13232  
13233  
13234 <  if test x_$HAVE_MKL != x_yes; then
7499 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
7500 < echo "$as_me: error: Can't build with MKL" >&2;}
7501 <   { (exit 1); exit 1; }; }
7502 <  fi
13234 > fi
13235  
13236 + if test "x$cgal" = xyes; then
13237 +  USE_CGAL=yes
13238  
13239 + cat >>confdefs.h <<\_ACEOF
13240 + #define HAVE_CGAL 1
13241 + _ACEOF
13242  
13243  
13244 + cat >>confdefs.h <<_ACEOF
13245 + #define CGAL_VERSION $CGAL_VERSION
13246 + _ACEOF
13247  
13248 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
13249 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13250 + echo "$as_me: WARNING: *****************************************************" >&2;}
13251 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
13252 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
13253 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
13254 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
13255 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13256 + echo "$as_me: WARNING: *****************************************************" >&2;}
13257 +  fi
13258   else
13259 +   if test "x$cgal_makefile" != xno; then
13260 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
13261 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
13262 +  fi
13263 +  CGAL_INCLDIR=
13264 +  CGAL_LIBDIR=
13265 +  CGAL_RLIBDIR=
13266 +  CGAL_DEFINES=
13267 +  CGAL_CXXFLAGS=
13268 +  CGAL_LIBS=
13269 + fi
13270  
7510 –    echo "$as_me:$LINENO: result: no" >&5
7511 – echo "${ECHO_T}no" >&6
13271  
13272 < fi;
13272 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
13273  
13274 + CGAL_LIB_DIR=${CGAL_LIBDIR}
13275  
13276 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13277  
13278  
13279  
7519 – OBJEXT=".$OBJEXT"
13280  
7521 – OOPSE=oopse
13281  
13282 < if test "x${prefix}" = "xNONE"
13283 < then
13284 <  OOPSE_HOME=${ac_default_prefix}/oopse
13282 >
13283 >
13284 > # Check whether --enable-doxygen or --disable-doxygen was given.
13285 > if test "${enable_doxygen+set}" = set; then
13286 >  enableval="$enable_doxygen"
13287 >
13288 > fi;
13289 > # Check whether --enable-dot or --disable-dot was given.
13290 > if test "${enable_dot+set}" = set; then
13291 >  enableval="$enable_dot"
13292 >
13293 > fi;
13294 > # Check whether --enable-html-docs or --disable-html-docs was given.
13295 > if test "${enable_html_docs+set}" = set; then
13296 >  enableval="$enable_html_docs"
13297 >
13298   else
13299 <  OOPSE_HOME=${prefix}/oopse
7528 < fi
7529 < # Check whether --enable-oopse-home or --disable-oopse-home was given.
7530 < if test "${enable_oopse_home+set}" = set; then
7531 <  enableval="$enable_oopse_home"
7532 <  OOPSE_HOME="${enableval}"
13299 >   enable_html_docs=yes
13300   fi;
13301 + # Check whether --enable-latex-docs or --disable-latex-docs was given.
13302 + if test "${enable_latex_docs+set}" = set; then
13303 +  enableval="$enable_latex_docs"
13304  
13305 < case "x$INSTALL" in
13306 <   x/*) ;;
13307 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
13305 > else
13306 >   enable_latex_docs=no
13307 > fi;
13308 > if test "x$enable_doxygen" = xno; then
13309 >        enable_doc=no
13310 > else
13311 >        # Extract the first word of "doxygen", so it can be a program name with args.
13312 > set dummy doxygen; ac_word=$2
13313 > echo "$as_me:$LINENO: checking for $ac_word" >&5
13314 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13315 > if test "${ac_cv_path_DOXYGEN+set}" = set; then
13316 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13317 > else
13318 >  case $DOXYGEN in
13319 >  [\\/]* | ?:[\\/]*)
13320 >  ac_cv_path_DOXYGEN="$DOXYGEN" # Let the user override the test with a path.
13321 >  ;;
13322 >  *)
13323 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13324 > for as_dir in $PATH
13325 > do
13326 >  IFS=$as_save_IFS
13327 >  test -z "$as_dir" && as_dir=.
13328 >  for ac_exec_ext in '' $ac_executable_extensions; do
13329 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13330 >    ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
13331 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
13332 >    break 2
13333 >  fi
13334 > done
13335 > done
13336 >
13337 >  ;;
13338   esac
13339 + fi
13340 + DOXYGEN=$ac_cv_path_DOXYGEN
13341  
13342 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
13342 > if test -n "$DOXYGEN"; then
13343 >  echo "$as_me:$LINENO: result: $DOXYGEN" >&5
13344 > echo "${ECHO_T}$DOXYGEN" >&6
13345 > else
13346 >  echo "$as_me:$LINENO: result: no" >&5
13347 > echo "${ECHO_T}no" >&6
13348 > fi
13349  
13350 < CFLAGS=${CFLAGS-""}
13351 < CXXFLAGS=${CXXFLAGS-""}
13352 < CPPFLAGS=${CPPFLAGS-""}
13353 < FFLAGS=${FFLAGS-""}
13354 < F90FLAGS=${F90FLAGS-""}
13355 < LDFLAGS=${LDFLAGS-""}
13356 < DEBUG=${DEBUG-"-g"}
13357 <
13358 < case $debug in
13359 <  1)
13360 <     FFLAGS="$DEBUG $FFLAGS"
13361 <     F90FLAGS="$DEBUG $F90FLAGS"
13362 <     ;;
13350 >        if test "x$DOXYGEN" = x; then
13351 >                if test "x$enable_doxygen" = xyes; then
13352 >                        { { echo "$as_me:$LINENO: error: could not find doxygen" >&5
13353 > echo "$as_me: error: could not find doxygen" >&2;}
13354 >   { (exit 1); exit 1; }; }
13355 >                fi
13356 >                enable_doc=no
13357 >        else
13358 >                enable_doc=yes
13359 >                # Extract the first word of "dot", so it can be a program name with args.
13360 > set dummy dot; ac_word=$2
13361 > echo "$as_me:$LINENO: checking for $ac_word" >&5
13362 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13363 > if test "${ac_cv_path_DOT+set}" = set; then
13364 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13365 > else
13366 >  case $DOT in
13367 >  [\\/]* | ?:[\\/]*)
13368 >  ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
13369 >  ;;
13370    *)
13371 <     ;;
13371 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13372 > for as_dir in $PATH
13373 > do
13374 >  IFS=$as_save_IFS
13375 >  test -z "$as_dir" && as_dir=.
13376 >  for ac_exec_ext in '' $ac_executable_extensions; do
13377 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13378 >    ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
13379 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
13380 >    break 2
13381 >  fi
13382 > done
13383 > done
13384 >
13385 >  ;;
13386   esac
13387 + fi
13388 + DOT=$ac_cv_path_DOT
13389  
13390 + if test -n "$DOT"; then
13391 +  echo "$as_me:$LINENO: result: $DOT" >&5
13392 + echo "${ECHO_T}$DOT" >&6
13393 + else
13394 +  echo "$as_me:$LINENO: result: no" >&5
13395 + echo "${ECHO_T}no" >&6
13396 + fi
13397  
13398 +        fi
13399 + fi
13400  
13401 + if test "x$enable_doc" = xyes; then
13402 +  DOC=1
13403 + else
13404 +  DOC=0
13405 + fi
13406  
13407  
13408 + if test x$DOT = x; then
13409 +        if test "x$enable_dot" = xyes; then
13410 +                { { echo "$as_me:$LINENO: error: could not find dot" >&5
13411 + echo "$as_me: error: could not find dot" >&2;}
13412 +   { (exit 1); exit 1; }; }
13413 +        fi
13414 +        enable_dot=no
13415 + else
13416 +        enable_dot=yes
13417 + fi
13418  
13419  
13420  
# Line 7572 | Line 13427 | esac
13427  
13428  
13429  
7575 –          ac_config_headers="$ac_config_headers src/config.h"
13430  
13431 <          ac_config_files="$ac_config_files make/Makefile"
13431 >
13432 >
13433 >
13434 >
13435 >
13436 >
13437 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
13438  
13439  
13440   cat >confcache <<\_ACEOF
# Line 8106 | Line 13966 | do
13966    case "$ac_config_target" in
13967    # Handling of arguments.
13968    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
13969 <  "utils/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS utils/getopt.h:utils/gnugetopt.h" ;;
13969 >  "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
13970 >  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
13971 >  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
13972 >  "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
13973    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
13974    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13975   echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
# Line 8193 | Line 14056 | s,@PROGNAME@,$PROGNAME,;t t
14056   s,@ECHO_N@,$ECHO_N,;t t
14057   s,@ECHO_T@,$ECHO_T,;t t
14058   s,@LIBS@,$LIBS,;t t
8196 – s,@PROGNAME@,$PROGNAME,;t t
8197 – s,@debug@,$debug,;t t
14059   s,@build@,$build,;t t
14060   s,@build_cpu@,$build_cpu,;t t
14061   s,@build_vendor@,$build_vendor,;t t
# Line 8203 | Line 14064 | s,@CC@,$CC,;t t
14064   s,@host_cpu@,$host_cpu,;t t
14065   s,@host_vendor@,$host_vendor,;t t
14066   s,@host_os@,$host_os,;t t
14067 < s,@CC@,$CC,;t t
14068 < s,@CFLAGS@,$CFLAGS,;t t
14067 > s,@PROGNAME@,$PROGNAME,;t t
14068 > s,@debug@,$debug,;t t
14069 > s,@CXX@,$CXX,;t t
14070 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14071   s,@LDFLAGS@,$LDFLAGS,;t t
14072   s,@CPPFLAGS@,$CPPFLAGS,;t t
14073 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14073 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14074   s,@EXEEXT@,$EXEEXT,;t t
14075   s,@OBJEXT@,$OBJEXT,;t t
14076 < s,@CXX@,$CXX,;t t
14077 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14078 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14079 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14080 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14081 < s,@F90@,$F90,;t t
8219 < s,@F90FLAGS@,$F90FLAGS,;t t
8220 < s,@ac_ct_F90@,$ac_ct_F90,;t t
8221 < s,@PREPFLAG@,$PREPFLAG,;t t
8222 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8223 < s,@F90LIBS@,$F90LIBS,;t t
8224 < s,@F90_FUNC@,$F90_FUNC,;t t
8225 < s,@F90_FUNC_@,$F90_FUNC_,;t t
8226 < s,@MOD@,$MOD,;t t
8227 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8228 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8229 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14076 > s,@CC@,$CC,;t t
14077 > s,@CFLAGS@,$CFLAGS,;t t
14078 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14079 > s,@FC@,$FC,;t t
14080 > s,@FCFLAGS@,$FCFLAGS,;t t
14081 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14082   s,@CPP@,$CPP,;t t
14083   s,@EGREP@,$EGREP,;t t
8232 – s,@LIBOBJS@,$LIBOBJS,;t t
8233 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8234 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8235 – s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14084   s,@LN_S@,$LN_S,;t t
14085   s,@SET_MAKE@,$SET_MAKE,;t t
14086   s,@RANLIB@,$RANLIB,;t t
14087   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
14088 < s,@YACC@,$YACC,;t t
14089 < s,@LEX@,$LEX,;t t
14090 < s,@LEXLIB@,$LEXLIB,;t t
14091 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14088 > s,@PERLINTERP@,$PERLINTERP,;t t
14089 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14090 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14091 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14092 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14093   s,@AR@,$AR,;t t
14094 + s,@PS@,$PS,;t t
14095 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14096 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14097 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14098 + s,@FCLIBS@,$FCLIBS,;t t
14099 + s,@FC_FUNC@,$FC_FUNC,;t t
14100 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14101 + s,@MOD@,$MOD,;t t
14102 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14103 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14104 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14105 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14106 + s,@LIBOBJS@,$LIBOBJS,;t t
14107 + s,@POW_LIB@,$POW_LIB,;t t
14108 + s,@CXXCPP@,$CXXCPP,;t t
14109 + s,@__func__@,$__func__,;t t
14110   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14111   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14112   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14113   s,@MPI_LIB@,$MPI_LIB,;t t
14114   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14115   s,@USE_MPI@,$USE_MPI,;t t
14116 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
14117 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
14118 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
14119 < s,@USE_SPRNG@,$USE_SPRNG,;t t
14120 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
14121 < s,@MKL_LIB@,$MKL_LIB,;t t
14122 < s,@MKL_INC@,$MKL_INC,;t t
14123 < s,@HAVE_MKL@,$HAVE_MKL,;t t
14116 > s,@USE_CGAL@,$USE_CGAL,;t t
14117 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14118 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
14119 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
14120 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
14121 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
14122 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14123 > s,@DOXYGEN@,$DOXYGEN,;t t
14124 > s,@DOT@,$DOT,;t t
14125 > s,@DOC@,$DOC,;t t
14126 > s,@enable_dot@,$enable_dot,;t t
14127 > s,@enable_html_docs@,$enable_html_docs,;t t
14128 > s,@enable_latex_docs@,$enable_latex_docs,;t t
14129   s,@BATEXT@,$BATEXT,;t t
14130   s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
14131   s,@OOPSE@,$OOPSE,;t t
14132   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14133   s,@SUBDIRS@,$SUBDIRS,;t t
8264 – s,@FFLAGS@,$FFLAGS,;t t
14134   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14135   CEOF
14136  
# Line 8499 | Line 14368 | done
14368      rm -f $tmp/out
14369    fi
14370  
14371 +  # Run the commands associated with the file.
14372 +  case $ac_file in
14373 +    make/Makefile ) chmod 0755 scripts/* ;;
14374 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
14375 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
14376 +    scripts/filepp ) chmod 0755 scripts/* ;;
14377 +  esac
14378   done
14379   _ACEOF
14380   cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

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