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

Comparing trunk/OOPSE-3.0/configure (file contents):
Revision 2027 by gezelter, Tue Feb 15 06:11:22 2005 UTC vs.
Revision 2754 by gezelter, Wed May 17 03:03:03 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_VERSION='2.0'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI SPRNG_LIB_DIR SPRNG_INC_DIR SPRNG_LIB USE_SPRNG MKL_LIBDIR MKL_LIB MKL_INC HAVE_MKL DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
764 ac_env_LDFLAGS_set=${LDFLAGS+set}
765 ac_env_LDFLAGS_value=$LDFLAGS
766 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 ac_cv_env_LDFLAGS_value=$LDFLAGS
768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 ac_env_CPPFLAGS_value=$CPPFLAGS
770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_env_F90_set=${F90+set}
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
792 + ac_env_CXXCPP_set=${CXXCPP+set}
793 + ac_env_CXXCPP_value=$CXXCPP
794 + ac_cv_env_CXXCPP_set=${CXXCPP+set}
795 + ac_cv_env_CXXCPP_value=$CXXCPP
796  
797   #
798   # Report the --help message.
# Line 797 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 858 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
873  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884 +  --with-zlib=DIR         root directory path of zlib installation (defaults
885 +                          to /usr/local or /usr if not found in /usr/local)
886 +  --with-fftw=DIR         root directory path of fftw installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889 <  --with-sprng=<prefix>   compile with SPRNG installed in <prefix>
880 <                          [default=/usr/local]
881 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
889 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
890  
891   Some influential environment variables:
892 <  CC          C compiler command
893 <  CFLAGS      C compiler flags
892 >  CXX         C++ compiler command
893 >  CXXFLAGS    C++ compiler flags
894    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895                nonstandard directory <lib dir>
896    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897                headers in a nonstandard directory <include dir>
898 <  CXX         C++ compiler command
899 <  CXXFLAGS    C++ compiler flags
900 <  F90         Fortran 90 compiler command
901 <  F90FLAGS    Fortran 90 compiler flags
898 >  CC          C compiler command
899 >  CFLAGS      C compiler flags
900 >  FC          Fortran compiler command
901 >  FCFLAGS     Fortran compiler flags
902    CPP         C preprocessor
903 +  CXXCPP      C++ preprocessor
904  
905   Use these variables to override the choices made by `configure' or to help
906   it to find libraries and programs with nonstandard names/locations.
# Line 992 | Line 1001 | OOPSE configure 2.0
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1004 > OOPSE configure 3.0
1005   generated by GNU Autoconf 2.59
1006  
1007   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1006 | Line 1015 | It was created by OOPSE $as_me 2.0, which was
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1018 > It was created by OOPSE $as_me 3.0, which was
1019   generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
# Line 1368 | Line 1377 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1378  
1379  
1380 < # This file is part of Autoconf.                       -*- Autoconf -*-
1372 < # Programming languages support.
1373 < # Copyright 2000, 2001
1374 < # Free Software Foundation, Inc.
1375 < #
1376 < # This program is free software; you can redistribute it and/or modify
1377 < # it under the terms of the GNU General Public License as published by
1378 < # the Free Software Foundation; either version 2, or (at your option)
1379 < # any later version.
1380 < #
1381 < # This program is distributed in the hope that it will be useful,
1382 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1383 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1384 < # GNU General Public License for more details.
1385 < #
1386 < # You should have received a copy of the GNU General Public License
1387 < # along with this program; if not, write to the Free Software
1388 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1389 < # 02111-1307, USA.
1390 < #
1391 < # As a special exception, the Free Software Foundation gives unlimited
1392 < # permission to copy, distribute and modify the configure scripts that
1393 < # are the output of Autoconf.  You need not follow the terms of the GNU
1394 < # General Public License when using or distributing such scripts, even
1395 < # though portions of the text of Autoconf appear in them.  The GNU
1396 < # General Public License (GPL) does govern all other use of the material
1397 < # that constitutes the Autoconf program.
1398 < #
1399 < # Certain portions of the Autoconf source text are designed to be copied
1400 < # (in certain cases, depending on the input) into the output of
1401 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1402 < # source text consists of comments plus executable code that decides which
1403 < # of the data portions to output in any given case.  We call these
1404 < # comments and executable code the "non-data" portions.  Autoconf never
1405 < # copies any of the non-data portions into its output.
1406 < #
1407 < # This special exception to the GPL applies to versions of Autoconf
1408 < # released by the Free Software Foundation.  When you make and
1409 < # distribute a modified version of Autoconf, you may extend this special
1410 < # exception to the GPL to apply to your modified version as well, *unless*
1411 < # your modified version has the potential to copy into its output some
1412 < # of the text that was the non-data portion of the version that you started
1413 < # with.  (In other words, unless your change moves or copies text from
1414 < # the non-data portions to the data portions.)  If your modification has
1415 < # such potential, you must delete any notice of this special exception
1416 < # to the GPL from your modified version.
1417 < #
1418 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1419 < # many others).
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1382  
1422 # Table of Contents:
1423 #
1424 # 1. Language selection
1425 #    and routines to produce programs in a given language.
1426 #  a. Fortran 77 (to be moved from aclang.m4)
1427 #  b. Fortran 90
1428 #  c. Fortran 95
1429 #
1430 # 2. Producing programs in a given language.
1431 #  a. Fortran 77 (to be moved from aclang.m4)
1432 #  b. Fortran 90
1433 #  c. Fortran 95
1434 #
1435 # 3. Looking for a compiler
1436 #    And possibly the associated preprocessor.
1437 #  a. Fortran 77 (to be moved from aclang.m4)
1438 #  b. Fortran 90
1439 #  c. Fortran 95
1440 #
1441 # 4. Compilers' characteristics.
1442 #  a. Fortran 77 (to be moved from aclang.m4)
1443 #  b. Fortran 90
1444 #  c. Fortran 95
1383  
1446 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1447 # ---------------------------------------------------------------------------
1448 #
1449 # Processing the elements of a list is tedious in shell programming,
1450 # as lists tend to be implemented as space delimited strings.
1451 #
1452 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1453 # if ELEMENT is a member of LIST, otherwise it executes
1454 # ACTION-IF-NOT-FOUND.
1455 # _AC_LIST_MEMBER_IF
1384  
1385  
1386  
1459 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1460 # -------------------------------------------------
1461 #
1462 # Specifying options to the compiler (whether it be the C, C++ or
1463 # Fortran 77 compiler) that are meant for the linker is compiler
1464 # dependent.  This macro lets you give options to the compiler that
1465 # are meant for the linker in a portable, compiler-independent way.
1466 #
1467 # This macro take two arguments, a list of linker options that the
1468 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1469 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1470 # appended to the shell variable in a compiler-dependent way.
1471 #
1472 # For example, if the selected language is C, then this:
1473 #
1474 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1475 #
1476 # will expand into this if the selected C compiler is gcc:
1477 #
1478 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1479 #
1480 # otherwise, it will expand into this:
1481 #
1482 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1483 #
1484 # You are encouraged to add support for compilers that this macro
1485 # doesn't currently support.
1486 # FIXME: Get rid of this macro.
1487 # _AC_LINKER_OPTION
1387  
1388  
1389  
1491 ## ----------------------- ##
1492 ## 1. Language selection.  ##
1493 ## ----------------------- ##
1390  
1495 # ----------------------------- #
1496 # 1b. The Fortran 90 language.  #
1497 # ----------------------------- #
1391  
1499 # AC_LANG(Fortran 90)
1500 # -------------------
1392  
1393  
1394  
1504 # _AC_LANG_ABBREV(Fortran 90)
1505 # ---------------------------
1395  
1396  
1397  
1509 # ----------------------------- #
1510 # 1c. The Fortran 95 language.  #
1511 # ----------------------------- #
1398  
1513 # AC_LANG(Fortran 95)
1514 # -------------------
1399  
1400  
1401  
1518 # _AC_LANG_ABBREV(Fortran 95)
1519 # ---------------------------
1402  
1403  
1404  
1523 ## ---------------------- ##
1524 ## 2.Producing programs.  ##
1525 ## ---------------------- ##
1405  
1527 # ------------------------ #
1528 # 2b. Fortran 90 sources.  #
1529 # ------------------------ #
1406  
1531 # AC_LANG_SOURCE(Fortran 90)(BODY)
1532 # --------------------------------
1407  
1408  
1409  
1536 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1537 # -----------------------------------------------
1410  
1411  
1540 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1541 # --------------------------------------------
1412  
1413  
1414  
1545 # ------------------------ #
1546 # 2c. Fortran 95 sources.  #
1547 # ------------------------ #
1415  
1549 # AC_LANG_SOURCE(Fortran 95)(BODY)
1550 # --------------------------------
1416  
1417  
1553 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1554 # -----------------------------------------------
1418  
1556
1557 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1558 # --------------------------------------------
1559
1560
1561
1562 ## -------------------------------------------- ##
1563 ## 3. Looking for Compilers and Preprocessors.  ##
1564 ## -------------------------------------------- ##
1565
1566 # ----------------------------- #
1567 # 3b. The Fortran 90 compiler.  #
1568 # ----------------------------- #
1569
1570
1571 # AC_LANG_PREPROC(Fortran 90)
1572 # ---------------------------
1573 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1419  
1420  
1421  
1577 # AC_LANG_COMPILER(Fortran 90)
1578 # ----------------------------
1579 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1580 # AC_REQUIRE'able.
1422  
1423  
1424  
1584 # AC_PROG_F90([COMPILERS...])
1585 # ---------------------------
1586 # COMPILERS is a space separated list of Fortran 90 compilers to search
1587 # for.
1425   #
1589 # Compilers are ordered by
1590 #  1. F90, F95
1591 #  2. Good/tested native compilers, bad/untested native compilers
1426   #
1593 # pgf90 is the Portland Group F90 compilers.
1594 # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1595 # lf95 is the Lahey-Fujitsu compiler.
1596 # epcf90 is the "Edinburgh Portable Compiler" F90.
1597 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1598 # AC_PROG_F90
1599
1600
1601 # ----------------------------- #
1602 # 3c. The Fortran 95 compiler.  #
1603 # ----------------------------- #
1604
1605
1606 # AC_LANG_PREPROC(Fortran 95)
1607 # ---------------------------
1608 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1609
1610
1611
1612 # AC_LANG_COMPILER(Fortran 95)
1613 # ----------------------------
1614 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1615 # AC_REQUIRE'able.
1616
1617
1618
1619 # AC_PROG_F95([COMPILERS...])
1620 # ---------------------------
1621 # COMPILERS is a space separated list of Fortran 95 compilers to search
1622 # for.
1427   #
1624 # Compilers are ordered by
1625 #  1. Good/tested native compilers, bad/untested native compilers
1626 #
1627 # xlf95 is the IBM (AIX) F95 compiler.
1628 # lf95 is the Lahey-Fujitsu compiler.
1629 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1630 # AC_PROG_F95
1428  
1429  
1633 ## ------------------------------- ##
1634 ## 4. Compilers' characteristics.  ##
1635 ## ------------------------------- ##
1430  
1431  
1638 # ---------------------------------------- #
1639 # 4b. Fortan 90 compiler characteristics.  #
1640 # ---------------------------------------- #
1432  
1433  
1434 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1435 < # -------------------------------------------------
1645 < # Link a trivial Fortran program, compiling with a verbose output FLAG
1646 < # (which default value, $ac_cv_prog_f90_v, is computed by
1647 < # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1648 < # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1649 < # so that any link flags that are echoed by the compiler appear as
1650 < # space-separated items.
1651 < # _AC_PROG_F90_V_OUTPUT
1652 <
1653 <
1654 < # _AC_PROG_F90_V
1655 < # --------------
1434 > # AC_F90_MODULE_NAMES
1435 > # -------------------
1436   #
1437 < # Determine the flag that causes the Fortran 90 compiler to print
1658 < # information of library and object files (normally -v)
1659 < # Needed for AC_F90_LIBRARY_FLAGS
1660 < # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1661 < # _AC_PROG_F90_V
1662 <
1663 <
1664 < # AC_F90_LIBRARY_LDFLAGS
1665 < # ----------------------
1437 > # Figure out how the Fortran 90 compiler constructs module file names
1438   #
1439 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1668 < # intrinsic and run-time libraries that are required to successfully
1669 < # link a Fortran 90 program or shared library.  The output variable
1670 < # F90LIBS is set to these flags.
1671 < #
1672 < # This macro is intended to be used in those situations when it is
1673 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1674 < # program or shared library.
1675 < #
1676 < # For example, if object files from a C++ and Fortran 90 compiler must
1677 < # be linked together, then the C++ compiler/linker must be used for
1678 < # linking (since special C++-ish things need to happen at link time
1679 < # like calling global constructors, instantiating templates, enabling
1680 < # exception support, etc.).
1681 < #
1682 < # However, the Fortran 90 intrinsic and run-time libraries must be
1683 < # linked in as well, but the C++ compiler/linker doesn't know how to
1684 < # add these Fortran 90 libraries.  Hence, the macro
1685 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1686 < # libraries.
1687 < #
1688 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1689 < # AC_F90_LIBRARY_LDFLAGS
1439 > # AC_F90_MODULE_NAMES
1440  
1441  
1692 # _AC_F90_NAME_MANGLING
1693 # ---------------------
1694 # Test for the name mangling scheme used by the Fortran 90 compiler.
1695 #
1696 # Sets ac_cv_f90_mangling. The value contains three fields, separated
1697 # by commas:
1698 #
1699 # lower case / upper case:
1700 #    case translation of the Fortan 90 symbols
1701 # underscore / no underscore:
1702 #    whether the compiler appends "_" to symbol names
1703 # extra underscore / no extra underscore:
1704 #    whether the compiler appends an extra "_" to symbol names already
1705 #    containing at least one underscore
1706 #
1707 # _AC_F90_NAME_MANGLING
1442  
1709 # The replacement is empty.
1443  
1444  
1445  
1713 # AC_F90_WRAPPERS
1714 # ---------------
1715 # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1716 # properly mangle the names of C identifiers, and C identifiers with
1717 # underscores, respectively, so that they match the name mangling
1718 # scheme used by the Fortran 90 compiler.
1719 # AC_F90_WRAPPERS
1446  
1447  
1722 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1723 # ------------------------------------
1724 # For a Fortran subroutine of given NAME, define a shell variable
1725 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1726 # argument is not supplied, it defaults to NAME.
1727 # AC_F90_FUNC
1448  
1449  
1730 # ---------------------------------------- #
1731 # 4c. Fortan 95 compiler characteristics.  #
1732 # ---------------------------------------- #
1450  
1451  
1735 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1736 # -------------------------------------------------
1737 # Link a trivial Fortran program, compiling with a verbose output FLAG
1738 # (which default value, $ac_cv_prog_f95_v, is computed by
1739 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1740 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1741 # so that any link flags that are echoed by the compiler appear as
1742 # space-separated items.
1743 # _AC_PROG_F95_V_OUTPUT
1452  
1453  
1746 # _AC_PROG_F95_V
1747 # --------------
1748 #
1749 # Determine the flag that causes the Fortran 95 compiler to print
1750 # information of library and object files (normally -v)
1751 # Needed for AC_F95_LIBRARY_FLAGS
1752 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1753 # _AC_PROG_F95_V
1454  
1455  
1756 # AC_F95_LIBRARY_LDFLAGS
1757 # ----------------------
1758 #
1759 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1760 # intrinsic and run-time libraries that are required to successfully
1761 # link a Fortran 95 program or shared library.  The output variable
1762 # F95LIBS is set to these flags.
1763 #
1764 # This macro is intended to be used in those situations when it is
1765 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1766 # program or shared library.
1767 #
1768 # For example, if object files from a C++ and Fortran 95 compiler must
1769 # be linked together, then the C++ compiler/linker must be used for
1770 # linking (since special C++-ish things need to happen at link time
1771 # like calling global constructors, instantiating templates, enabling
1772 # exception support, etc.).
1773 #
1774 # However, the Fortran 95 intrinsic and run-time libraries must be
1775 # linked in as well, but the C++ compiler/linker doesn't know how to
1776 # add these Fortran 95 libraries.  Hence, the macro
1777 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1778 # libraries.
1779 #
1780 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1781 # AC_F95_LIBRARY_LDFLAGS
1456  
1457  
1784 # _AC_F95_NAME_MANGLING
1785 # ---------------------
1786 # Test for the name mangling scheme used by the Fortran 95 compiler.
1787 #
1788 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1789 # by commas:
1790 #
1791 # lower case / upper case:
1792 #    case translation of the Fortan 95 symbols
1793 # underscore / no underscore:
1794 #    whether the compiler appends "_" to symbol names
1795 # extra underscore / no extra underscore:
1796 #    whether the compiler appends an extra "_" to symbol names already
1797 #    containing at least one underscore
1798 #
1799 # _AC_F95_NAME_MANGLING
1458  
1801 # The replacement is empty.
1459  
1460  
1461  
1805 # AC_F95_WRAPPERS
1806 # ---------------
1807 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1808 # properly mangle the names of C identifiers, and C identifiers with
1809 # underscores, respectively, so that they match the name mangling
1810 # scheme used by the Fortran 95 compiler.
1811 # AC_F95_WRAPPERS
1462  
1463  
1814 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1815 # ------------------------------------
1816 # For a Fortran subroutine of given NAME, define a shell variable
1817 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1818 # argument is not supplied, it defaults to NAME.
1819 # AC_F95_FUNC
1464  
1821 # AC_F90_MODULE_NAMES
1822 # -------------------
1823 #
1824 # Figure out how the Fortran 90 compiler constructs module file names
1825 #
1826 # AC_F90_MODULE_NAMES
1465  
1466  
1467  
# Line 1883 | Line 1521 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1521  
1522  
1523  
1886 # set program name
1887 PROGNAME="oopse"
1524  
1525  
1890 # there are two ways to do debugging.  One with the --enable-debug flag
1891 # and one using the DEBUG environment variable
1526  
1893 debug=0
1894 # Check whether --enable-debug or --disable-debug was given.
1895 if test "${enable_debug+set}" = set; then
1896  enableval="$enable_debug"
1897  debug=1
1898 fi;
1899 if test "${DEBUG}"; then
1527  
1901 cat >>confdefs.h <<\_ACEOF
1902 #define debug 1
1903 _ACEOF
1904
1905  msg="$msg, debug mode"
1906 fi
1907
1908
1528   # who am i
1529   # Make sure we can run config.sub.
1530   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1964 | Line 1583 | ac_ext=c
1583  
1584  
1585  
1586 < ac_ext=c
1587 < ac_cpp='$CPP $CPPFLAGS'
1588 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1589 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1590 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1586 > # set program name
1587 > PROGNAME="oopse"
1588 >
1589 >
1590 >
1591 >
1592 > OBJEXT=".$OBJEXT"
1593 >
1594 > OOPSE=oopse
1595 >
1596 > if test "x${prefix}" = "xNONE"
1597 > then
1598 >  OOPSE_HOME=${ac_default_prefix}/oopse
1599 > else
1600 >  OOPSE_HOME=${prefix}/oopse
1601 > fi
1602 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1603 > if test "${enable_oopse_home+set}" = set; then
1604 >  enableval="$enable_oopse_home"
1605 >  OOPSE_HOME="${enableval}"
1606 > fi;
1607 >
1608 > # there are two ways to do debugging.  One with the --enable-debug flag
1609 > # and one using the DEBUG environment variable
1610 >
1611 > debug=0
1612 > # Check whether --enable-debug or --disable-debug was given.
1613 > if test "${enable_debug+set}" = set; then
1614 >  enableval="$enable_debug"
1615 >  debug=1
1616 > fi;
1617 > if test "${DEBUG}"; then
1618 >
1619 > cat >>confdefs.h <<\_ACEOF
1620 > #define debug 1
1621 > _ACEOF
1622 >
1623 >  msg="$msg, debug mode"
1624 > fi
1625 >
1626 >
1627 > # Checks for programs.
1628 > ac_ext=cc
1629 > ac_cpp='$CXXCPP $CPPFLAGS'
1630 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1631 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1632 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1633   if test -n "$ac_tool_prefix"; then
1634 <  for ac_prog in icc xlc gcc cc
1634 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1635    do
1636      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1637   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1638   echo "$as_me:$LINENO: checking for $ac_word" >&5
1639   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1640 < if test "${ac_cv_prog_CC+set}" = set; then
1640 > if test "${ac_cv_prog_CXX+set}" = set; then
1641    echo $ECHO_N "(cached) $ECHO_C" >&6
1642   else
1643 <  if test -n "$CC"; then
1644 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1643 >  if test -n "$CXX"; then
1644 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1645   else
1646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1647   for as_dir in $PATH
# Line 1989 | Line 1650 | do
1650    test -z "$as_dir" && as_dir=.
1651    for ac_exec_ext in '' $ac_executable_extensions; do
1652    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1653 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1653 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1654      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1655      break 2
1656    fi
# Line 1998 | Line 1659 | CC=$ac_cv_prog_CC
1659  
1660   fi
1661   fi
1662 < CC=$ac_cv_prog_CC
1663 < if test -n "$CC"; then
1664 <  echo "$as_me:$LINENO: result: $CC" >&5
1665 < echo "${ECHO_T}$CC" >&6
1662 > CXX=$ac_cv_prog_CXX
1663 > if test -n "$CXX"; then
1664 >  echo "$as_me:$LINENO: result: $CXX" >&5
1665 > echo "${ECHO_T}$CXX" >&6
1666   else
1667    echo "$as_me:$LINENO: result: no" >&5
1668   echo "${ECHO_T}no" >&6
1669   fi
1670  
1671 <    test -n "$CC" && break
1671 >    test -n "$CXX" && break
1672    done
1673   fi
1674 < if test -z "$CC"; then
1675 <  ac_ct_CC=$CC
1676 <  for ac_prog in icc xlc gcc cc
1674 > if test -z "$CXX"; then
1675 >  ac_ct_CXX=$CXX
1676 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1677   do
1678    # Extract the first word of "$ac_prog", so it can be a program name with args.
1679   set dummy $ac_prog; ac_word=$2
1680   echo "$as_me:$LINENO: checking for $ac_word" >&5
1681   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1682 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1682 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1683    echo $ECHO_N "(cached) $ECHO_C" >&6
1684   else
1685 <  if test -n "$ac_ct_CC"; then
1686 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1685 >  if test -n "$ac_ct_CXX"; then
1686 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1687   else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689   for as_dir in $PATH
# Line 2031 | Line 1692 | do
1692    test -z "$as_dir" && as_dir=.
1693    for ac_exec_ext in '' $ac_executable_extensions; do
1694    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1695 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1695 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1696      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1697      break 2
1698    fi
# Line 2040 | Line 1701 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1701  
1702   fi
1703   fi
1704 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1705 < if test -n "$ac_ct_CC"; then
1706 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1707 < echo "${ECHO_T}$ac_ct_CC" >&6
1704 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1705 > if test -n "$ac_ct_CXX"; then
1706 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1707 > echo "${ECHO_T}$ac_ct_CXX" >&6
1708   else
1709    echo "$as_me:$LINENO: result: no" >&5
1710   echo "${ECHO_T}no" >&6
1711   fi
1712  
1713 <  test -n "$ac_ct_CC" && break
1713 >  test -n "$ac_ct_CXX" && break
1714   done
1715 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1716  
1717 <  CC=$ac_ct_CC
1717 >  CXX=$ac_ct_CXX
1718   fi
1719  
1720  
2059 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2060 See \`config.log' for more details." >&5
2061 echo "$as_me: error: no acceptable C compiler found in \$PATH
2062 See \`config.log' for more details." >&2;}
2063   { (exit 1); exit 1; }; }
2064
1721   # Provide some information about the compiler.
1722   echo "$as_me:$LINENO:" \
1723 <     "checking for C compiler version" >&5
1723 >     "checking for C++ compiler version" >&5
1724   ac_compiler=`set X $ac_compile; echo $2`
1725   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1726    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2102 | Line 1758 | echo "$as_me:$LINENO: checking for C compiler default
1758   # Try to create an executable without -o first, disregard a.out.
1759   # It will help us diagnose broken compilers, and finding out an intuition
1760   # of exeext.
1761 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1762 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1761 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1762 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1763   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1764   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1765    (eval $ac_link_default) 2>&5
# Line 2146 | Line 1802 | sed 's/^/| /' conftest.$ac_ext >&5
1802    echo "$as_me: failed program was:" >&5
1803   sed 's/^/| /' conftest.$ac_ext >&5
1804  
1805 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1805 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1806   See \`config.log' for more details." >&5
1807 < echo "$as_me: error: C compiler cannot create executables
1807 > echo "$as_me: error: C++ compiler cannot create executables
1808   See \`config.log' for more details." >&2;}
1809     { (exit 77); exit 77; }; }
1810   fi
# Line 2159 | Line 1815 | echo "$as_me:$LINENO: checking whether the C compiler
1815  
1816   # Check the compiler produces executables we can run.  If not, either
1817   # the compiler is broken, or we cross compile.
1818 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1819 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1818 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1819 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1820   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1821   # If not cross compiling, check that we can run a simple program.
1822   if test "$cross_compiling" != yes; then
# Line 2175 | Line 1831 | if test "$cross_compiling" != yes; then
1831      if test "$cross_compiling" = maybe; then
1832          cross_compiling=yes
1833      else
1834 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1834 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1835   If you meant to cross compile, use \`--host'.
1836   See \`config.log' for more details." >&5
1837 < echo "$as_me: error: cannot run C compiled programs.
1837 > echo "$as_me: error: cannot run C++ compiled programs.
1838   If you meant to cross compile, use \`--host'.
1839   See \`config.log' for more details." >&2;}
1840     { (exit 1); exit 1; }; }
# Line 2283 | Line 1939 | echo "$as_me:$LINENO: checking whether we are using th
1939   echo "${ECHO_T}$ac_cv_objext" >&6
1940   OBJEXT=$ac_cv_objext
1941   ac_objext=$OBJEXT
1942 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1943 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1944 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1945 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1946 + else
1947 +  cat >conftest.$ac_ext <<_ACEOF
1948 + /* confdefs.h.  */
1949 + _ACEOF
1950 + cat confdefs.h >>conftest.$ac_ext
1951 + cat >>conftest.$ac_ext <<_ACEOF
1952 + /* end confdefs.h.  */
1953 +
1954 + int
1955 + main ()
1956 + {
1957 + #ifndef __GNUC__
1958 +       choke me
1959 + #endif
1960 +
1961 +  ;
1962 +  return 0;
1963 + }
1964 + _ACEOF
1965 + rm -f conftest.$ac_objext
1966 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1967 +  (eval $ac_compile) 2>conftest.er1
1968 +  ac_status=$?
1969 +  grep -v '^ *+' conftest.er1 >conftest.err
1970 +  rm -f conftest.er1
1971 +  cat conftest.err >&5
1972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973 +  (exit $ac_status); } &&
1974 +         { ac_try='test -z "$ac_cxx_werror_flag"
1975 +                         || test ! -s conftest.err'
1976 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1977 +  (eval $ac_try) 2>&5
1978 +  ac_status=$?
1979 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1980 +  (exit $ac_status); }; } &&
1981 +         { ac_try='test -s conftest.$ac_objext'
1982 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1983 +  (eval $ac_try) 2>&5
1984 +  ac_status=$?
1985 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986 +  (exit $ac_status); }; }; then
1987 +  ac_compiler_gnu=yes
1988 + else
1989 +  echo "$as_me: failed program was:" >&5
1990 + sed 's/^/| /' conftest.$ac_ext >&5
1991 +
1992 + ac_compiler_gnu=no
1993 + fi
1994 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1996 +
1997 + fi
1998 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1999 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2000 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2001 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2002 + ac_save_CXXFLAGS=$CXXFLAGS
2003 + CXXFLAGS="-g"
2004 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2005 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2006 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2007 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2008 + else
2009 +  cat >conftest.$ac_ext <<_ACEOF
2010 + /* confdefs.h.  */
2011 + _ACEOF
2012 + cat confdefs.h >>conftest.$ac_ext
2013 + cat >>conftest.$ac_ext <<_ACEOF
2014 + /* end confdefs.h.  */
2015 +
2016 + int
2017 + main ()
2018 + {
2019 +
2020 +  ;
2021 +  return 0;
2022 + }
2023 + _ACEOF
2024 + rm -f conftest.$ac_objext
2025 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2026 +  (eval $ac_compile) 2>conftest.er1
2027 +  ac_status=$?
2028 +  grep -v '^ *+' conftest.er1 >conftest.err
2029 +  rm -f conftest.er1
2030 +  cat conftest.err >&5
2031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2032 +  (exit $ac_status); } &&
2033 +         { ac_try='test -z "$ac_cxx_werror_flag"
2034 +                         || test ! -s conftest.err'
2035 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2036 +  (eval $ac_try) 2>&5
2037 +  ac_status=$?
2038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2039 +  (exit $ac_status); }; } &&
2040 +         { ac_try='test -s conftest.$ac_objext'
2041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2042 +  (eval $ac_try) 2>&5
2043 +  ac_status=$?
2044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045 +  (exit $ac_status); }; }; then
2046 +  ac_cv_prog_cxx_g=yes
2047 + else
2048 +  echo "$as_me: failed program was:" >&5
2049 + sed 's/^/| /' conftest.$ac_ext >&5
2050 +
2051 + ac_cv_prog_cxx_g=no
2052 + fi
2053 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2054 + fi
2055 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2056 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2057 + if test "$ac_test_CXXFLAGS" = set; then
2058 +  CXXFLAGS=$ac_save_CXXFLAGS
2059 + elif test $ac_cv_prog_cxx_g = yes; then
2060 +  if test "$GXX" = yes; then
2061 +    CXXFLAGS="-g -O2"
2062 +  else
2063 +    CXXFLAGS="-g"
2064 +  fi
2065 + else
2066 +  if test "$GXX" = yes; then
2067 +    CXXFLAGS="-O2"
2068 +  else
2069 +    CXXFLAGS=
2070 +  fi
2071 + fi
2072 + for ac_declaration in \
2073 +   '' \
2074 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2075 +   'extern "C" void std::exit (int); using std::exit;' \
2076 +   'extern "C" void exit (int) throw ();' \
2077 +   'extern "C" void exit (int);' \
2078 +   'void exit (int);'
2079 + do
2080 +  cat >conftest.$ac_ext <<_ACEOF
2081 + /* confdefs.h.  */
2082 + _ACEOF
2083 + cat confdefs.h >>conftest.$ac_ext
2084 + cat >>conftest.$ac_ext <<_ACEOF
2085 + /* end confdefs.h.  */
2086 + $ac_declaration
2087 + #include <stdlib.h>
2088 + int
2089 + main ()
2090 + {
2091 + exit (42);
2092 +  ;
2093 +  return 0;
2094 + }
2095 + _ACEOF
2096 + rm -f conftest.$ac_objext
2097 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2098 +  (eval $ac_compile) 2>conftest.er1
2099 +  ac_status=$?
2100 +  grep -v '^ *+' conftest.er1 >conftest.err
2101 +  rm -f conftest.er1
2102 +  cat conftest.err >&5
2103 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104 +  (exit $ac_status); } &&
2105 +         { ac_try='test -z "$ac_cxx_werror_flag"
2106 +                         || test ! -s conftest.err'
2107 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108 +  (eval $ac_try) 2>&5
2109 +  ac_status=$?
2110 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2111 +  (exit $ac_status); }; } &&
2112 +         { ac_try='test -s conftest.$ac_objext'
2113 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2114 +  (eval $ac_try) 2>&5
2115 +  ac_status=$?
2116 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2117 +  (exit $ac_status); }; }; then
2118 +  :
2119 + else
2120 +  echo "$as_me: failed program was:" >&5
2121 + sed 's/^/| /' conftest.$ac_ext >&5
2122 +
2123 + continue
2124 + fi
2125 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2126 +  cat >conftest.$ac_ext <<_ACEOF
2127 + /* confdefs.h.  */
2128 + _ACEOF
2129 + cat confdefs.h >>conftest.$ac_ext
2130 + cat >>conftest.$ac_ext <<_ACEOF
2131 + /* end confdefs.h.  */
2132 + $ac_declaration
2133 + int
2134 + main ()
2135 + {
2136 + exit (42);
2137 +  ;
2138 +  return 0;
2139 + }
2140 + _ACEOF
2141 + rm -f conftest.$ac_objext
2142 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2143 +  (eval $ac_compile) 2>conftest.er1
2144 +  ac_status=$?
2145 +  grep -v '^ *+' conftest.er1 >conftest.err
2146 +  rm -f conftest.er1
2147 +  cat conftest.err >&5
2148 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2149 +  (exit $ac_status); } &&
2150 +         { ac_try='test -z "$ac_cxx_werror_flag"
2151 +                         || test ! -s conftest.err'
2152 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2153 +  (eval $ac_try) 2>&5
2154 +  ac_status=$?
2155 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2156 +  (exit $ac_status); }; } &&
2157 +         { ac_try='test -s conftest.$ac_objext'
2158 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2159 +  (eval $ac_try) 2>&5
2160 +  ac_status=$?
2161 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2162 +  (exit $ac_status); }; }; then
2163 +  break
2164 + else
2165 +  echo "$as_me: failed program was:" >&5
2166 + sed 's/^/| /' conftest.$ac_ext >&5
2167 +
2168 + fi
2169 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2170 + done
2171 + rm -f conftest*
2172 + if test -n "$ac_declaration"; then
2173 +  echo '#ifdef __cplusplus' >>confdefs.h
2174 +  echo $ac_declaration      >>confdefs.h
2175 +  echo '#endif'             >>confdefs.h
2176 + fi
2177 +
2178 + ac_ext=c
2179 + ac_cpp='$CPP $CPPFLAGS'
2180 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2181 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2182 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2183 +
2184 + ac_ext=c
2185 + ac_cpp='$CPP $CPPFLAGS'
2186 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2187 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2188 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2189 + if test -n "$ac_tool_prefix"; then
2190 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2191 +  do
2192 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2193 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2194 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2195 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2196 + if test "${ac_cv_prog_CC+set}" = set; then
2197 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2198 + else
2199 +  if test -n "$CC"; then
2200 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2201 + else
2202 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2203 + for as_dir in $PATH
2204 + do
2205 +  IFS=$as_save_IFS
2206 +  test -z "$as_dir" && as_dir=.
2207 +  for ac_exec_ext in '' $ac_executable_extensions; do
2208 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2209 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2210 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2211 +    break 2
2212 +  fi
2213 + done
2214 + done
2215 +
2216 + fi
2217 + fi
2218 + CC=$ac_cv_prog_CC
2219 + if test -n "$CC"; then
2220 +  echo "$as_me:$LINENO: result: $CC" >&5
2221 + echo "${ECHO_T}$CC" >&6
2222 + else
2223 +  echo "$as_me:$LINENO: result: no" >&5
2224 + echo "${ECHO_T}no" >&6
2225 + fi
2226 +
2227 +    test -n "$CC" && break
2228 +  done
2229 + fi
2230 + if test -z "$CC"; then
2231 +  ac_ct_CC=$CC
2232 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2233 + do
2234 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2235 + set dummy $ac_prog; ac_word=$2
2236 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2237 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2238 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2239 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2240 + else
2241 +  if test -n "$ac_ct_CC"; then
2242 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2243 + else
2244 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2245 + for as_dir in $PATH
2246 + do
2247 +  IFS=$as_save_IFS
2248 +  test -z "$as_dir" && as_dir=.
2249 +  for ac_exec_ext in '' $ac_executable_extensions; do
2250 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2251 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2252 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2253 +    break 2
2254 +  fi
2255 + done
2256 + done
2257 +
2258 + fi
2259 + fi
2260 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2261 + if test -n "$ac_ct_CC"; then
2262 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2263 + echo "${ECHO_T}$ac_ct_CC" >&6
2264 + else
2265 +  echo "$as_me:$LINENO: result: no" >&5
2266 + echo "${ECHO_T}no" >&6
2267 + fi
2268 +
2269 +  test -n "$ac_ct_CC" && break
2270 + done
2271 +
2272 +  CC=$ac_ct_CC
2273 + fi
2274 +
2275 +
2276 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2277 + See \`config.log' for more details." >&5
2278 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2279 + See \`config.log' for more details." >&2;}
2280 +   { (exit 1); exit 1; }; }
2281 +
2282 + # Provide some information about the compiler.
2283 + echo "$as_me:$LINENO:" \
2284 +     "checking for C compiler version" >&5
2285 + ac_compiler=`set X $ac_compile; echo $2`
2286 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2287 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2288 +  ac_status=$?
2289 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2290 +  (exit $ac_status); }
2291 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2292 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2293 +  ac_status=$?
2294 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2295 +  (exit $ac_status); }
2296 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2297 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2298 +  ac_status=$?
2299 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2300 +  (exit $ac_status); }
2301 +
2302   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2303   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2304   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2677 | Line 2693 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2693   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2694   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2695  
2696 <
2697 < ac_ext=cc
2698 < ac_cpp='$CXXCPP $CPPFLAGS'
2699 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2684 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2685 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2696 > ac_ext=${FC_SRCEXT-f}
2697 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2698 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2699 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2700   if test -n "$ac_tool_prefix"; then
2701 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2701 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2702    do
2703      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2704   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2705   echo "$as_me:$LINENO: checking for $ac_word" >&5
2706   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2707 < if test "${ac_cv_prog_CXX+set}" = set; then
2707 > if test "${ac_cv_prog_FC+set}" = set; then
2708    echo $ECHO_N "(cached) $ECHO_C" >&6
2709   else
2710 <  if test -n "$CXX"; then
2711 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2710 >  if test -n "$FC"; then
2711 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2712   else
2713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2714   for as_dir in $PATH
# Line 2703 | Line 2717 | do
2717    test -z "$as_dir" && as_dir=.
2718    for ac_exec_ext in '' $ac_executable_extensions; do
2719    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2720 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2720 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2721      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2722      break 2
2723    fi
# Line 2712 | Line 2726 | CXX=$ac_cv_prog_CXX
2726  
2727   fi
2728   fi
2729 < CXX=$ac_cv_prog_CXX
2730 < if test -n "$CXX"; then
2731 <  echo "$as_me:$LINENO: result: $CXX" >&5
2732 < echo "${ECHO_T}$CXX" >&6
2729 > FC=$ac_cv_prog_FC
2730 > if test -n "$FC"; then
2731 >  echo "$as_me:$LINENO: result: $FC" >&5
2732 > echo "${ECHO_T}$FC" >&6
2733   else
2734    echo "$as_me:$LINENO: result: no" >&5
2735   echo "${ECHO_T}no" >&6
2736   fi
2737  
2738 <    test -n "$CXX" && break
2738 >    test -n "$FC" && break
2739    done
2740   fi
2741 < if test -z "$CXX"; then
2742 <  ac_ct_CXX=$CXX
2743 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2741 > if test -z "$FC"; then
2742 >  ac_ct_FC=$FC
2743 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2744   do
2745    # Extract the first word of "$ac_prog", so it can be a program name with args.
2746   set dummy $ac_prog; ac_word=$2
2747   echo "$as_me:$LINENO: checking for $ac_word" >&5
2748   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2749 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2749 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2750    echo $ECHO_N "(cached) $ECHO_C" >&6
2751   else
2752 <  if test -n "$ac_ct_CXX"; then
2753 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2752 >  if test -n "$ac_ct_FC"; then
2753 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2754   else
2755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2756   for as_dir in $PATH
# Line 2745 | Line 2759 | do
2759    test -z "$as_dir" && as_dir=.
2760    for ac_exec_ext in '' $ac_executable_extensions; do
2761    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2762 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2762 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2763      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2764      break 2
2765    fi
# Line 2754 | Line 2768 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2768  
2769   fi
2770   fi
2771 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2772 < if test -n "$ac_ct_CXX"; then
2773 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2774 < echo "${ECHO_T}$ac_ct_CXX" >&6
2775 < else
2771 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2772 > if test -n "$ac_ct_FC"; then
2773 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2774 > echo "${ECHO_T}$ac_ct_FC" >&6
2775 > else
2776    echo "$as_me:$LINENO: result: no" >&5
2777   echo "${ECHO_T}no" >&6
2778   fi
2779  
2780 <  test -n "$ac_ct_CXX" && break
2780 >  test -n "$ac_ct_FC" && break
2781   done
2768 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2782  
2783 <  CXX=$ac_ct_CXX
2783 >  FC=$ac_ct_FC
2784   fi
2785  
2786  
2787   # Provide some information about the compiler.
2788 < echo "$as_me:$LINENO:" \
2789 <     "checking for C++ compiler version" >&5
2788 > echo "$as_me:2788:" \
2789 >     "checking for Fortran compiler version" >&5
2790   ac_compiler=`set X $ac_compile; echo $2`
2791   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2792    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2790 | Line 2803 | ac_compiler=`set X $ac_compile; echo $2`
2803    ac_status=$?
2804    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2805    (exit $ac_status); }
2806 + rm -f a.out
2807  
2808 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2809 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2810 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2808 > # If we don't use `.F' as extension, the preprocessor is not run on the
2809 > # input file.  (Note that this only needs to work for GNU compilers.)
2810 > ac_save_ext=$ac_ext
2811 > ac_ext=F
2812 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2813 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2814 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2815    echo $ECHO_N "(cached) $ECHO_C" >&6
2816   else
2817    cat >conftest.$ac_ext <<_ACEOF
2818 < /* confdefs.h.  */
2801 < _ACEOF
2802 < cat confdefs.h >>conftest.$ac_ext
2803 < cat >>conftest.$ac_ext <<_ACEOF
2804 < /* end confdefs.h.  */
2805 <
2806 < int
2807 < main ()
2808 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2814 <  return 0;
2815 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2823 | Line 2831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2831    cat conftest.err >&5
2832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833    (exit $ac_status); } &&
2834 <         { ac_try='test -z "$ac_cxx_werror_flag"
2834 >         { ac_try='test -z "$ac_fc_werror_flag"
2835                           || test ! -s conftest.err'
2836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837    (eval $ac_try) 2>&5
# Line 2844 | Line 2852 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2852   ac_compiler_gnu=no
2853   fi
2854   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2855 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2855 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2856  
2857   fi
2858 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2859 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2860 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2861 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2862 < ac_save_CXXFLAGS=$CXXFLAGS
2863 < CXXFLAGS="-g"
2864 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2865 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2866 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2858 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2859 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2860 > ac_ext=$ac_save_ext
2861 > ac_test_FFLAGS=${FCFLAGS+set}
2862 > ac_save_FFLAGS=$FCFLAGS
2863 > FCFLAGS=
2864 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2865 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2866 > if test "${ac_cv_prog_fc_g+set}" = set; then
2867    echo $ECHO_N "(cached) $ECHO_C" >&6
2868   else
2869 <  cat >conftest.$ac_ext <<_ACEOF
2870 < /* confdefs.h.  */
2871 < _ACEOF
2864 < cat confdefs.h >>conftest.$ac_ext
2865 < cat >>conftest.$ac_ext <<_ACEOF
2866 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2869 < main ()
2870 < {
2871 <
2872 <  ;
2873 <  return 0;
2874 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2882 | Line 2881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2881    cat conftest.err >&5
2882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883    (exit $ac_status); } &&
2884 <         { ac_try='test -z "$ac_cxx_werror_flag"
2884 >         { ac_try='test -z "$ac_fc_werror_flag"
2885                           || test ! -s conftest.err'
2886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2887    (eval $ac_try) 2>&5
# Line 2895 | Line 2894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2894    ac_status=$?
2895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2896    (exit $ac_status); }; }; then
2897 <  ac_cv_prog_cxx_g=yes
2897 >  ac_cv_prog_fc_g=yes
2898   else
2899    echo "$as_me: failed program was:" >&5
2900   sed 's/^/| /' conftest.$ac_ext >&5
2901  
2902 < ac_cv_prog_cxx_g=no
2902 > ac_cv_prog_fc_g=no
2903   fi
2904   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2905 +
2906   fi
2907 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2908 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2909 < if test "$ac_test_CXXFLAGS" = set; then
2910 <  CXXFLAGS=$ac_save_CXXFLAGS
2911 < elif test $ac_cv_prog_cxx_g = yes; then
2912 <  if test "$GXX" = yes; then
2913 <    CXXFLAGS="-g -O2"
2907 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2908 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2909 > if test "$ac_test_FFLAGS" = set; then
2910 >  FCFLAGS=$ac_save_FFLAGS
2911 > elif test $ac_cv_prog_fc_g = yes; then
2912 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2913 >    FCFLAGS="-g -O2"
2914    else
2915 <    CXXFLAGS="-g"
2915 >    FCFLAGS="-g"
2916    fi
2917   else
2918 <  if test "$GXX" = yes; then
2919 <    CXXFLAGS="-O2"
2918 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2919 >    FCFLAGS="-O2"
2920    else
2921 <    CXXFLAGS=
2921 >    FCFLAGS=
2922    fi
2923   fi
2924 < for ac_declaration in \
2925 <   '' \
2926 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2927 <   'extern "C" void std::exit (int); using std::exit;' \
2928 <   'extern "C" void exit (int) throw ();' \
2929 <   'extern "C" void exit (int);' \
2930 <   'void exit (int);'
2924 >
2925 > ac_ext=c
2926 > ac_cpp='$CPP $CPPFLAGS'
2927 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2928 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2929 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2930 >
2931 > ac_ext=c
2932 > ac_cpp='$CPP $CPPFLAGS'
2933 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2934 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2935 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2936 > echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2937 > echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2938 > # On Suns, sometimes $CPP names a directory.
2939 > if test -n "$CPP" && test -d "$CPP"; then
2940 >  CPP=
2941 > fi
2942 > if test -z "$CPP"; then
2943 >  if test "${ac_cv_prog_CPP+set}" = set; then
2944 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2945 > else
2946 >      # Double quotes because CPP needs to be expanded
2947 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2948 >    do
2949 >      ac_preproc_ok=false
2950 > for ac_c_preproc_warn_flag in '' yes
2951   do
2952 +  # Use a header file that comes with gcc, so configuring glibc
2953 +  # with a fresh cross-compiler works.
2954 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2955 +  # <limits.h> exists even on freestanding compilers.
2956 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2957 +  # not just through cpp. "Syntax error" is here to catch this case.
2958    cat >conftest.$ac_ext <<_ACEOF
2959   /* confdefs.h.  */
2960   _ACEOF
2961   cat confdefs.h >>conftest.$ac_ext
2962   cat >>conftest.$ac_ext <<_ACEOF
2963   /* end confdefs.h.  */
2964 < $ac_declaration
2965 < #include <stdlib.h>
2966 < int
2967 < main ()
2968 < {
2969 < exit (42);
2944 <  ;
2945 <  return 0;
2946 < }
2964 > #ifdef __STDC__
2965 > # include <limits.h>
2966 > #else
2967 > # include <assert.h>
2968 > #endif
2969 >                     Syntax error
2970   _ACEOF
2971 < rm -f conftest.$ac_objext
2972 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2950 <  (eval $ac_compile) 2>conftest.er1
2971 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2972 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2973    ac_status=$?
2974    grep -v '^ *+' conftest.er1 >conftest.err
2975    rm -f conftest.er1
2976    cat conftest.err >&5
2977    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2978 <  (exit $ac_status); } &&
2979 <         { ac_try='test -z "$ac_cxx_werror_flag"
2980 <                         || test ! -s conftest.err'
2981 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2982 <  (eval $ac_try) 2>&5
2983 <  ac_status=$?
2984 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2985 <  (exit $ac_status); }; } &&
2986 <         { ac_try='test -s conftest.$ac_objext'
2987 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2988 <  (eval $ac_try) 2>&5
2967 <  ac_status=$?
2968 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2969 <  (exit $ac_status); }; }; then
2978 >  (exit $ac_status); } >/dev/null; then
2979 >  if test -s conftest.err; then
2980 >    ac_cpp_err=$ac_c_preproc_warn_flag
2981 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2982 >  else
2983 >    ac_cpp_err=
2984 >  fi
2985 > else
2986 >  ac_cpp_err=yes
2987 > fi
2988 > if test -z "$ac_cpp_err"; then
2989    :
2990   else
2991    echo "$as_me: failed program was:" >&5
2992   sed 's/^/| /' conftest.$ac_ext >&5
2993  
2994 +  # Broken: fails on valid input.
2995   continue
2996   fi
2997 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2997 > rm -f conftest.err conftest.$ac_ext
2998 >
2999 >  # OK, works on sane cases.  Now check whether non-existent headers
3000 >  # can be detected and how.
3001    cat >conftest.$ac_ext <<_ACEOF
3002   /* confdefs.h.  */
3003   _ACEOF
3004   cat confdefs.h >>conftest.$ac_ext
3005   cat >>conftest.$ac_ext <<_ACEOF
3006   /* end confdefs.h.  */
3007 < $ac_declaration
2985 < int
2986 < main ()
2987 < {
2988 < exit (42);
2989 <  ;
2990 <  return 0;
2991 < }
3007 > #include <ac_nonexistent.h>
3008   _ACEOF
3009 < rm -f conftest.$ac_objext
3010 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2995 <  (eval $ac_compile) 2>conftest.er1
3009 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3010 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3011    ac_status=$?
3012    grep -v '^ *+' conftest.er1 >conftest.err
3013    rm -f conftest.er1
3014    cat conftest.err >&5
3015    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3016 <  (exit $ac_status); } &&
3017 <         { ac_try='test -z "$ac_cxx_werror_flag"
3018 <                         || test ! -s conftest.err'
3019 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3020 <  (eval $ac_try) 2>&5
3016 >  (exit $ac_status); } >/dev/null; then
3017 >  if test -s conftest.err; then
3018 >    ac_cpp_err=$ac_c_preproc_warn_flag
3019 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3020 >  else
3021 >    ac_cpp_err=
3022 >  fi
3023 > else
3024 >  ac_cpp_err=yes
3025 > fi
3026 > if test -z "$ac_cpp_err"; then
3027 >  # Broken: success on invalid input.
3028 > continue
3029 > else
3030 >  echo "$as_me: failed program was:" >&5
3031 > sed 's/^/| /' conftest.$ac_ext >&5
3032 >
3033 >  # Passes both tests.
3034 > ac_preproc_ok=:
3035 > break
3036 > fi
3037 > rm -f conftest.err conftest.$ac_ext
3038 >
3039 > done
3040 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3041 > rm -f conftest.err conftest.$ac_ext
3042 > if $ac_preproc_ok; then
3043 >  break
3044 > fi
3045 >
3046 >    done
3047 >    ac_cv_prog_CPP=$CPP
3048 >
3049 > fi
3050 >  CPP=$ac_cv_prog_CPP
3051 > else
3052 >  ac_cv_prog_CPP=$CPP
3053 > fi
3054 > echo "$as_me:$LINENO: result: $CPP" >&5
3055 > echo "${ECHO_T}$CPP" >&6
3056 > ac_preproc_ok=false
3057 > for ac_c_preproc_warn_flag in '' yes
3058 > do
3059 >  # Use a header file that comes with gcc, so configuring glibc
3060 >  # with a fresh cross-compiler works.
3061 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3062 >  # <limits.h> exists even on freestanding compilers.
3063 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3064 >  # not just through cpp. "Syntax error" is here to catch this case.
3065 >  cat >conftest.$ac_ext <<_ACEOF
3066 > /* confdefs.h.  */
3067 > _ACEOF
3068 > cat confdefs.h >>conftest.$ac_ext
3069 > cat >>conftest.$ac_ext <<_ACEOF
3070 > /* end confdefs.h.  */
3071 > #ifdef __STDC__
3072 > # include <limits.h>
3073 > #else
3074 > # include <assert.h>
3075 > #endif
3076 >                     Syntax error
3077 > _ACEOF
3078 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3079 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3080    ac_status=$?
3081 +  grep -v '^ *+' conftest.er1 >conftest.err
3082 +  rm -f conftest.er1
3083 +  cat conftest.err >&5
3084    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3085 <  (exit $ac_status); }; } &&
3086 <         { ac_try='test -s conftest.$ac_objext'
3087 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3088 <  (eval $ac_try) 2>&5
3085 >  (exit $ac_status); } >/dev/null; then
3086 >  if test -s conftest.err; then
3087 >    ac_cpp_err=$ac_c_preproc_warn_flag
3088 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3089 >  else
3090 >    ac_cpp_err=
3091 >  fi
3092 > else
3093 >  ac_cpp_err=yes
3094 > fi
3095 > if test -z "$ac_cpp_err"; then
3096 >  :
3097 > else
3098 >  echo "$as_me: failed program was:" >&5
3099 > sed 's/^/| /' conftest.$ac_ext >&5
3100 >
3101 >  # Broken: fails on valid input.
3102 > continue
3103 > fi
3104 > rm -f conftest.err conftest.$ac_ext
3105 >
3106 >  # OK, works on sane cases.  Now check whether non-existent headers
3107 >  # can be detected and how.
3108 >  cat >conftest.$ac_ext <<_ACEOF
3109 > /* confdefs.h.  */
3110 > _ACEOF
3111 > cat confdefs.h >>conftest.$ac_ext
3112 > cat >>conftest.$ac_ext <<_ACEOF
3113 > /* end confdefs.h.  */
3114 > #include <ac_nonexistent.h>
3115 > _ACEOF
3116 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3117 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3118    ac_status=$?
3119 +  grep -v '^ *+' conftest.er1 >conftest.err
3120 +  rm -f conftest.er1
3121 +  cat conftest.err >&5
3122    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3123 <  (exit $ac_status); }; }; then
3124 <  break
3123 >  (exit $ac_status); } >/dev/null; then
3124 >  if test -s conftest.err; then
3125 >    ac_cpp_err=$ac_c_preproc_warn_flag
3126 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3127 >  else
3128 >    ac_cpp_err=
3129 >  fi
3130   else
3131 +  ac_cpp_err=yes
3132 + fi
3133 + if test -z "$ac_cpp_err"; then
3134 +  # Broken: success on invalid input.
3135 + continue
3136 + else
3137    echo "$as_me: failed program was:" >&5
3138   sed 's/^/| /' conftest.$ac_ext >&5
3139  
3140 +  # Passes both tests.
3141 + ac_preproc_ok=:
3142 + break
3143   fi
3144 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3144 > rm -f conftest.err conftest.$ac_ext
3145 >
3146   done
3147 < rm -f conftest*
3148 < if test -n "$ac_declaration"; then
3149 <  echo '#ifdef __cplusplus' >>confdefs.h
3150 <  echo $ac_declaration      >>confdefs.h
3151 <  echo '#endif'             >>confdefs.h
3147 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3148 > rm -f conftest.err conftest.$ac_ext
3149 > if $ac_preproc_ok; then
3150 >  :
3151 > else
3152 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3153 > See \`config.log' for more details." >&5
3154 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3155 > See \`config.log' for more details." >&2;}
3156 >   { (exit 1); exit 1; }; }
3157   fi
3158  
3159   ac_ext=c
# Line 3033 | Line 3162 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3162   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3163   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3164  
3165 + echo "$as_me:$LINENO: checking for egrep" >&5
3166 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3167 + if test "${ac_cv_prog_egrep+set}" = set; then
3168 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3169 + else
3170 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3171 +    then ac_cv_prog_egrep='grep -E'
3172 +    else ac_cv_prog_egrep='egrep'
3173 +    fi
3174 + fi
3175 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3176 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3177 + EGREP=$ac_cv_prog_egrep
3178  
3179 < OOPSE_TEMPLATE_FLAGS=""
3180 < if test $ac_cv_cxx_compiler_gnu = no; then
3181 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3182 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3183 <  echo 'void f(){}' > conftest.cc
3184 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3043 <    echo "$as_me:$LINENO: result: yes" >&5
3179 >
3180 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3181 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3182 > LN_S=$as_ln_s
3183 > if test "$LN_S" = "ln -s"; then
3184 >  echo "$as_me:$LINENO: result: yes" >&5
3185   echo "${ECHO_T}yes" >&6
3186 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3187 <  else
3188 <    echo "$as_me:$LINENO: result: no" >&5
3189 < echo "${ECHO_T}no" >&6
3190 <  fi
3191 <  rm -f conftest*
3192 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3193 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3194 <  echo 'void f(){}' > conftest.cc
3195 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3196 <    echo "$as_me:$LINENO: result: yes" >&5
3186 > else
3187 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3188 > echo "${ECHO_T}no, using $LN_S" >&6
3189 > fi
3190 >
3191 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3192 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3193 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3194 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3196 > else
3197 >  cat >conftest.make <<\_ACEOF
3198 > all:
3199 >        @echo 'ac_maketemp="$(MAKE)"'
3200 > _ACEOF
3201 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3202 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3203 > if test -n "$ac_maketemp"; then
3204 >  eval ac_cv_prog_make_${ac_make}_set=yes
3205 > else
3206 >  eval ac_cv_prog_make_${ac_make}_set=no
3207 > fi
3208 > rm -f conftest.make
3209 > fi
3210 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3211 >  echo "$as_me:$LINENO: result: yes" >&5
3212   echo "${ECHO_T}yes" >&6
3213 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3213 >  SET_MAKE=
3214 > else
3215 >  echo "$as_me:$LINENO: result: no" >&5
3216   echo "${ECHO_T}no" >&6
3217 +  SET_MAKE="MAKE=${MAKE-make}"
3218 + fi
3219 +
3220 + if test -n "$ac_tool_prefix"; then
3221 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3222 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3223 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3226 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3227 + else
3228 +  if test -n "$RANLIB"; then
3229 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3230 + else
3231 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 + for as_dir in $PATH
3233 + do
3234 +  IFS=$as_save_IFS
3235 +  test -z "$as_dir" && as_dir=.
3236 +  for ac_exec_ext in '' $ac_executable_extensions; do
3237 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3239 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240 +    break 2
3241    fi
3242 <  rm -f conftest*
3243 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3244 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3245 <  echo 'void f(){}' > conftest.cc
3246 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3247 <    echo "$as_me:$LINENO: result: yes" >&5
3248 < echo "${ECHO_T}yes" >&6
3249 <    OOPSE_TEMPLATE_FLAGS="-pto"
3250 <  else
3251 <    echo "$as_me:$LINENO: result: no" >&5
3242 > done
3243 > done
3244 >
3245 > fi
3246 > fi
3247 > RANLIB=$ac_cv_prog_RANLIB
3248 > if test -n "$RANLIB"; then
3249 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3250 > echo "${ECHO_T}$RANLIB" >&6
3251 > else
3252 >  echo "$as_me:$LINENO: result: no" >&5
3253   echo "${ECHO_T}no" >&6
3254 + fi
3255 +
3256 + fi
3257 + if test -z "$ac_cv_prog_RANLIB"; then
3258 +  ac_ct_RANLIB=$RANLIB
3259 +  # Extract the first word of "ranlib", so it can be a program name with args.
3260 + set dummy ranlib; ac_word=$2
3261 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3262 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3263 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3264 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3265 + else
3266 +  if test -n "$ac_ct_RANLIB"; then
3267 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3268 + else
3269 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3270 + for as_dir in $PATH
3271 + do
3272 +  IFS=$as_save_IFS
3273 +  test -z "$as_dir" && as_dir=.
3274 +  for ac_exec_ext in '' $ac_executable_extensions; do
3275 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3276 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3277 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3278 +    break 2
3279    fi
3280 <  rm -f conftest*
3281 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3076 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3077 <  echo 'void f(){}' > conftest.cc
3078 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3079 <    echo "$as_me:$LINENO: result: yes" >&5
3080 < echo "${ECHO_T}yes" >&6
3280 > done
3281 > done
3282  
3283 +  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284 + fi
3285 + fi
3286 + ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3287 + if test -n "$ac_ct_RANLIB"; then
3288 +  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3289 + echo "${ECHO_T}$ac_ct_RANLIB" >&6
3290 + else
3291 +  echo "$as_me:$LINENO: result: no" >&5
3292 + echo "${ECHO_T}no" >&6
3293 + fi
3294  
3295 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3296 <  else
3297 <    echo "$as_me:$LINENO: result: no" >&5
3295 >  RANLIB=$ac_ct_RANLIB
3296 > else
3297 >  RANLIB="$ac_cv_prog_RANLIB"
3298 > fi
3299 >
3300 >
3301 >   # Extract the first word of "perl", so it can be a program name with args.
3302 > set dummy perl; ac_word=$2
3303 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3304 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3305 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3307 > else
3308 >  case $PERLINTERP in
3309 >  [\\/]* | ?:[\\/]*)
3310 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3311 >  ;;
3312 >  *)
3313 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3314 > for as_dir in $PATH
3315 > do
3316 >  IFS=$as_save_IFS
3317 >  test -z "$as_dir" && as_dir=.
3318 >  for ac_exec_ext in '' $ac_executable_extensions; do
3319 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3320 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3321 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3322 >    break 2
3323 >  fi
3324 > done
3325 > done
3326 >
3327 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3328 >  ;;
3329 > esac
3330 > fi
3331 > PERLINTERP=$ac_cv_path_PERLINTERP
3332 >
3333 > if test -n "$PERLINTERP"; then
3334 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3335 > echo "${ECHO_T}$PERLINTERP" >&6
3336 > else
3337 >  echo "$as_me:$LINENO: result: no" >&5
3338   echo "${ECHO_T}no" >&6
3339 + fi
3340 +
3341 +   ac_cv_path_perlinterp="$PERLINTERP"
3342 +   _sHpB='#!'
3343 +
3344 +
3345 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3346 + if test "${with_perl_shebang+set}" = set; then
3347 +  withval="$with_perl_shebang"
3348 +  opt_perl_shebang="$withval"
3349 + else
3350 +                opt_perl_shebang="not_set"
3351 + fi;
3352 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3353 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3354 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3356 + else
3357 +   case "$opt_perl_shebang" in
3358 +                      not_set  ) ax_cv_opt_perl_shebang=''
3359 +                               ;;
3360 +                         *     )
3361 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3362 +                    esac
3363 +
3364 + fi
3365 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3366 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3367 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3368 +     then
3369 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3370 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3371 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3372 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3373 +
3374 + # Automatic detection of sharpbang formula starts here
3375 +     else
3376 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3377 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3378 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3379 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3380 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3381 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3382 + else
3383 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3384 +        if test "x$_somian_kspb_perl" == x
3385 +          then _somian_ksbp_warn_empty='durnit'
3386 +          else
3387 +          case "A$_somian_kspb_perl" in
3388 +                 A#!*perl* )
3389 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3390 +                        ;;
3391 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3392 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3393 +          esac
3394 +        fi
3395 +
3396 + fi
3397 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3398 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3399 + # The above prints Checking ... result message to user.
3400 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3401 +
3402 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3403 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3404 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3405 +    fi
3406 + # Inform user after printing result value
3407 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3408 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3409 + echo "$as_me: Maybe Not good -" >&6;}
3410 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3411 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3412 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3413 + echo "$as_me: OK Good result - " >&6;}
3414 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3415 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3416 +    fi
3417    fi
3418 +
3419 + # Find a good install program.  We prefer a C program (faster),
3420 + # so one script is as good as another.  But avoid the broken or
3421 + # incompatible versions:
3422 + # SysV /etc/install, /usr/sbin/install
3423 + # SunOS /usr/etc/install
3424 + # IRIX /sbin/install
3425 + # AIX /bin/install
3426 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3427 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3428 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3429 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3430 + # OS/2's system install, which has a completely different semantic
3431 + # ./install, which can be erroneously created by make from ./install.sh.
3432 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3433 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3434 + if test -z "$INSTALL"; then
3435 + if test "${ac_cv_path_install+set}" = set; then
3436 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3437 + else
3438 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3439 + for as_dir in $PATH
3440 + do
3441 +  IFS=$as_save_IFS
3442 +  test -z "$as_dir" && as_dir=.
3443 +  # Account for people who put trailing slashes in PATH elements.
3444 + case $as_dir/ in
3445 +  ./ | .// | /cC/* | \
3446 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3447 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3448 +  /usr/ucb/* ) ;;
3449 +  *)
3450 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3451 +    # Don't use installbsd from OSF since it installs stuff as root
3452 +    # by default.
3453 +    for ac_prog in ginstall scoinst install; do
3454 +      for ac_exec_ext in '' $ac_executable_extensions; do
3455 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3456 +          if test $ac_prog = install &&
3457 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3458 +            # AIX install.  It has an incompatible calling convention.
3459 +            :
3460 +          elif test $ac_prog = install &&
3461 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3462 +            # program-specific install script used by HP pwplus--don't use.
3463 +            :
3464 +          else
3465 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3466 +            break 3
3467 +          fi
3468 +        fi
3469 +      done
3470 +    done
3471 +    ;;
3472 + esac
3473 + done
3474 +
3475 +
3476   fi
3477 +  if test "${ac_cv_path_install+set}" = set; then
3478 +    INSTALL=$ac_cv_path_install
3479 +  else
3480 +    # As a last resort, use the slow shell script.  We don't cache a
3481 +    # path for INSTALL within a source directory, because that will
3482 +    # break other packages using the cache if that directory is
3483 +    # removed, or if the path is relative.
3484 +    INSTALL=$ac_install_sh
3485 +  fi
3486 + fi
3487 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3488 + echo "${ECHO_T}$INSTALL" >&6
3489  
3490 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3491 + # It thinks the first close brace ends the variable substitution.
3492 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3493  
3494 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3495  
3496 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3497  
3498 < ac_ext=f90
3499 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3500 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3501 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3502 < if test -n "$ac_tool_prefix"; then
3503 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3504 <  do
3100 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3101 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3498 > case "x$INSTALL" in
3499 >   x/*) ;;
3500 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3501 > esac
3502 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3503 > # Extract the first word of "ar", so it can be a program name with args.
3504 > set dummy ar; ac_word=$2
3505   echo "$as_me:$LINENO: checking for $ac_word" >&5
3506   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3507 < if test "${ac_cv_prog_F90+set}" = set; then
3507 > if test "${ac_cv_prog_AR+set}" = set; then
3508    echo $ECHO_N "(cached) $ECHO_C" >&6
3509   else
3510 <  if test -n "$F90"; then
3511 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3510 >  if test -n "$AR"; then
3511 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3512   else
3513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3514   for as_dir in $PATH
# Line 3114 | Line 3517 | do
3517    test -z "$as_dir" && as_dir=.
3518    for ac_exec_ext in '' $ac_executable_extensions; do
3519    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3520 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3520 >    ac_cv_prog_AR="ar"
3521      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3522      break 2
3523    fi
3524   done
3525   done
3526  
3527 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3528   fi
3529   fi
3530 < F90=$ac_cv_prog_F90
3531 < if test -n "$F90"; then
3532 <  echo "$as_me:$LINENO: result: $F90" >&5
3533 < echo "${ECHO_T}$F90" >&6
3530 > AR=$ac_cv_prog_AR
3531 > if test -n "$AR"; then
3532 >  echo "$as_me:$LINENO: result: $AR" >&5
3533 > echo "${ECHO_T}$AR" >&6
3534   else
3535    echo "$as_me:$LINENO: result: no" >&5
3536   echo "${ECHO_T}no" >&6
3537   fi
3538  
3539 <    test -n "$F90" && break
3540 <  done
3539 > if test "$AR" = "NONE"; then
3540 >  cat >confcache <<\_ACEOF
3541 > # This file is a shell script that caches the results of configure
3542 > # tests run on this system so they can be shared between configure
3543 > # scripts and configure runs, see configure's option --config-cache.
3544 > # It is not useful on other systems.  If it contains results you don't
3545 > # want to keep, you may remove or edit it.
3546 > #
3547 > # config.status only pays attention to the cache file if you give it
3548 > # the --recheck option to rerun configure.
3549 > #
3550 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3551 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3552 > # following values.
3553 >
3554 > _ACEOF
3555 >
3556 > # The following way of writing the cache mishandles newlines in values,
3557 > # but we know of no workaround that is simple, portable, and efficient.
3558 > # So, don't put newlines in cache variables' values.
3559 > # Ultrix sh set writes to stderr and can't be redirected directly,
3560 > # and sets the high bit in the cache file unless we assign to the vars.
3561 > {
3562 >  (set) 2>&1 |
3563 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3564 >    *ac_space=\ *)
3565 >      # `set' does not quote correctly, so add quotes (double-quote
3566 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3567 >      sed -n \
3568 >        "s/'/'\\\\''/g;
3569 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3570 >      ;;
3571 >    *)
3572 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3573 >      sed -n \
3574 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3575 >      ;;
3576 >    esac;
3577 > } |
3578 >  sed '
3579 >     t clear
3580 >     : clear
3581 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3582 >     t end
3583 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3584 >     : end' >>confcache
3585 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3586 >  if test -w $cache_file; then
3587 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3588 >    cat confcache >$cache_file
3589 >  else
3590 >    echo "not updating unwritable cache $cache_file"
3591 >  fi
3592   fi
3593 < if test -z "$F90"; then
3594 <  ac_ct_F90=$F90
3595 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3596 < do
3597 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3143 < set dummy $ac_prog; ac_word=$2
3593 > rm -f confcache
3594 >  exit 1
3595 > fi
3596 > # Extract the first word of "ps", so it can be a program name with args.
3597 > set dummy ps; ac_word=$2
3598   echo "$as_me:$LINENO: checking for $ac_word" >&5
3599   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3600 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3600 > if test "${ac_cv_path_PS+set}" = set; then
3601    echo $ECHO_N "(cached) $ECHO_C" >&6
3602   else
3603 <  if test -n "$ac_ct_F90"; then
3604 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3605 < else
3606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3603 >  case $PS in
3604 >  [\\/]* | ?:[\\/]*)
3605 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3606 >  ;;
3607 >  *)
3608 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3609   for as_dir in $PATH
3610   do
3611    IFS=$as_save_IFS
3612    test -z "$as_dir" && as_dir=.
3613    for ac_exec_ext in '' $ac_executable_extensions; do
3614    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3615 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3615 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3616      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3617      break 2
3618    fi
3619   done
3620   done
3621  
3622 +  ;;
3623 + esac
3624   fi
3625 < fi
3626 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3627 < if test -n "$ac_ct_F90"; then
3628 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3629 < echo "${ECHO_T}$ac_ct_F90" >&6
3625 > PS=$ac_cv_path_PS
3626 >
3627 > if test -n "$PS"; then
3628 >  echo "$as_me:$LINENO: result: $PS" >&5
3629 > echo "${ECHO_T}$PS" >&6
3630   else
3631    echo "$as_me:$LINENO: result: no" >&5
3632   echo "${ECHO_T}no" >&6
3633   fi
3634  
3635 <  test -n "$ac_ct_F90" && break
3636 < done
3635 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3636 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3637 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3639 > else
3640  
3641 <  F90=$ac_ct_F90
3641 >        if $PS ax -o rss > /dev/null 2>&1; then
3642 >                ac_cv_prog_ps_ax=yes
3643 >        else
3644 >                ac_cv_prog_ps_ax=no
3645 >        fi
3646 >        if $PS -ef -o rss > /dev/null 2>&1; then
3647 >                ac_cv_prog_ps_ef=yes
3648 >        else
3649 >                ac_cv_prog_ps_ef=no
3650 >        fi
3651 >        if test "$ac_cv_prog_ps_ax" = yes; then
3652 >                ac_cv_prog_ps_syntax=BSD
3653 >        else
3654 >                if test "$ac_cv_prog_ps_ef" = yes; then
3655 >                        ac_cv_prog_ps_syntax=POSIX
3656 >                else
3657 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3658 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3659 >   { (exit 1); exit 1; }; }
3660 >                fi
3661 >        fi
3662 >
3663   fi
3664 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3665 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3666  
3667 + cat >>confdefs.h <<_ACEOF
3668 + #define PSCOMMAND $PS
3669 + _ACEOF
3670  
3671 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3185 < # input file.
3186 < ac_save_ext=$ac_ext
3187 < ac_ext=F90
3188 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3189 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3190 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3191 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3192 < else
3193 <  cat >conftest.$ac_ext <<_ACEOF
3671 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3672  
3673 < program main
3673 > cat >>confdefs.h <<\_ACEOF
3674 > #define PSTYPE_IS_BSD 1
3675 > _ACEOF
3676  
3677 < #ifndef __GNUC__
3678 <       choke me
3199 < #endif
3677 > else
3678 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679  
3680 < end program main
3680 > cat >>confdefs.h <<\_ACEOF
3681 > #define PSTYPE_IS_POSIX 1
3682 > _ACEOF
3683 >
3684 >   else
3685 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3686 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3687 >   { (exit 1); exit 1; }; }
3688 >   fi
3689 > fi
3690  
3691 + ac_ext=${FC_SRCEXT-f}
3692 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3693 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3694 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3695 +
3696 +
3697 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3698 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3699 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3700 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3701 + else
3702 +  ac_ext=F90
3703 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3704 + FCFLAGS_SRCEXT=""
3705 + ac_cv_fc_srcext_F90=unknown
3706 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3707 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3708 +  cat >conftest.$ac_ext <<_ACEOF
3709 +      program main
3710 +
3711 +      end
3712   _ACEOF
3713   rm -f conftest.$ac_objext
3714   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3210 | Line 3719 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3719    cat conftest.err >&5
3720    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3721    (exit $ac_status); } &&
3722 <         { ac_try='test -z "$ac_f90_werror_flag"
3722 >         { ac_try='test -z "$ac_fc_werror_flag"
3723                           || test ! -s conftest.err'
3724    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3725    (eval $ac_try) 2>&5
# Line 3223 | Line 3732 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3732    ac_status=$?
3733    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3734    (exit $ac_status); }; }; then
3735 <  ac_compiler_gnu=yes
3735 >  ac_cv_fc_srcext_F90=$ac_flag; break
3736   else
3737    echo "$as_me: failed program was:" >&5
3738   sed 's/^/| /' conftest.$ac_ext >&5
3739  
3231 ac_compiler_gnu=no
3740   fi
3741   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3742 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3742 > done
3743 > rm -f conftest.$ac_objext conftest.F90
3744 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3745  
3746   fi
3747 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3748 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3749 < ac_ext=$ac_save_ext
3750 < G95=`test $ac_compiler_gnu = yes && echo yes`
3751 < ac_ext=c
3752 < ac_cpp='$CPP $CPPFLAGS'
3753 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3754 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3747 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3748 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3749 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3750 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3751 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3752 >   { (exit 1); exit 1; }; }
3753 > else
3754 >  FC_SRCEXT=F90
3755 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3756 >    FCFLAGS_SRCEXT=""
3757 >    FCFLAGS_F90=""
3758 >  else
3759 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3760 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3761 >  fi
3762  
3763  
3764 + fi
3765  
3766  
3767  
3768 +
3769 +
3770   # Try to determine native compiler flags that allow us to use F90 suffix
3771   # for preprocessed f90 source.
3772  
# Line 3255 | Line 3774 | if test "$ac_test_PREPFLAG" != "set"; then
3774    PREPFLAG=""
3775    case "${host_cpu}-${host_os}" in
3776  
3777 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3777 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3778                      PREPFLAG="-fpp1 "
3779                  fi;;
3780 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3780 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3781                      PREPFLAG="-qsuffix=cpp=F90 "
3782                  fi;;
3783    *darwin*)
3784 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3784 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3785                  PREPFLAG="-qsuffix=cpp=F90 "
3786          fi;;
3787    esac
# Line 3277 | Line 3796 | echo $ECHO_N "checking to make sure F90 preprocessor f
3796   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3797  
3798  
3799 <  ac_ext=f90
3800 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3801 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3802 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3799 >  ac_ext=${FC_SRCEXT-f}
3800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3803  
3804    ac_save_ext=$ac_ext
3805    ac_ext=F90
3806 <  ac_save_F90FLAGS=$F90FLAGS
3806 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3807  
3808    if test "$PREPFLAG"; then
3809 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3809 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3810   fi
3811  
3812      cat >conftest.$ac_ext <<_ACEOF
3813  
3814  
3815 < program main
3297 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3301
3302 end program main
3303
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3311 | Line 3827 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827    cat conftest.err >&5
3828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3829    (exit $ac_status); } &&
3830 <         { ac_try='test -z "$ac_f90_werror_flag"
3830 >         { ac_try='test -z "$ac_fc_werror_flag"
3831                           || test ! -s conftest.err'
3832    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3833    (eval $ac_try) 2>&5
# Line 3333 | Line 3849 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3849   fi
3850   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3851  
3852 <  F90FLAGS=$ac_save_F90FLAGS
3852 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3853    ac_ext=$ac_save_ext
3854 <  ac_ext=c
3855 < ac_cpp='$CPP $CPPFLAGS'
3856 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3857 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3342 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3854 >  ac_ext=${FC_SRCEXT-f}
3855 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3856 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3857 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3858  
3859  
3860    if test "$prepflagworks" = 1; then
3861      echo "$as_me:$LINENO: result: yes" >&5
3862   echo "${ECHO_T}yes" >&6
3863 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3864  
3865    else
3866      echo "$as_me:$LINENO: result: no" >&5
# Line 3366 | Line 3882 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3882    PREPDEFFLAG=""
3883    case "${host_cpu}-${host_os}" in
3884  
3885 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3885 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3886                      PREPDEFFLAG=" "
3887                  fi;;
3888 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3888 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3889                      PREPDEFFLAG="-WF,"
3890                  fi;;
3891    *darwin*)
3892 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3892 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3893                  PREPDEFFLAG="-WF,"
3894          fi;;
3895    esac
# Line 3388 | Line 3904 | echo $ECHO_N "checking to make sure F90 preprocessor d
3904   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3905  
3906  
3907 <  ac_ext=f90
3908 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3909 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3907 >  ac_ext=${FC_SRCEXT-f}
3908 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3909 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3910 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3911  
3912    ac_save_ext=$ac_ext
3913    ac_ext=F90
3914 <  ac_save_F90FLAGS=$F90FLAGS
3914 >  ac_save_FCFLAGS=$FCFLAGS
3915  
3916    if test "$PREPDEFFLAG"; then
3917 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3917 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3918   fi
3919  
3920      cat >conftest.$ac_ext <<_ACEOF
3921  
3922  
3923 < program main
3408 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3416
3417 end program main
3418
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3426 | Line 3939 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3939    cat conftest.err >&5
3940    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3941    (exit $ac_status); } &&
3942 <         { ac_try='test -z "$ac_f90_werror_flag"
3942 >         { ac_try='test -z "$ac_fc_werror_flag"
3943                           || test ! -s conftest.err'
3944    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3945    (eval $ac_try) 2>&5
# Line 3448 | Line 3961 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3961   fi
3962   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3963  
3964 <  F90FLAGS=$ac_save_F90FLAGS
3964 >  FCFLAGS=$ac_save_FCFLAGS
3965    ac_ext=$ac_save_ext
3966 <  ac_ext=c
3967 < ac_cpp='$CPP $CPPFLAGS'
3968 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3969 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3457 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3966 >  ac_ext=${FC_SRCEXT-f}
3967 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3968 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3969 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3970  
3971  
3460
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3471 | Line 3982 | ac_ext=f90
3982    fi
3983   fi
3984  
3985 < ac_ext=f90
3986 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3987 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3988 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3989 <
3990 <
3991 <
3481 < ac_ext=f90
3482 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3483 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3484 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3485 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3486 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3487 < if test "${ac_cv_prog_f90_v+set}" = set; then
3985 > ac_ext=${FC_SRCEXT-f}
3986 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3987 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3988 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3989 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3990 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3991 > if test "${ac_cv_prog_fc_v+set}" = set; then
3992    echo $ECHO_N "(cached) $ECHO_C" >&6
3993   else
3994 +  cat >conftest.$ac_ext <<_ACEOF
3995 +      program main
3996  
3997 < cat >conftest.$ac_ext <<_ACEOF
3492 <
3493 < program main
3494 <
3495 <
3496 < end program main
3497 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3505 | Line 4005 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4005    cat conftest.err >&5
4006    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007    (exit $ac_status); } &&
4008 <         { ac_try='test -z "$ac_f90_werror_flag"
4008 >         { ac_try='test -z "$ac_fc_werror_flag"
4009                           || test ! -s conftest.err'
4010    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4011    (eval $ac_try) 2>&5
# Line 3518 | Line 4018 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018    ac_status=$?
4019    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020    (exit $ac_status); }; }; then
4021 <  ac_cv_prog_f90_v=
4021 >  ac_cv_prog_fc_v=
4022   # Try some options frequently used verbose output
4023   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4024 <  ac_ext=f90
4025 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3526 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3527 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3530 <
3531 < program main
3532 <
3533 <
3534 < end program main
3535 <
4027 >      end
4028   _ACEOF
4029  
4030   # Compile and link our simple test program by passing a flag (argument
4031 < # 1 to this macro) to the Fortran 90 compiler in order to get
4032 < # "verbose" output that we can then parse for the Fortran 90 linker
4031 > # 1 to this macro) to the Fortran compiler in order to get
4032 > # "verbose" output that we can then parse for the Fortran linker
4033   # flags.
4034 < ac_save_F90FLAGS=$F90FLAGS
4035 < F90FLAGS="$F90FLAGS $ac_verb"
4034 > ac_save_FFLAGS=$FCFLAGS
4035 > FCFLAGS="$FCFLAGS $ac_verb"
4036 > (eval echo $as_me:4036: \"$ac_link\") >&5
4037 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4038 > echo "$ac_fc_v_output" >&5
4039 > FCFLAGS=$ac_save_FFLAGS
4040  
4041 < (eval echo $as_me:3545: \"$ac_link\") >&5
3546 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3547 < echo "$ac_f90_v_output" >&5
3548 < F90FLAGS=$ac_save_F90FLAGS
4041 > rm -f conftest*
4042  
4043 < rm -f conftest.*
4044 < ac_ext=f90
4045 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4046 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4047 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4043 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4044 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4045 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4046 > ac_fc_v_output="`echo $ac_fc_v_output |
4047 >        grep 'LPATH is:' |
4048 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4049  
4050 < # If we are using xlf then replace all the commas with spaces.
4051 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4052 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4053 < fi
4050 > case $ac_fc_v_output in
4051 >  # If we are using xlf then replace all the commas with spaces.
4052 >  *xlfentry*)
4053 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4054  
4055 < # If we are using Cray Fortran then delete quotes.
4056 < # Use "\"" instead of '"' for font-lock-mode.
4057 < # FIXME: a more general fix for quoted arguments with spaces?
4058 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4059 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4060 < fi
4055 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4056 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4057 >  *mGLOB_options_string*)
4058 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4059 >
4060 >  # If we are using Cray Fortran then delete quotes.
4061 >  # Use "\"" instead of '"' for font-lock-mode.
4062 >  # FIXME: a more general fix for quoted arguments with spaces?
4063 >  *cft90*)
4064 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4065 > esac
4066 >
4067 >
4068    # look for -l* and *.a constructs in the output
4069 <  for ac_arg in $ac_f90_v_output; do
4069 >  for ac_arg in $ac_fc_v_output; do
4070       case $ac_arg in
4071          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4072 <          ac_cv_prog_f90_v=$ac_verb
4072 >          ac_cv_prog_fc_v=$ac_verb
4073            break 2 ;;
4074       esac
4075    done
4076   done
4077 < if test -z "$ac_cv_prog_f90_v"; then
4078 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4079 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4077 > if test -z "$ac_cv_prog_fc_v"; then
4078 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4079 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4080   fi
4081   else
4082    echo "$as_me: failed program was:" >&5
# Line 3587 | Line 4088 | echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4088   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089  
4090   fi
4091 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4092 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4093 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4094 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4095 < if test "${ac_cv_flibs+set}" = set; then
4091 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4092 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4093 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4094 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4095 > if test "${ac_cv_fc_libs+set}" = set; then
4096    echo $ECHO_N "(cached) $ECHO_C" >&6
4097   else
4098 <  if test "x$F90LIBS" != "x"; then
4099 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4098 >  if test "x$FCLIBS" != "x"; then
4099 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4100   else
4101  
3601 ac_ext=f90
3602 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3603 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3604 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3605
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3609 <
3610 <
3611 < end program main
3612 <
4105 >      end
4106   _ACEOF
4107  
4108   # Compile and link our simple test program by passing a flag (argument
4109 < # 1 to this macro) to the Fortran 90 compiler in order to get
4110 < # "verbose" output that we can then parse for the Fortran 90 linker
4109 > # 1 to this macro) to the Fortran compiler in order to get
4110 > # "verbose" output that we can then parse for the Fortran linker
4111   # flags.
4112 < ac_save_F90FLAGS=$F90FLAGS
4113 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4112 > ac_save_FFLAGS=$FCFLAGS
4113 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4114 > (eval echo $as_me:4114: \"$ac_link\") >&5
4115 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4116 > echo "$ac_fc_v_output" >&5
4117 > FCFLAGS=$ac_save_FFLAGS
4118  
4119 < (eval echo $as_me:3622: \"$ac_link\") >&5
3623 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3624 < echo "$ac_f90_v_output" >&5
3625 < F90FLAGS=$ac_save_F90FLAGS
4119 > rm -f conftest*
4120  
4121 < rm -f conftest.*
4122 < ac_ext=f90
4123 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4124 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4125 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4121 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4122 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4123 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4124 > ac_fc_v_output="`echo $ac_fc_v_output |
4125 >        grep 'LPATH is:' |
4126 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4127  
4128 < # If we are using xlf then replace all the commas with spaces.
4129 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4130 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4131 < fi
4128 > case $ac_fc_v_output in
4129 >  # If we are using xlf then replace all the commas with spaces.
4130 >  *xlfentry*)
4131 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4132  
4133 < # If we are using Cray Fortran then delete quotes.
4134 < # Use "\"" instead of '"' for font-lock-mode.
4135 < # FIXME: a more general fix for quoted arguments with spaces?
4136 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3642 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3643 < fi
4133 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4134 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4135 >  *mGLOB_options_string*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4137  
4138 < ac_cv_f90libs=
4138 >  # If we are using Cray Fortran then delete quotes.
4139 >  # Use "\"" instead of '"' for font-lock-mode.
4140 >  # FIXME: a more general fix for quoted arguments with spaces?
4141 >  *cft90*)
4142 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4143 > esac
4144  
4145 +
4146 +
4147 + ac_cv_fc_libs=
4148 +
4149   # Save positional arguments (if any)
4150   ac_save_positional="$@"
4151  
4152 < set X $ac_f90_v_output
4152 > set X $ac_fc_v_output
4153   while test $# != 1; do
4154    shift
4155    ac_arg=$1
4156    case $ac_arg in
4157          [\\/]*.a | ?:[\\/]*.a)
4158              ac_exists=false
4159 <  for ac_i in $ac_cv_f90libs; do
4159 >  for ac_i in $ac_cv_fc_libs; do
4160      if test x"$ac_arg" = x"$ac_i"; then
4161        ac_exists=true
4162        break
# Line 3664 | Line 4166 | else
4166    if test x"$ac_exists" = xtrue; then
4167    :
4168   else
4169 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4169 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4170   fi
4171  
4172            ;;
4173          -bI:*)
4174              ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_arg" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 3682 | Line 4184 | else
4184   else
4185    if test "$ac_compiler_gnu" = yes; then
4186    for ac_link_opt in $ac_arg; do
4187 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4187 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4188    done
4189   else
4190 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4190 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4191   fi
4192   fi
4193  
4194            ;;
4195            # Ignore these flags.
4196 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4196 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4197            ;;
4198          -lkernel32)
4199 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4199 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4200            ;;
4201          -[LRuY])
4202            # These flags, when seen by themselves, take an argument.
4203            # We remove the space between option and argument and re-iterate
4204            # unless we find an empty arg or a new option (starting with -)
4205            case $2 in
4206 <             "" | -*);;
4207 <             *)
4206 >             "" | -*);;
4207 >             *)
4208                  ac_arg="$ac_arg$2"
3707
4209                  shift; shift
4210                  set X $ac_arg "$@"
4211                  ;;
# Line 3713 | Line 4214 | fi
4214          -YP,*)
4215            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4216                ac_exists=false
4217 <  for ac_i in $ac_cv_f90libs; do
4217 >  for ac_i in $ac_cv_fc_libs; do
4218      if test x"$ac_j" = x"$ac_i"; then
4219        ac_exists=true
4220        break
# Line 3724 | Line 4225 | else
4225    :
4226   else
4227    ac_arg="$ac_arg $ac_j"
4228 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4228 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4229   fi
4230  
4231            done
4232            ;;
4233          -[lLR]*)
4234              ac_exists=false
4235 <  for ac_i in $ac_cv_f90libs; do
4235 >  for ac_i in $ac_cv_fc_libs; do
4236      if test x"$ac_arg" = x"$ac_i"; then
4237        ac_exists=true
4238        break
# Line 3741 | Line 4242 | else
4242    if test x"$ac_exists" = xtrue; then
4243    :
4244   else
4245 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4245 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4246   fi
4247  
4248            ;;
# Line 3756 | Line 4257 | case `(uname -sr) 2>/dev/null` in
4257   # must begin with a "/").
4258   case `(uname -sr) 2>/dev/null` in
4259     "SunOS 5"*)
4260 <      ac_ld_run_path=`echo $ac_f90_v_output |
4260 >      ac_ld_run_path=`echo $ac_fc_v_output |
4261                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4262        test "x$ac_ld_run_path" != x &&
3762
4263          if test "$ac_compiler_gnu" = yes; then
4264    for ac_link_opt in $ac_ld_run_path; do
4265 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4265 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4266    done
4267   else
4268 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4268 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4269   fi
4270        ;;
4271   esac
4272 < fi # test "x$F90LIBS" = "x"
4272 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4273  
4274   fi
4275 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4276 < echo "${ECHO_T}$ac_cv_flibs" >&6
4277 < F90LIBS="$ac_cv_f90libs"
4275 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4276 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4277 > FCLIBS="$ac_cv_fc_libs"
4278  
3779 ac_ext=f90
3780 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3781 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3782 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4279  
4280 + ac_ext=${FC_SRCEXT-f}
4281 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4282 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4283 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4284  
4285 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4286 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4287 < if test "${ac_cv_f90_mangling+set}" = set; then
4285 >
4286 > ac_ext=${FC_SRCEXT-f}
4287 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4288 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4289 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4290 >
4291 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4292 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4293 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4294    echo $ECHO_N "(cached) $ECHO_C" >&6
4295   else
4296 <  ac_ext=f90
4297 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4298 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4299 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4300 < cat >conftest.$ac_ext <<_ACEOF
4301 < subroutine foobar()
4302 < return
4303 < end
4304 < subroutine foo_bar()
4305 < return
4306 < end
4296 >  ac_fc_dm_save_LIBS=$LIBS
4297 > LIBS="$LIBS $FCLIBS"
4298 > ac_fortran_dm_var=FC_DUMMY_MAIN
4299 > ac_ext=c
4300 > ac_cpp='$CPP $CPPFLAGS'
4301 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4302 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4303 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4304 >
4305 > # First, try linking without a dummy main:
4306 > cat >conftest.$ac_ext <<_ACEOF
4307 > /* confdefs.h.  */
4308   _ACEOF
4309 + cat confdefs.h >>conftest.$ac_ext
4310 + cat >>conftest.$ac_ext <<_ACEOF
4311 + /* end confdefs.h.  */
4312 +
4313 + #ifdef FC_DUMMY_MAIN
4314 + #ifndef FC_DUMMY_MAIN_EQ_F77
4315 + #  ifdef __cplusplus
4316 +     extern "C"
4317 + #  endif
4318 +   int FC_DUMMY_MAIN() { return 1; }
4319 + #endif
4320 + #endif
4321 + int
4322 + main ()
4323 + {
4324 +
4325 +  ;
4326 +  return 0;
4327 + }
4328 + _ACEOF
4329 + rm -f conftest.$ac_objext conftest$ac_exeext
4330 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4331 +  (eval $ac_link) 2>conftest.er1
4332 +  ac_status=$?
4333 +  grep -v '^ *+' conftest.er1 >conftest.err
4334 +  rm -f conftest.er1
4335 +  cat conftest.err >&5
4336 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4337 +  (exit $ac_status); } &&
4338 +         { ac_try='test -z "$ac_c_werror_flag"
4339 +                         || test ! -s conftest.err'
4340 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4341 +  (eval $ac_try) 2>&5
4342 +  ac_status=$?
4343 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4344 +  (exit $ac_status); }; } &&
4345 +         { ac_try='test -s conftest$ac_exeext'
4346 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4347 +  (eval $ac_try) 2>&5
4348 +  ac_status=$?
4349 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4350 +  (exit $ac_status); }; }; then
4351 +  ac_cv_fortran_dummy_main=none
4352 + else
4353 +  echo "$as_me: failed program was:" >&5
4354 + sed 's/^/| /' conftest.$ac_ext >&5
4355 +
4356 + ac_cv_fortran_dummy_main=unknown
4357 + fi
4358 + rm -f conftest.err conftest.$ac_objext \
4359 +      conftest$ac_exeext conftest.$ac_ext
4360 +
4361 + if test $ac_cv_fortran_dummy_main = unknown; then
4362 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4363 +     cat >conftest.$ac_ext <<_ACEOF
4364 + /* confdefs.h.  */
4365 + _ACEOF
4366 + cat confdefs.h >>conftest.$ac_ext
4367 + cat >>conftest.$ac_ext <<_ACEOF
4368 + /* end confdefs.h.  */
4369 + #define $ac_fortran_dm_var $ac_func
4370 + #ifdef FC_DUMMY_MAIN
4371 + #ifndef FC_DUMMY_MAIN_EQ_F77
4372 + #  ifdef __cplusplus
4373 +     extern "C"
4374 + #  endif
4375 +   int FC_DUMMY_MAIN() { return 1; }
4376 + #endif
4377 + #endif
4378 + int
4379 + main ()
4380 + {
4381 +
4382 +  ;
4383 +  return 0;
4384 + }
4385 + _ACEOF
4386 + rm -f conftest.$ac_objext conftest$ac_exeext
4387 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4388 +  (eval $ac_link) 2>conftest.er1
4389 +  ac_status=$?
4390 +  grep -v '^ *+' conftest.er1 >conftest.err
4391 +  rm -f conftest.er1
4392 +  cat conftest.err >&5
4393 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4394 +  (exit $ac_status); } &&
4395 +         { ac_try='test -z "$ac_c_werror_flag"
4396 +                         || test ! -s conftest.err'
4397 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4398 +  (eval $ac_try) 2>&5
4399 +  ac_status=$?
4400 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4401 +  (exit $ac_status); }; } &&
4402 +         { ac_try='test -s conftest$ac_exeext'
4403 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4404 +  (eval $ac_try) 2>&5
4405 +  ac_status=$?
4406 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4407 +  (exit $ac_status); }; }; then
4408 +  ac_cv_fortran_dummy_main=$ac_func; break
4409 + else
4410 +  echo "$as_me: failed program was:" >&5
4411 + sed 's/^/| /' conftest.$ac_ext >&5
4412 +
4413 + fi
4414 + rm -f conftest.err conftest.$ac_objext \
4415 +      conftest$ac_exeext conftest.$ac_ext
4416 +   done
4417 + fi
4418 + ac_ext=${FC_SRCEXT-f}
4419 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4420 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4421 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4422 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4423 + rm -f conftest*
4424 + LIBS=$ac_fc_dm_save_LIBS
4425 +
4426 + fi
4427 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4428 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4429 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4430 + if test "$FC_DUMMY_MAIN" != unknown; then
4431 +  if test $FC_DUMMY_MAIN != none; then
4432 +
4433 + cat >>confdefs.h <<_ACEOF
4434 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4435 + _ACEOF
4436 +
4437 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4438 +
4439 + cat >>confdefs.h <<\_ACEOF
4440 + #define FC_DUMMY_MAIN_EQ_F77 1
4441 + _ACEOF
4442 +
4443 +  fi
4444 + fi
4445 + else
4446 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4447 + See \`config.log' for more details." >&5
4448 + echo "$as_me: error: linking to Fortran libraries from C fails
4449 + See \`config.log' for more details." >&2;}
4450 +   { (exit 1); exit 1; }; }
4451 + fi
4452 +
4453 +
4454 + ac_ext=${FC_SRCEXT-f}
4455 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4456 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4457 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4458 +
4459 + ac_ext=${FC_SRCEXT-f}
4460 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4461 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4462 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4463 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4464 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4465 + if test "${ac_cv_fc_mangling+set}" = set; then
4466 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4467 + else
4468 +  cat >conftest.$ac_ext <<_ACEOF
4469 +      subroutine foobar()
4470 +      return
4471 +      end
4472 +      subroutine foo_bar()
4473 +      return
4474 +      end
4475 + _ACEOF
4476   rm -f conftest.$ac_objext
4477   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4478    (eval $ac_compile) 2>conftest.er1
# Line 3808 | Line 4482 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4482    cat conftest.err >&5
4483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4484    (exit $ac_status); } &&
4485 <         { ac_try='test -z "$ac_f90_werror_flag"
4485 >         { ac_try='test -z "$ac_fc_werror_flag"
4486                           || test ! -s conftest.err'
4487    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4488    (eval $ac_try) 2>&5
# Line 3821 | Line 4495 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4495    ac_status=$?
4496    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4497    (exit $ac_status); }; }; then
4498 <  mv conftest.$ac_objext cf90_test.$ac_objext
4498 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4499  
4500 +  ac_save_LIBS=$LIBS
4501 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4502 +
4503    ac_ext=c
4504   ac_cpp='$CPP $CPPFLAGS'
4505   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4506   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4507   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3831
3832  ac_save_LIBS=$LIBS
3833  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3834
4508    ac_success=no
4509    for ac_foobar in foobar FOOBAR; do
4510      for ac_underscore in "" "_"; do
# Line 3850 | Line 4523 | int
4523   /* We use char because int might match the return type of a gcc2
4524     builtin and then its argument prototype would still apply.  */
4525   char $ac_func ();
4526 + #ifdef FC_DUMMY_MAIN
4527 + #ifndef FC_DUMMY_MAIN_EQ_F77
4528 + #  ifdef __cplusplus
4529 +     extern "C"
4530 + #  endif
4531 +   int FC_DUMMY_MAIN() { return 1; }
4532 + #endif
4533 + #endif
4534   int
4535   main ()
4536   {
# Line 3890 | Line 4571 | rm -f conftest.err conftest.$ac_objext \
4571        conftest$ac_exeext conftest.$ac_ext
4572      done
4573    done
4574 +  ac_ext=${FC_SRCEXT-f}
4575 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4576 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4577 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4578  
4579    if test "$ac_success" = "yes"; then
4580       case $ac_foobar in
4581 <        foobar)
4582 <           ac_case=lower
4583 <           ac_foo_bar=foo_bar
4584 <           ;;
4585 <        FOOBAR)
4586 <           ac_case=upper
4587 <           ac_foo_bar=FOO_BAR
4588 <           ;;
4581 >        foobar)
4582 >           ac_case=lower
4583 >           ac_foo_bar=foo_bar
4584 >           ;;
4585 >        FOOBAR)
4586 >           ac_case=upper
4587 >           ac_foo_bar=FOO_BAR
4588 >           ;;
4589       esac
4590  
4591 +     ac_ext=c
4592 + ac_cpp='$CPP $CPPFLAGS'
4593 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4594 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4595 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4596       ac_success_extra=no
4597       for ac_extra in "" "_"; do
4598 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 <
3910 <        cat >conftest.$ac_ext <<_ACEOF
4598 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 >        cat >conftest.$ac_ext <<_ACEOF
4600   /* confdefs.h.  */
4601   _ACEOF
4602   cat confdefs.h >>conftest.$ac_ext
# Line 3921 | Line 4610 | int
4610   /* We use char because int might match the return type of a gcc2
4611     builtin and then its argument prototype would still apply.  */
4612   char $ac_func ();
4613 + #ifdef FC_DUMMY_MAIN
4614 + #ifndef FC_DUMMY_MAIN_EQ_F77
4615 + #  ifdef __cplusplus
4616 +     extern "C"
4617 + #  endif
4618 +   int FC_DUMMY_MAIN() { return 1; }
4619 + #endif
4620 + #endif
4621   int
4622   main ()
4623   {
# Line 3960 | Line 4657 | rm -f conftest.err conftest.$ac_objext \
4657   rm -f conftest.err conftest.$ac_objext \
4658        conftest$ac_exeext conftest.$ac_ext
4659       done
4660 +     ac_ext=${FC_SRCEXT-f}
4661 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664  
4665       if test "$ac_success_extra" = "yes"; then
4666 <        ac_cv_f90_mangling="$ac_case case"
4666 >        ac_cv_fc_mangling="$ac_case case"
4667          if test -z "$ac_underscore"; then
4668 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4668 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4669          else
4670 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
3970 <
4670 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4671          fi
4672          if test -z "$ac_extra"; then
4673 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4673 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4674          else
4675 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4675 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4676          fi
4677        else
4678 <        ac_cv_f90_mangling="unknown"
4678 >        ac_cv_fc_mangling="unknown"
4679        fi
4680    else
4681 <     ac_cv_f90_mangling="unknown"
3982 <
4681 >     ac_cv_fc_mangling="unknown"
4682    fi
4683  
4684    LIBS=$ac_save_LIBS
4685 <  ac_ext=f90
3987 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3988 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3989 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3990 <  rm -f cf90_test* conftest*
4685 >  rm -f cfortran_test* conftest*
4686   else
4687    echo "$as_me: failed program was:" >&5
4688   sed 's/^/| /' conftest.$ac_ext >&5
4689  
4690 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4691 + See \`config.log' for more details." >&5
4692 + echo "$as_me: error: cannot compile a simple Fortran program
4693 + See \`config.log' for more details." >&2;}
4694 +   { (exit 1); exit 1; }; }
4695   fi
4696   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3997 ac_ext=f90
3998 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3999 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4000 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4697  
4698   fi
4699 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4700 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4699 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4700 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4701  
4702 + ac_ext=${FC_SRCEXT-f}
4703 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4704 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4705 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4706  
4707 + ac_ext=${FC_SRCEXT-f}
4708 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4709 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4710 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4711  
4712 < case $ac_cv_f90_mangling in
4712 >
4713 > case $ac_cv_fc_mangling in
4714    "lower case, no underscore, no extra underscore")
4715            cat >>confdefs.h <<\_ACEOF
4716 < #define F90_FUNC(name,NAME) name
4716 > #define FC_FUNC(name,NAME) name
4717   _ACEOF
4718  
4719            cat >>confdefs.h <<\_ACEOF
4720 < #define F90_FUNC_(name,NAME) name
4720 > #define FC_FUNC_(name,NAME) name
4721   _ACEOF
4722   ;;
4723    "lower case, no underscore, extra underscore")
4724            cat >>confdefs.h <<\_ACEOF
4725 < #define F90_FUNC(name,NAME) name
4725 > #define FC_FUNC(name,NAME) name
4726   _ACEOF
4727  
4728            cat >>confdefs.h <<\_ACEOF
4729 < #define F90_FUNC_(name,NAME) name ## _
4729 > #define FC_FUNC_(name,NAME) name ## _
4730   _ACEOF
4731   ;;
4732    "lower case, underscore, no extra underscore")
4733            cat >>confdefs.h <<\_ACEOF
4734 < #define F90_FUNC(name,NAME) name ## _
4734 > #define FC_FUNC(name,NAME) name ## _
4735   _ACEOF
4736  
4737            cat >>confdefs.h <<\_ACEOF
4738 < #define F90_FUNC_(name,NAME) name ## _
4738 > #define FC_FUNC_(name,NAME) name ## _
4739   _ACEOF
4740   ;;
4741    "lower case, underscore, extra underscore")
4742            cat >>confdefs.h <<\_ACEOF
4743 < #define F90_FUNC(name,NAME) name ## _
4743 > #define FC_FUNC(name,NAME) name ## _
4744   _ACEOF
4745  
4746            cat >>confdefs.h <<\_ACEOF
4747 < #define F90_FUNC_(name,NAME) name ## __
4747 > #define FC_FUNC_(name,NAME) name ## __
4748   _ACEOF
4749   ;;
4750    "upper case, no underscore, no extra underscore")
4751            cat >>confdefs.h <<\_ACEOF
4752 < #define F90_FUNC(name,NAME) NAME
4752 > #define FC_FUNC(name,NAME) NAME
4753   _ACEOF
4754  
4755            cat >>confdefs.h <<\_ACEOF
4756 < #define F90_FUNC_(name,NAME) NAME
4756 > #define FC_FUNC_(name,NAME) NAME
4757   _ACEOF
4758   ;;
4759    "upper case, no underscore, extra underscore")
4760            cat >>confdefs.h <<\_ACEOF
4761 < #define F90_FUNC(name,NAME) NAME
4761 > #define FC_FUNC(name,NAME) NAME
4762   _ACEOF
4763  
4764            cat >>confdefs.h <<\_ACEOF
4765 < #define F90_FUNC_(name,NAME) NAME ## _
4765 > #define FC_FUNC_(name,NAME) NAME ## _
4766   _ACEOF
4767   ;;
4768    "upper case, underscore, no extra underscore")
4769            cat >>confdefs.h <<\_ACEOF
4770 < #define F90_FUNC(name,NAME) NAME ## _
4770 > #define FC_FUNC(name,NAME) NAME ## _
4771   _ACEOF
4772  
4773            cat >>confdefs.h <<\_ACEOF
4774 < #define F90_FUNC_(name,NAME) NAME ## _
4774 > #define FC_FUNC_(name,NAME) NAME ## _
4775   _ACEOF
4776   ;;
4777    "upper case, underscore, extra underscore")
4778            cat >>confdefs.h <<\_ACEOF
4779 < #define F90_FUNC(name,NAME) NAME ## _
4779 > #define FC_FUNC(name,NAME) NAME ## _
4780   _ACEOF
4781  
4782            cat >>confdefs.h <<\_ACEOF
4783 < #define F90_FUNC_(name,NAME) NAME ## __
4783 > #define FC_FUNC_(name,NAME) NAME ## __
4784   _ACEOF
4785   ;;
4786    *)
4787 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4788 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4787 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4788 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4789 >          ;;
4790 > esac
4791 >
4792 > ac_ext=${FC_SRCEXT-f}
4793 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4794 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4795 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4796 >
4797 >
4798 >
4799 > ac_ext=${FC_SRCEXT-f}
4800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4803 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4804 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4805 > if test "${ac_cv_prog_fc_v+set}" = set; then
4806 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4807 > else
4808 >  cat >conftest.$ac_ext <<_ACEOF
4809 >      program main
4810 >
4811 >      end
4812 > _ACEOF
4813 > rm -f conftest.$ac_objext
4814 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4815 >  (eval $ac_compile) 2>conftest.er1
4816 >  ac_status=$?
4817 >  grep -v '^ *+' conftest.er1 >conftest.err
4818 >  rm -f conftest.er1
4819 >  cat conftest.err >&5
4820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4821 >  (exit $ac_status); } &&
4822 >         { ac_try='test -z "$ac_fc_werror_flag"
4823 >                         || test ! -s conftest.err'
4824 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4825 >  (eval $ac_try) 2>&5
4826 >  ac_status=$?
4827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828 >  (exit $ac_status); }; } &&
4829 >         { ac_try='test -s conftest.$ac_objext'
4830 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4831 >  (eval $ac_try) 2>&5
4832 >  ac_status=$?
4833 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4834 >  (exit $ac_status); }; }; then
4835 >  ac_cv_prog_fc_v=
4836 > # Try some options frequently used verbose output
4837 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4838 >  cat >conftest.$ac_ext <<_ACEOF
4839 >      program main
4840 >
4841 >      end
4842 > _ACEOF
4843 >
4844 > # Compile and link our simple test program by passing a flag (argument
4845 > # 1 to this macro) to the Fortran compiler in order to get
4846 > # "verbose" output that we can then parse for the Fortran linker
4847 > # flags.
4848 > ac_save_FFLAGS=$FCFLAGS
4849 > FCFLAGS="$FCFLAGS $ac_verb"
4850 > (eval echo $as_me:4850: \"$ac_link\") >&5
4851 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4852 > echo "$ac_fc_v_output" >&5
4853 > FCFLAGS=$ac_save_FFLAGS
4854 >
4855 > rm -f conftest*
4856 >
4857 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4858 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4859 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4860 > ac_fc_v_output="`echo $ac_fc_v_output |
4861 >        grep 'LPATH is:' |
4862 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4863 >
4864 > case $ac_fc_v_output in
4865 >  # If we are using xlf then replace all the commas with spaces.
4866 >  *xlfentry*)
4867 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4868 >
4869 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4870 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4871 >  *mGLOB_options_string*)
4872 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4873 >
4874 >  # If we are using Cray Fortran then delete quotes.
4875 >  # Use "\"" instead of '"' for font-lock-mode.
4876 >  # FIXME: a more general fix for quoted arguments with spaces?
4877 >  *cft90*)
4878 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4879 > esac
4880 >
4881 >
4882 >  # look for -l* and *.a constructs in the output
4883 >  for ac_arg in $ac_fc_v_output; do
4884 >     case $ac_arg in
4885 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4886 >          ac_cv_prog_fc_v=$ac_verb
4887 >          break 2 ;;
4888 >     esac
4889 >  done
4890 > done
4891 > if test -z "$ac_cv_prog_fc_v"; then
4892 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4893 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4894 > fi
4895 > else
4896 >  echo "$as_me: failed program was:" >&5
4897 > sed 's/^/| /' conftest.$ac_ext >&5
4898 >
4899 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4900 > echo "$as_me: WARNING: compilation failed" >&2;}
4901 > fi
4902 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4903 >
4904 > fi
4905 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4906 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4907 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4908 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4909 > if test "${ac_cv_fc_libs+set}" = set; then
4910 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4911 > else
4912 >  if test "x$FCLIBS" != "x"; then
4913 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4914 > else
4915 >
4916 > cat >conftest.$ac_ext <<_ACEOF
4917 >      program main
4918 >
4919 >      end
4920 > _ACEOF
4921 >
4922 > # Compile and link our simple test program by passing a flag (argument
4923 > # 1 to this macro) to the Fortran compiler in order to get
4924 > # "verbose" output that we can then parse for the Fortran linker
4925 > # flags.
4926 > ac_save_FFLAGS=$FCFLAGS
4927 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4928 > (eval echo $as_me:4928: \"$ac_link\") >&5
4929 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4930 > echo "$ac_fc_v_output" >&5
4931 > FCFLAGS=$ac_save_FFLAGS
4932 >
4933 > rm -f conftest*
4934 >
4935 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4936 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4937 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4938 > ac_fc_v_output="`echo $ac_fc_v_output |
4939 >        grep 'LPATH is:' |
4940 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4941 >
4942 > case $ac_fc_v_output in
4943 >  # If we are using xlf then replace all the commas with spaces.
4944 >  *xlfentry*)
4945 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4946 >
4947 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4948 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4949 >  *mGLOB_options_string*)
4950 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4951 >
4952 >  # If we are using Cray Fortran then delete quotes.
4953 >  # Use "\"" instead of '"' for font-lock-mode.
4954 >  # FIXME: a more general fix for quoted arguments with spaces?
4955 >  *cft90*)
4956 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4957 > esac
4958 >
4959 >
4960 >
4961 > ac_cv_fc_libs=
4962 >
4963 > # Save positional arguments (if any)
4964 > ac_save_positional="$@"
4965 >
4966 > set X $ac_fc_v_output
4967 > while test $# != 1; do
4968 >  shift
4969 >  ac_arg=$1
4970 >  case $ac_arg in
4971 >        [\\/]*.a | ?:[\\/]*.a)
4972 >            ac_exists=false
4973 >  for ac_i in $ac_cv_fc_libs; do
4974 >    if test x"$ac_arg" = x"$ac_i"; then
4975 >      ac_exists=true
4976 >      break
4977 >    fi
4978 >  done
4979 >
4980 >  if test x"$ac_exists" = xtrue; then
4981 >  :
4982 > else
4983 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4984 > fi
4985 >
4986            ;;
4987 +        -bI:*)
4988 +            ac_exists=false
4989 +  for ac_i in $ac_cv_fc_libs; do
4990 +    if test x"$ac_arg" = x"$ac_i"; then
4991 +      ac_exists=true
4992 +      break
4993 +    fi
4994 +  done
4995 +
4996 +  if test x"$ac_exists" = xtrue; then
4997 +  :
4998 + else
4999 +  if test "$ac_compiler_gnu" = yes; then
5000 +  for ac_link_opt in $ac_arg; do
5001 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5002 +  done
5003 + else
5004 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5005 + fi
5006 + fi
5007 +
5008 +          ;;
5009 +          # Ignore these flags.
5010 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5011 +          ;;
5012 +        -lkernel32)
5013 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5014 +          ;;
5015 +        -[LRuY])
5016 +          # These flags, when seen by themselves, take an argument.
5017 +          # We remove the space between option and argument and re-iterate
5018 +          # unless we find an empty arg or a new option (starting with -)
5019 +          case $2 in
5020 +             "" | -*);;
5021 +             *)
5022 +                ac_arg="$ac_arg$2"
5023 +                shift; shift
5024 +                set X $ac_arg "$@"
5025 +                ;;
5026 +          esac
5027 +          ;;
5028 +        -YP,*)
5029 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5030 +              ac_exists=false
5031 +  for ac_i in $ac_cv_fc_libs; do
5032 +    if test x"$ac_j" = x"$ac_i"; then
5033 +      ac_exists=true
5034 +      break
5035 +    fi
5036 +  done
5037 +
5038 +  if test x"$ac_exists" = xtrue; then
5039 +  :
5040 + else
5041 +  ac_arg="$ac_arg $ac_j"
5042 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5043 + fi
5044 +
5045 +          done
5046 +          ;;
5047 +        -[lLR]*)
5048 +            ac_exists=false
5049 +  for ac_i in $ac_cv_fc_libs; do
5050 +    if test x"$ac_arg" = x"$ac_i"; then
5051 +      ac_exists=true
5052 +      break
5053 +    fi
5054 +  done
5055 +
5056 +  if test x"$ac_exists" = xtrue; then
5057 +  :
5058 + else
5059 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5060 + fi
5061 +
5062 +          ;;
5063 +          # Ignore everything else.
5064 +  esac
5065 + done
5066 + # restore positional arguments
5067 + set X $ac_save_positional; shift
5068 +
5069 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5070 + # then we insist that the "run path" must be an absolute path (i.e. it
5071 + # must begin with a "/").
5072 + case `(uname -sr) 2>/dev/null` in
5073 +   "SunOS 5"*)
5074 +      ac_ld_run_path=`echo $ac_fc_v_output |
5075 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5076 +      test "x$ac_ld_run_path" != x &&
5077 +        if test "$ac_compiler_gnu" = yes; then
5078 +  for ac_link_opt in $ac_ld_run_path; do
5079 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5080 +  done
5081 + else
5082 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5083 + fi
5084 +      ;;
5085   esac
5086 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5087  
5088 + fi
5089 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5090 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5091 + FCLIBS="$ac_cv_fc_libs"
5092  
5093  
5094 + ac_ext=${FC_SRCEXT-f}
5095 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5096 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5097 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5098  
5099  
5100 +
5101   echo "$as_me:$LINENO: checking for module suffix" >&5
5102   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5103   rm -f conftest*
5104   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5105   rm -f work*
5106 < cat >conftest.f90 <<EOF
5106 > cat >conftest.$ac_ext <<EOF
5107          module conftest
5108          integer n
5109          parameter (n=1)
# Line 4102 | Line 5112 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5112   # SGI and absoft compilers generates module name in upper case!
5113   testname="conftest"
5114   modcase="lower"
5115 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5116 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5115 > if (eval $ac_compile) 2>/dev/null ; then
5116 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5117      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5118      if test -z "$MOD" ; then
5119          MOD=`ls CONFTEST* 2>/dev/null \
5120 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5120 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5121          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5122          if test -n "$MOD" ; then
5123              testname="CONFTEST"
# Line 4147 | Line 5157 | cat >conftest.f90 <<EOF
5157   rm -f conftest*
5158   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5159   rm -f work*
5160 < cat >conftest.f90 <<EOF
5160 > cat >conftest.$ac_ext <<EOF
5161          module conftest
5162          integer n
5163          parameter (n=1)
# Line 4155 | Line 5165 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5165   EOF
5166   # SGI and absoft compilers generates module name in upper case!
5167   testname="conftest"
5168 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5169 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5168 > if (eval $ac_compile) 2>/dev/null ; then
5169 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5170     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5171     if test -n "$mod" ; then
5172        testname="CONFTEST"
# Line 4165 | Line 5175 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5175     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5176     cp $testname.$MOD conf
5177     rm -f conftest* CONFTEST*
5178 <   cat >conftest1.f90 <<EOF
5178 >   cat >conftest1.$ac_ext <<EOF
5179          program main
5180          use conftest
5181          print *, n
# Line 4173 | Line 5183 | EOF
5183   EOF
5184     F90_WORK_FILES_ARG=""
5185     F90MODINCSPEC=""
5186 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5186 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5187         MODDIRFLAG="-I"
5188         F90MODINCSPEC="-I<dir>"
5189         echo "$as_me:$LINENO: result: -I" >&5
5190   echo "${ECHO_T}-I" >&6
5191 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5191 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5192         MODDIRFLAG="-M"
5193         F90MODINCSPEC="-M<dir>"
5194         echo "$as_me:$LINENO: result: -M" >&5
5195   echo "${ECHO_T}-M" >&6
5196 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5196 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5197         MODDIRFLAG="-p"
5198         F90MODINCSPEC="-p<dir>"
5199         echo "$as_me:$LINENO: result: -p" >&5
# Line 4192 | Line 5202 | echo "${ECHO_T}-p" >&6
5202          cp work.pc conf/mpimod.pc
5203          echo "mpimod.pc" > conf/mpimod.pcl
5204          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5205 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5205 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5206              MODDIRFLAG='-cl,mpimod.pcl'
5207              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5208   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4222 | Line 5232 | else
5232   if test "${ac_cv_f90_module_names+set}" = set; then
5233    echo $ECHO_N "(cached) $ECHO_C" >&6
5234   else
5235 <  ac_ext=f90
5236 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5237 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5238 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5235 >  ac_ext=${FC_SRCEXT-f}
5236 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5237 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5238 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5239  
5240   # carry out the test in a new directory, so that we don't miss anything
5241   mkdir conftest
# Line 4243 | Line 5253 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5253    cat conftest.err >&5
5254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5255    (exit $ac_status); } &&
5256 <         { ac_try='test -z "$ac_f90_werror_flag"
5256 >         { ac_try='test -z "$ac_fc_werror_flag"
5257                           || test ! -s conftest.err'
5258    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5259    (eval $ac_try) 2>&5
# Line 4359 | Line 5369 | ac_ext=f90
5369   cd ..
5370   # cleanup
5371   rm -rf conftest
5372 < ac_ext=f90
5373 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5374 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5375 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
5372 > ac_ext=${FC_SRCEXT-f}
5373 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5374 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5375 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5376  
5377   fi
5378   echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
# Line 4457 | Line 5467 | ac_ext=c
5467   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5468   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5469  
5470 < ac_ext=c
5471 < ac_cpp='$CPP $CPPFLAGS'
5472 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5473 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5474 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4465 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4466 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4467 < # On Suns, sometimes $CPP names a directory.
4468 < if test -n "$CPP" && test -d "$CPP"; then
4469 <  CPP=
4470 < fi
4471 < if test -z "$CPP"; then
4472 <  if test "${ac_cv_prog_CPP+set}" = set; then
5470 >
5471 >
5472 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5473 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5474 > if test "${ac_cv_lib_m_asin+set}" = set; then
5475    echo $ECHO_N "(cached) $ECHO_C" >&6
5476   else
5477 <      # Double quotes because CPP needs to be expanded
5478 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5479 <    do
4478 <      ac_preproc_ok=false
4479 < for ac_c_preproc_warn_flag in '' yes
4480 < do
4481 <  # Use a header file that comes with gcc, so configuring glibc
4482 <  # with a fresh cross-compiler works.
4483 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4484 <  # <limits.h> exists even on freestanding compilers.
4485 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4486 <  # not just through cpp. "Syntax error" is here to catch this case.
4487 <  cat >conftest.$ac_ext <<_ACEOF
5477 >  ac_check_lib_save_LIBS=$LIBS
5478 > LIBS="-lm  $LIBS"
5479 > cat >conftest.$ac_ext <<_ACEOF
5480   /* confdefs.h.  */
5481   _ACEOF
5482   cat confdefs.h >>conftest.$ac_ext
5483   cat >>conftest.$ac_ext <<_ACEOF
5484   /* end confdefs.h.  */
5485 < #ifdef __STDC__
5486 < # include <limits.h>
5487 < #else
5488 < # include <assert.h>
5485 >
5486 > /* Override any gcc2 internal prototype to avoid an error.  */
5487 > #ifdef __cplusplus
5488 > extern "C"
5489   #endif
5490 <                     Syntax error
5490 > /* We use char because int might match the return type of a gcc2
5491 >   builtin and then its argument prototype would still apply.  */
5492 > char asin ();
5493 > #ifdef FC_DUMMY_MAIN
5494 > #ifndef FC_DUMMY_MAIN_EQ_F77
5495 > #  ifdef __cplusplus
5496 >     extern "C"
5497 > #  endif
5498 >   int FC_DUMMY_MAIN() { return 1; }
5499 > #endif
5500 > #endif
5501 > int
5502 > main ()
5503 > {
5504 > asin ();
5505 >  ;
5506 >  return 0;
5507 > }
5508   _ACEOF
5509 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5510 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5509 > rm -f conftest.$ac_objext conftest$ac_exeext
5510 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5511 >  (eval $ac_link) 2>conftest.er1
5512    ac_status=$?
5513    grep -v '^ *+' conftest.er1 >conftest.err
5514    rm -f conftest.er1
5515    cat conftest.err >&5
5516    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5517 <  (exit $ac_status); } >/dev/null; then
5518 <  if test -s conftest.err; then
5519 <    ac_cpp_err=$ac_c_preproc_warn_flag
5517 >  (exit $ac_status); } &&
5518 >         { ac_try='test -z "$ac_c_werror_flag"
5519 >                         || test ! -s conftest.err'
5520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5521 >  (eval $ac_try) 2>&5
5522 >  ac_status=$?
5523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5524 >  (exit $ac_status); }; } &&
5525 >         { ac_try='test -s conftest$ac_exeext'
5526 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5527 >  (eval $ac_try) 2>&5
5528 >  ac_status=$?
5529 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5530 >  (exit $ac_status); }; }; then
5531 >  ac_cv_lib_m_asin=yes
5532 > else
5533 >  echo "$as_me: failed program was:" >&5
5534 > sed 's/^/| /' conftest.$ac_ext >&5
5535 >
5536 > ac_cv_lib_m_asin=no
5537 > fi
5538 > rm -f conftest.err conftest.$ac_objext \
5539 >      conftest$ac_exeext conftest.$ac_ext
5540 > LIBS=$ac_check_lib_save_LIBS
5541 > fi
5542 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5543 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5544 > if test $ac_cv_lib_m_asin = yes; then
5545 >  cat >>confdefs.h <<_ACEOF
5546 > #define HAVE_LIBM 1
5547 > _ACEOF
5548 >
5549 >  LIBS="-lm $LIBS"
5550 >
5551 > else
5552 >  exit
5553 > fi
5554 >
5555 >
5556 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5557 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5558 > if test "${ac_cv_header_stdc+set}" = set; then
5559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5560 > else
5561 >  cat >conftest.$ac_ext <<_ACEOF
5562 > /* confdefs.h.  */
5563 > _ACEOF
5564 > cat confdefs.h >>conftest.$ac_ext
5565 > cat >>conftest.$ac_ext <<_ACEOF
5566 > /* end confdefs.h.  */
5567 > #include <stdlib.h>
5568 > #include <stdarg.h>
5569 > #include <string.h>
5570 > #include <float.h>
5571 >
5572 > #ifdef FC_DUMMY_MAIN
5573 > #ifndef FC_DUMMY_MAIN_EQ_F77
5574 > #  ifdef __cplusplus
5575 >     extern "C"
5576 > #  endif
5577 >   int FC_DUMMY_MAIN() { return 1; }
5578 > #endif
5579 > #endif
5580 > int
5581 > main ()
5582 > {
5583 >
5584 >  ;
5585 >  return 0;
5586 > }
5587 > _ACEOF
5588 > rm -f conftest.$ac_objext
5589 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5590 >  (eval $ac_compile) 2>conftest.er1
5591 >  ac_status=$?
5592 >  grep -v '^ *+' conftest.er1 >conftest.err
5593 >  rm -f conftest.er1
5594 >  cat conftest.err >&5
5595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5596 >  (exit $ac_status); } &&
5597 >         { ac_try='test -z "$ac_c_werror_flag"
5598 >                         || test ! -s conftest.err'
5599 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5600 >  (eval $ac_try) 2>&5
5601 >  ac_status=$?
5602 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603 >  (exit $ac_status); }; } &&
5604 >         { ac_try='test -s conftest.$ac_objext'
5605 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5606 >  (eval $ac_try) 2>&5
5607 >  ac_status=$?
5608 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5609 >  (exit $ac_status); }; }; then
5610 >  ac_cv_header_stdc=yes
5611 > else
5612 >  echo "$as_me: failed program was:" >&5
5613 > sed 's/^/| /' conftest.$ac_ext >&5
5614 >
5615 > ac_cv_header_stdc=no
5616 > fi
5617 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5618 >
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5621 >  cat >conftest.$ac_ext <<_ACEOF
5622 > /* confdefs.h.  */
5623 > _ACEOF
5624 > cat confdefs.h >>conftest.$ac_ext
5625 > cat >>conftest.$ac_ext <<_ACEOF
5626 > /* end confdefs.h.  */
5627 > #include <string.h>
5628 >
5629 > _ACEOF
5630 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5631 >  $EGREP "memchr" >/dev/null 2>&1; then
5632 >  :
5633 > else
5634 >  ac_cv_header_stdc=no
5635 > fi
5636 > rm -f conftest*
5637 >
5638 > fi
5639 >
5640 > if test $ac_cv_header_stdc = yes; then
5641 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5642 >  cat >conftest.$ac_ext <<_ACEOF
5643 > /* confdefs.h.  */
5644 > _ACEOF
5645 > cat confdefs.h >>conftest.$ac_ext
5646 > cat >>conftest.$ac_ext <<_ACEOF
5647 > /* end confdefs.h.  */
5648 > #include <stdlib.h>
5649 >
5650 > _ACEOF
5651 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5652 >  $EGREP "free" >/dev/null 2>&1; then
5653 >  :
5654 > else
5655 >  ac_cv_header_stdc=no
5656 > fi
5657 > rm -f conftest*
5658 >
5659 > fi
5660 >
5661 > if test $ac_cv_header_stdc = yes; then
5662 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5663 >  if test "$cross_compiling" = yes; then
5664 >  :
5665 > else
5666 >  cat >conftest.$ac_ext <<_ACEOF
5667 > /* confdefs.h.  */
5668 > _ACEOF
5669 > cat confdefs.h >>conftest.$ac_ext
5670 > cat >>conftest.$ac_ext <<_ACEOF
5671 > /* end confdefs.h.  */
5672 > #include <ctype.h>
5673 > #if ((' ' & 0x0FF) == 0x020)
5674 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5675 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5676 > #else
5677 > # define ISLOWER(c) \
5678 >                   (('a' <= (c) && (c) <= 'i') \
5679 >                     || ('j' <= (c) && (c) <= 'r') \
5680 >                     || ('s' <= (c) && (c) <= 'z'))
5681 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5682 > #endif
5683 >
5684 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5685 > int
5686 > main ()
5687 > {
5688 >  int i;
5689 >  for (i = 0; i < 256; i++)
5690 >    if (XOR (islower (i), ISLOWER (i))
5691 >        || toupper (i) != TOUPPER (i))
5692 >      exit(2);
5693 >  exit (0);
5694 > }
5695 > _ACEOF
5696 > rm -f conftest$ac_exeext
5697 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5698 >  (eval $ac_link) 2>&5
5699 >  ac_status=$?
5700 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5701 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5702 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5703 >  (eval $ac_try) 2>&5
5704 >  ac_status=$?
5705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5706 >  (exit $ac_status); }; }; then
5707 >  :
5708 > else
5709 >  echo "$as_me: program exited with status $ac_status" >&5
5710 > echo "$as_me: failed program was:" >&5
5711 > sed 's/^/| /' conftest.$ac_ext >&5
5712 >
5713 > ( exit $ac_status )
5714 > ac_cv_header_stdc=no
5715 > fi
5716 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5717 > fi
5718 > fi
5719 > fi
5720 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5721 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5722 > if test $ac_cv_header_stdc = yes; then
5723 >
5724 > cat >>confdefs.h <<\_ACEOF
5725 > #define STDC_HEADERS 1
5726 > _ACEOF
5727 >
5728 > fi
5729 >
5730 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5731 >
5732 >
5733 >
5734 >
5735 >
5736 >
5737 >
5738 >
5739 >
5740 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5741 >                  inttypes.h stdint.h unistd.h
5742 > do
5743 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5744 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5745 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5746 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5747 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5748 > else
5749 >  cat >conftest.$ac_ext <<_ACEOF
5750 > /* confdefs.h.  */
5751 > _ACEOF
5752 > cat confdefs.h >>conftest.$ac_ext
5753 > cat >>conftest.$ac_ext <<_ACEOF
5754 > /* end confdefs.h.  */
5755 > $ac_includes_default
5756 >
5757 > #include <$ac_header>
5758 > _ACEOF
5759 > rm -f conftest.$ac_objext
5760 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5761 >  (eval $ac_compile) 2>conftest.er1
5762 >  ac_status=$?
5763 >  grep -v '^ *+' conftest.er1 >conftest.err
5764 >  rm -f conftest.er1
5765 >  cat conftest.err >&5
5766 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5767 >  (exit $ac_status); } &&
5768 >         { ac_try='test -z "$ac_c_werror_flag"
5769 >                         || test ! -s conftest.err'
5770 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5771 >  (eval $ac_try) 2>&5
5772 >  ac_status=$?
5773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5774 >  (exit $ac_status); }; } &&
5775 >         { ac_try='test -s conftest.$ac_objext'
5776 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5777 >  (eval $ac_try) 2>&5
5778 >  ac_status=$?
5779 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5780 >  (exit $ac_status); }; }; then
5781 >  eval "$as_ac_Header=yes"
5782 > else
5783 >  echo "$as_me: failed program was:" >&5
5784 > sed 's/^/| /' conftest.$ac_ext >&5
5785 >
5786 > eval "$as_ac_Header=no"
5787 > fi
5788 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5789 > fi
5790 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5791 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5792 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5793 >  cat >>confdefs.h <<_ACEOF
5794 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5795 > _ACEOF
5796 >
5797 > fi
5798 >
5799 > done
5800 >
5801 >
5802 > #
5803 > # Handle user hints
5804 > #
5805 >
5806 > # Check whether --with-zlib or --without-zlib was given.
5807 > if test "${with_zlib+set}" = set; then
5808 >  withval="$with_zlib"
5809 >  zlib_dir="$withval"
5810 > else
5811 >                zlib_dir="not_set"
5812 > fi;
5813 > if test "$zlib_dir" != "no"; then
5814 >
5815 > if test "$zlib_dir" != "not_set" ; then
5816 >  if test -d "$zlib_dir"
5817 >  then
5818 >    ZLIB_HOME="$zlib_dir"
5819 >  else
5820 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5821 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5822 >  fi
5823 > fi
5824 >
5825 > ZLIB_HOME=/usr/local
5826 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5827 > then
5828 >        ZLIB_HOME=/usr
5829 > fi
5830 >
5831 > #
5832 > # Locate zlib, if wanted
5833 > #
5834 > if test -n "${ZLIB_HOME}"
5835 > then
5836 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5837 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5838 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5839 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5840 >
5841 >
5842 >        ac_ext=c
5843 > ac_cpp='$CPP $CPPFLAGS'
5844 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5845 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5846 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5847 >
5848 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5849 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5850 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5851 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5852 > else
5853 >  ac_check_lib_save_LIBS=$LIBS
5854 > LIBS="-lz  $LIBS"
5855 > cat >conftest.$ac_ext <<_ACEOF
5856 > /* confdefs.h.  */
5857 > _ACEOF
5858 > cat confdefs.h >>conftest.$ac_ext
5859 > cat >>conftest.$ac_ext <<_ACEOF
5860 > /* end confdefs.h.  */
5861 >
5862 > /* Override any gcc2 internal prototype to avoid an error.  */
5863 > #ifdef __cplusplus
5864 > extern "C"
5865 > #endif
5866 > /* We use char because int might match the return type of a gcc2
5867 >   builtin and then its argument prototype would still apply.  */
5868 > char inflateEnd ();
5869 > #ifdef FC_DUMMY_MAIN
5870 > #ifndef FC_DUMMY_MAIN_EQ_F77
5871 > #  ifdef __cplusplus
5872 >     extern "C"
5873 > #  endif
5874 >   int FC_DUMMY_MAIN() { return 1; }
5875 > #endif
5876 > #endif
5877 > int
5878 > main ()
5879 > {
5880 > inflateEnd ();
5881 >  ;
5882 >  return 0;
5883 > }
5884 > _ACEOF
5885 > rm -f conftest.$ac_objext conftest$ac_exeext
5886 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5887 >  (eval $ac_link) 2>conftest.er1
5888 >  ac_status=$?
5889 >  grep -v '^ *+' conftest.er1 >conftest.err
5890 >  rm -f conftest.er1
5891 >  cat conftest.err >&5
5892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5893 >  (exit $ac_status); } &&
5894 >         { ac_try='test -z "$ac_c_werror_flag"
5895 >                         || test ! -s conftest.err'
5896 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5897 >  (eval $ac_try) 2>&5
5898 >  ac_status=$?
5899 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5900 >  (exit $ac_status); }; } &&
5901 >         { ac_try='test -s conftest$ac_exeext'
5902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5903 >  (eval $ac_try) 2>&5
5904 >  ac_status=$?
5905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5906 >  (exit $ac_status); }; }; then
5907 >  ac_cv_lib_z_inflateEnd=yes
5908 > else
5909 >  echo "$as_me: failed program was:" >&5
5910 > sed 's/^/| /' conftest.$ac_ext >&5
5911 >
5912 > ac_cv_lib_z_inflateEnd=no
5913 > fi
5914 > rm -f conftest.err conftest.$ac_objext \
5915 >      conftest$ac_exeext conftest.$ac_ext
5916 > LIBS=$ac_check_lib_save_LIBS
5917 > fi
5918 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5919 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5920 > if test $ac_cv_lib_z_inflateEnd = yes; then
5921 >  zlib_cv_libz=yes
5922 > else
5923 >  zlib_cv_libz=no
5924 > fi
5925 >
5926 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5927 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5928 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5929 > if test "${ac_cv_header_zlib_h+set}" = set; then
5930 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5931 > fi
5932 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5933 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5934 > else
5935 >  # Is the header compilable?
5936 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5937 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5938 > cat >conftest.$ac_ext <<_ACEOF
5939 > /* confdefs.h.  */
5940 > _ACEOF
5941 > cat confdefs.h >>conftest.$ac_ext
5942 > cat >>conftest.$ac_ext <<_ACEOF
5943 > /* end confdefs.h.  */
5944 > $ac_includes_default
5945 > #include <zlib.h>
5946 > _ACEOF
5947 > rm -f conftest.$ac_objext
5948 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5949 >  (eval $ac_compile) 2>conftest.er1
5950 >  ac_status=$?
5951 >  grep -v '^ *+' conftest.er1 >conftest.err
5952 >  rm -f conftest.er1
5953 >  cat conftest.err >&5
5954 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5955 >  (exit $ac_status); } &&
5956 >         { ac_try='test -z "$ac_c_werror_flag"
5957 >                         || test ! -s conftest.err'
5958 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5959 >  (eval $ac_try) 2>&5
5960 >  ac_status=$?
5961 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5962 >  (exit $ac_status); }; } &&
5963 >         { ac_try='test -s conftest.$ac_objext'
5964 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5965 >  (eval $ac_try) 2>&5
5966 >  ac_status=$?
5967 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5968 >  (exit $ac_status); }; }; then
5969 >  ac_header_compiler=yes
5970 > else
5971 >  echo "$as_me: failed program was:" >&5
5972 > sed 's/^/| /' conftest.$ac_ext >&5
5973 >
5974 > ac_header_compiler=no
5975 > fi
5976 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5977 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5978 > echo "${ECHO_T}$ac_header_compiler" >&6
5979 >
5980 > # Is the header present?
5981 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5982 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5983 > cat >conftest.$ac_ext <<_ACEOF
5984 > /* confdefs.h.  */
5985 > _ACEOF
5986 > cat confdefs.h >>conftest.$ac_ext
5987 > cat >>conftest.$ac_ext <<_ACEOF
5988 > /* end confdefs.h.  */
5989 > #include <zlib.h>
5990 > _ACEOF
5991 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5992 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5993 >  ac_status=$?
5994 >  grep -v '^ *+' conftest.er1 >conftest.err
5995 >  rm -f conftest.er1
5996 >  cat conftest.err >&5
5997 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5998 >  (exit $ac_status); } >/dev/null; then
5999 >  if test -s conftest.err; then
6000 >    ac_cpp_err=$ac_c_preproc_warn_flag
6001 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6002 >  else
6003 >    ac_cpp_err=
6004 >  fi
6005 > else
6006 >  ac_cpp_err=yes
6007 > fi
6008 > if test -z "$ac_cpp_err"; then
6009 >  ac_header_preproc=yes
6010 > else
6011 >  echo "$as_me: failed program was:" >&5
6012 > sed 's/^/| /' conftest.$ac_ext >&5
6013 >
6014 >  ac_header_preproc=no
6015 > fi
6016 > rm -f conftest.err conftest.$ac_ext
6017 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6018 > echo "${ECHO_T}$ac_header_preproc" >&6
6019 >
6020 > # So?  What about this header?
6021 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6022 >  yes:no: )
6023 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6024 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6025 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6026 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6027 >    ac_header_preproc=yes
6028 >    ;;
6029 >  no:yes:* )
6030 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6031 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6032 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6033 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6034 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6035 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6036 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6037 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6038 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6039 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6040 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6041 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6042 >    (
6043 >      cat <<\_ASBOX
6044 > ## ------------------------------ ##
6045 > ## Report this to gezelter@nd.edu ##
6046 > ## ------------------------------ ##
6047 > _ASBOX
6048 >    ) |
6049 >      sed "s/^/$as_me: WARNING:     /" >&2
6050 >    ;;
6051 > esac
6052 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6053 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6054 > if test "${ac_cv_header_zlib_h+set}" = set; then
6055 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6056 > else
6057 >  ac_cv_header_zlib_h=$ac_header_preproc
6058 > fi
6059 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6060 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6061 >
6062 > fi
6063 > if test $ac_cv_header_zlib_h = yes; then
6064 >  zlib_cv_zlib_h=yes
6065 > else
6066 >  zlib_cv_zlib_h=no
6067 > fi
6068 >
6069 >
6070 >        ac_ext=c
6071 > ac_cpp='$CPP $CPPFLAGS'
6072 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6073 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6074 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6075 >
6076 >
6077 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6078 >
6079 > cat >>confdefs.h <<\_ACEOF
6080 > #define HAVE_ZLIB_H 1
6081 > _ACEOF
6082 >
6083 >
6084 > cat >>confdefs.h <<\_ACEOF
6085 > #define HAVE_LIBZ 1
6086 > _ACEOF
6087 >
6088 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6089 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6090 >                ZLIB="-lz"
6091 >        else
6092 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6093 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6094 >                ZLIB_INC_DIR=
6095 >                ZLIB_LIB_DIR=
6096 >                ZLIB=
6097 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6098 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6099 >                echo "$as_me:$LINENO: result: failed" >&5
6100 > echo "${ECHO_T}failed" >&6
6101 >                echo ""
6102 >                echo "*********************************************************"
6103 >                echo "* WARNING: Could not find a working zlib installation   *"
6104 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6105 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6106 >                echo "* installation with --with-zlib=DIR                     *"
6107 >                echo "*                                                       *"
6108 >                echo "* OOPSE will still work without zlib installed.         *"
6109 >                echo "*********************************************************"
6110 >                echo ""
6111 >        fi
6112 >
6113 >
6114 >
6115 > fi
6116 > fi
6117 >
6118 > #
6119 > # Handle user hints
6120 > #
6121 >
6122 > # Check whether --with-fftw or --without-fftw was given.
6123 > if test "${with_fftw+set}" = set; then
6124 >  withval="$with_fftw"
6125 >  fftw_dir="$withval"
6126 > else
6127 >                fftw_dir="not_set"
6128 > fi;
6129 > if test "$fftw_dir" != "no"; then
6130 >
6131 > if test "$fftw_dir" != "not_set" ; then
6132 >  if test -d "$fftw_dir"
6133 >  then
6134 >    FFTW_HOME="$fftw_dir"
6135 >  else
6136 >    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6137 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6138 >  fi
6139 > fi
6140 >
6141 > FFTW_HOME=/usr/local
6142 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6143 > then
6144 >        FFTW_HOME=/usr
6145 > fi
6146 >
6147 > #
6148 > # Locate fftw, if wanted
6149 > #
6150 > if test -n "${FFTW_HOME}"
6151 > then
6152 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6153 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6154 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6155 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6156 >
6157 >
6158 >        ac_ext=c
6159 > ac_cpp='$CPP $CPPFLAGS'
6160 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6161 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6162 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6163 >
6164 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6165 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6166 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6167 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6168 > else
6169 >  ac_check_lib_save_LIBS=$LIBS
6170 > LIBS="-lfftw3  $LIBS"
6171 > cat >conftest.$ac_ext <<_ACEOF
6172 > /* confdefs.h.  */
6173 > _ACEOF
6174 > cat confdefs.h >>conftest.$ac_ext
6175 > cat >>conftest.$ac_ext <<_ACEOF
6176 > /* end confdefs.h.  */
6177 >
6178 > /* Override any gcc2 internal prototype to avoid an error.  */
6179 > #ifdef __cplusplus
6180 > extern "C"
6181 > #endif
6182 > /* We use char because int might match the return type of a gcc2
6183 >   builtin and then its argument prototype would still apply.  */
6184 > char fftw_execute ();
6185 > #ifdef FC_DUMMY_MAIN
6186 > #ifndef FC_DUMMY_MAIN_EQ_F77
6187 > #  ifdef __cplusplus
6188 >     extern "C"
6189 > #  endif
6190 >   int FC_DUMMY_MAIN() { return 1; }
6191 > #endif
6192 > #endif
6193 > int
6194 > main ()
6195 > {
6196 > fftw_execute ();
6197 >  ;
6198 >  return 0;
6199 > }
6200 > _ACEOF
6201 > rm -f conftest.$ac_objext conftest$ac_exeext
6202 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6203 >  (eval $ac_link) 2>conftest.er1
6204 >  ac_status=$?
6205 >  grep -v '^ *+' conftest.er1 >conftest.err
6206 >  rm -f conftest.er1
6207 >  cat conftest.err >&5
6208 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6209 >  (exit $ac_status); } &&
6210 >         { ac_try='test -z "$ac_c_werror_flag"
6211 >                         || test ! -s conftest.err'
6212 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6213 >  (eval $ac_try) 2>&5
6214 >  ac_status=$?
6215 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6216 >  (exit $ac_status); }; } &&
6217 >         { ac_try='test -s conftest$ac_exeext'
6218 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6219 >  (eval $ac_try) 2>&5
6220 >  ac_status=$?
6221 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6222 >  (exit $ac_status); }; }; then
6223 >  ac_cv_lib_fftw3_fftw_execute=yes
6224 > else
6225 >  echo "$as_me: failed program was:" >&5
6226 > sed 's/^/| /' conftest.$ac_ext >&5
6227 >
6228 > ac_cv_lib_fftw3_fftw_execute=no
6229 > fi
6230 > rm -f conftest.err conftest.$ac_objext \
6231 >      conftest$ac_exeext conftest.$ac_ext
6232 > LIBS=$ac_check_lib_save_LIBS
6233 > fi
6234 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6235 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6236 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6237 >  fftw_cv_libfftw3=yes
6238 > else
6239 >  fftw_cv_libfftw3=no
6240 > fi
6241 >
6242 >        if test "${ac_cv_header_fftw3_h+set}" = set; then
6243 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6244 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6245 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6246 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6247 > fi
6248 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6249 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6250 > else
6251 >  # Is the header compilable?
6252 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6253 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6254 > cat >conftest.$ac_ext <<_ACEOF
6255 > /* confdefs.h.  */
6256 > _ACEOF
6257 > cat confdefs.h >>conftest.$ac_ext
6258 > cat >>conftest.$ac_ext <<_ACEOF
6259 > /* end confdefs.h.  */
6260 > $ac_includes_default
6261 > #include <fftw3.h>
6262 > _ACEOF
6263 > rm -f conftest.$ac_objext
6264 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6265 >  (eval $ac_compile) 2>conftest.er1
6266 >  ac_status=$?
6267 >  grep -v '^ *+' conftest.er1 >conftest.err
6268 >  rm -f conftest.er1
6269 >  cat conftest.err >&5
6270 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6271 >  (exit $ac_status); } &&
6272 >         { ac_try='test -z "$ac_c_werror_flag"
6273 >                         || test ! -s conftest.err'
6274 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6275 >  (eval $ac_try) 2>&5
6276 >  ac_status=$?
6277 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6278 >  (exit $ac_status); }; } &&
6279 >         { ac_try='test -s conftest.$ac_objext'
6280 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6281 >  (eval $ac_try) 2>&5
6282 >  ac_status=$?
6283 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6284 >  (exit $ac_status); }; }; then
6285 >  ac_header_compiler=yes
6286 > else
6287 >  echo "$as_me: failed program was:" >&5
6288 > sed 's/^/| /' conftest.$ac_ext >&5
6289 >
6290 > ac_header_compiler=no
6291 > fi
6292 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6293 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6294 > echo "${ECHO_T}$ac_header_compiler" >&6
6295 >
6296 > # Is the header present?
6297 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6298 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6299 > cat >conftest.$ac_ext <<_ACEOF
6300 > /* confdefs.h.  */
6301 > _ACEOF
6302 > cat confdefs.h >>conftest.$ac_ext
6303 > cat >>conftest.$ac_ext <<_ACEOF
6304 > /* end confdefs.h.  */
6305 > #include <fftw3.h>
6306 > _ACEOF
6307 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6308 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6309 >  ac_status=$?
6310 >  grep -v '^ *+' conftest.er1 >conftest.err
6311 >  rm -f conftest.er1
6312 >  cat conftest.err >&5
6313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6314 >  (exit $ac_status); } >/dev/null; then
6315 >  if test -s conftest.err; then
6316 >    ac_cpp_err=$ac_c_preproc_warn_flag
6317 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6318 >  else
6319 >    ac_cpp_err=
6320 >  fi
6321 > else
6322 >  ac_cpp_err=yes
6323 > fi
6324 > if test -z "$ac_cpp_err"; then
6325 >  ac_header_preproc=yes
6326 > else
6327 >  echo "$as_me: failed program was:" >&5
6328 > sed 's/^/| /' conftest.$ac_ext >&5
6329 >
6330 >  ac_header_preproc=no
6331 > fi
6332 > rm -f conftest.err conftest.$ac_ext
6333 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6334 > echo "${ECHO_T}$ac_header_preproc" >&6
6335 >
6336 > # So?  What about this header?
6337 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6338 >  yes:no: )
6339 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6340 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6341 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6342 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6343 >    ac_header_preproc=yes
6344 >    ;;
6345 >  no:yes:* )
6346 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6347 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6348 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6349 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6350 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6351 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6352 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6353 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6354 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6355 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6356 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6357 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6358 >    (
6359 >      cat <<\_ASBOX
6360 > ## ------------------------------ ##
6361 > ## Report this to gezelter@nd.edu ##
6362 > ## ------------------------------ ##
6363 > _ASBOX
6364 >    ) |
6365 >      sed "s/^/$as_me: WARNING:     /" >&2
6366 >    ;;
6367 > esac
6368 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6369 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6370 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6371 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6372 > else
6373 >  ac_cv_header_fftw3_h=$ac_header_preproc
6374 > fi
6375 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6376 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6377 >
6378 > fi
6379 > if test $ac_cv_header_fftw3_h = yes; then
6380 >  fftw_cv_fftw3_h=yes
6381 > else
6382 >  fftw_cv_fftw3_h=no
6383 > fi
6384 >
6385 >
6386 >        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6387 >        then
6388 >                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6389 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6390 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6391 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6392 > else
6393 >  ac_check_lib_save_LIBS=$LIBS
6394 > LIBS="-lfftw  $LIBS"
6395 > cat >conftest.$ac_ext <<_ACEOF
6396 > /* confdefs.h.  */
6397 > _ACEOF
6398 > cat confdefs.h >>conftest.$ac_ext
6399 > cat >>conftest.$ac_ext <<_ACEOF
6400 > /* end confdefs.h.  */
6401 >
6402 > /* Override any gcc2 internal prototype to avoid an error.  */
6403 > #ifdef __cplusplus
6404 > extern "C"
6405 > #endif
6406 > /* We use char because int might match the return type of a gcc2
6407 >   builtin and then its argument prototype would still apply.  */
6408 > char fftwnd_one ();
6409 > #ifdef FC_DUMMY_MAIN
6410 > #ifndef FC_DUMMY_MAIN_EQ_F77
6411 > #  ifdef __cplusplus
6412 >     extern "C"
6413 > #  endif
6414 >   int FC_DUMMY_MAIN() { return 1; }
6415 > #endif
6416 > #endif
6417 > int
6418 > main ()
6419 > {
6420 > fftwnd_one ();
6421 >  ;
6422 >  return 0;
6423 > }
6424 > _ACEOF
6425 > rm -f conftest.$ac_objext conftest$ac_exeext
6426 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6427 >  (eval $ac_link) 2>conftest.er1
6428 >  ac_status=$?
6429 >  grep -v '^ *+' conftest.er1 >conftest.err
6430 >  rm -f conftest.er1
6431 >  cat conftest.err >&5
6432 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6433 >  (exit $ac_status); } &&
6434 >         { ac_try='test -z "$ac_c_werror_flag"
6435 >                         || test ! -s conftest.err'
6436 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6437 >  (eval $ac_try) 2>&5
6438 >  ac_status=$?
6439 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6440 >  (exit $ac_status); }; } &&
6441 >         { ac_try='test -s conftest$ac_exeext'
6442 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6443 >  (eval $ac_try) 2>&5
6444 >  ac_status=$?
6445 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6446 >  (exit $ac_status); }; }; then
6447 >  ac_cv_lib_fftw_fftwnd_one=yes
6448 > else
6449 >  echo "$as_me: failed program was:" >&5
6450 > sed 's/^/| /' conftest.$ac_ext >&5
6451 >
6452 > ac_cv_lib_fftw_fftwnd_one=no
6453 > fi
6454 > rm -f conftest.err conftest.$ac_objext \
6455 >      conftest$ac_exeext conftest.$ac_ext
6456 > LIBS=$ac_check_lib_save_LIBS
6457 > fi
6458 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6459 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6460 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6461 >  fftw_cv_libfftw=yes
6462 > else
6463 >  fftw_cv_libfftw=no
6464 > fi
6465 >
6466 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6467 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6468 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6469 > if test "${ac_cv_header_fftw_h+set}" = set; then
6470 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6471 > fi
6472 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6473 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6474 > else
6475 >  # Is the header compilable?
6476 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6477 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6478 > cat >conftest.$ac_ext <<_ACEOF
6479 > /* confdefs.h.  */
6480 > _ACEOF
6481 > cat confdefs.h >>conftest.$ac_ext
6482 > cat >>conftest.$ac_ext <<_ACEOF
6483 > /* end confdefs.h.  */
6484 > $ac_includes_default
6485 > #include <fftw.h>
6486 > _ACEOF
6487 > rm -f conftest.$ac_objext
6488 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6489 >  (eval $ac_compile) 2>conftest.er1
6490 >  ac_status=$?
6491 >  grep -v '^ *+' conftest.er1 >conftest.err
6492 >  rm -f conftest.er1
6493 >  cat conftest.err >&5
6494 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6495 >  (exit $ac_status); } &&
6496 >         { ac_try='test -z "$ac_c_werror_flag"
6497 >                         || test ! -s conftest.err'
6498 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6499 >  (eval $ac_try) 2>&5
6500 >  ac_status=$?
6501 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6502 >  (exit $ac_status); }; } &&
6503 >         { ac_try='test -s conftest.$ac_objext'
6504 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6505 >  (eval $ac_try) 2>&5
6506 >  ac_status=$?
6507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508 >  (exit $ac_status); }; }; then
6509 >  ac_header_compiler=yes
6510 > else
6511 >  echo "$as_me: failed program was:" >&5
6512 > sed 's/^/| /' conftest.$ac_ext >&5
6513 >
6514 > ac_header_compiler=no
6515 > fi
6516 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6517 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6518 > echo "${ECHO_T}$ac_header_compiler" >&6
6519 >
6520 > # Is the header present?
6521 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6522 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6523 > cat >conftest.$ac_ext <<_ACEOF
6524 > /* confdefs.h.  */
6525 > _ACEOF
6526 > cat confdefs.h >>conftest.$ac_ext
6527 > cat >>conftest.$ac_ext <<_ACEOF
6528 > /* end confdefs.h.  */
6529 > #include <fftw.h>
6530 > _ACEOF
6531 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6532 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6533 >  ac_status=$?
6534 >  grep -v '^ *+' conftest.er1 >conftest.err
6535 >  rm -f conftest.er1
6536 >  cat conftest.err >&5
6537 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6538 >  (exit $ac_status); } >/dev/null; then
6539 >  if test -s conftest.err; then
6540 >    ac_cpp_err=$ac_c_preproc_warn_flag
6541 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6542 >  else
6543 >    ac_cpp_err=
6544 >  fi
6545 > else
6546 >  ac_cpp_err=yes
6547 > fi
6548 > if test -z "$ac_cpp_err"; then
6549 >  ac_header_preproc=yes
6550 > else
6551 >  echo "$as_me: failed program was:" >&5
6552 > sed 's/^/| /' conftest.$ac_ext >&5
6553 >
6554 >  ac_header_preproc=no
6555 > fi
6556 > rm -f conftest.err conftest.$ac_ext
6557 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6558 > echo "${ECHO_T}$ac_header_preproc" >&6
6559 >
6560 > # So?  What about this header?
6561 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6562 >  yes:no: )
6563 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6564 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6565 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6566 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6567 >    ac_header_preproc=yes
6568 >    ;;
6569 >  no:yes:* )
6570 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6571 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6572 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6573 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6574 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6575 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6576 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6577 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6578 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6579 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6580 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6581 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6582 >    (
6583 >      cat <<\_ASBOX
6584 > ## ------------------------------ ##
6585 > ## Report this to gezelter@nd.edu ##
6586 > ## ------------------------------ ##
6587 > _ASBOX
6588 >    ) |
6589 >      sed "s/^/$as_me: WARNING:     /" >&2
6590 >    ;;
6591 > esac
6592 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6593 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6594 > if test "${ac_cv_header_fftw_h+set}" = set; then
6595 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6596 > else
6597 >  ac_cv_header_fftw_h=$ac_header_preproc
6598 > fi
6599 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6600 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6601 >
6602 > fi
6603 > if test $ac_cv_header_fftw_h = yes; then
6604 >  fftw_cv_fftw_h=yes
6605 > else
6606 >  fftw_cv_fftw_h=no
6607 > fi
6608 >
6609 >
6610 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6611 >                then
6612 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6613 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6614 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6615 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6616 > else
6617 >  ac_check_lib_save_LIBS=$LIBS
6618 > LIBS="-ldfftw  $LIBS"
6619 > cat >conftest.$ac_ext <<_ACEOF
6620 > /* confdefs.h.  */
6621 > _ACEOF
6622 > cat confdefs.h >>conftest.$ac_ext
6623 > cat >>conftest.$ac_ext <<_ACEOF
6624 > /* end confdefs.h.  */
6625 >
6626 > /* Override any gcc2 internal prototype to avoid an error.  */
6627 > #ifdef __cplusplus
6628 > extern "C"
6629 > #endif
6630 > /* We use char because int might match the return type of a gcc2
6631 >   builtin and then its argument prototype would still apply.  */
6632 > char fftwnd_one ();
6633 > #ifdef FC_DUMMY_MAIN
6634 > #ifndef FC_DUMMY_MAIN_EQ_F77
6635 > #  ifdef __cplusplus
6636 >     extern "C"
6637 > #  endif
6638 >   int FC_DUMMY_MAIN() { return 1; }
6639 > #endif
6640 > #endif
6641 > int
6642 > main ()
6643 > {
6644 > fftwnd_one ();
6645 >  ;
6646 >  return 0;
6647 > }
6648 > _ACEOF
6649 > rm -f conftest.$ac_objext conftest$ac_exeext
6650 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6651 >  (eval $ac_link) 2>conftest.er1
6652 >  ac_status=$?
6653 >  grep -v '^ *+' conftest.er1 >conftest.err
6654 >  rm -f conftest.er1
6655 >  cat conftest.err >&5
6656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6657 >  (exit $ac_status); } &&
6658 >         { ac_try='test -z "$ac_c_werror_flag"
6659 >                         || test ! -s conftest.err'
6660 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6661 >  (eval $ac_try) 2>&5
6662 >  ac_status=$?
6663 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6664 >  (exit $ac_status); }; } &&
6665 >         { ac_try='test -s conftest$ac_exeext'
6666 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6667 >  (eval $ac_try) 2>&5
6668 >  ac_status=$?
6669 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6670 >  (exit $ac_status); }; }; then
6671 >  ac_cv_lib_dfftw_fftwnd_one=yes
6672 > else
6673 >  echo "$as_me: failed program was:" >&5
6674 > sed 's/^/| /' conftest.$ac_ext >&5
6675 >
6676 > ac_cv_lib_dfftw_fftwnd_one=no
6677 > fi
6678 > rm -f conftest.err conftest.$ac_objext \
6679 >      conftest$ac_exeext conftest.$ac_ext
6680 > LIBS=$ac_check_lib_save_LIBS
6681 > fi
6682 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6683 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6684 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6685 >  fftw_cv_libdfftw=yes
6686 > else
6687 >  fftw_cv_libdfftw=no
6688 > fi
6689 >
6690 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6691 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6692 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6693 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6694 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6695 > fi
6696 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6697 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6698 > else
6699 >  # Is the header compilable?
6700 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6701 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6702 > cat >conftest.$ac_ext <<_ACEOF
6703 > /* confdefs.h.  */
6704 > _ACEOF
6705 > cat confdefs.h >>conftest.$ac_ext
6706 > cat >>conftest.$ac_ext <<_ACEOF
6707 > /* end confdefs.h.  */
6708 > $ac_includes_default
6709 > #include <dfftw.h>
6710 > _ACEOF
6711 > rm -f conftest.$ac_objext
6712 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6713 >  (eval $ac_compile) 2>conftest.er1
6714 >  ac_status=$?
6715 >  grep -v '^ *+' conftest.er1 >conftest.err
6716 >  rm -f conftest.er1
6717 >  cat conftest.err >&5
6718 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6719 >  (exit $ac_status); } &&
6720 >         { ac_try='test -z "$ac_c_werror_flag"
6721 >                         || test ! -s conftest.err'
6722 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6723 >  (eval $ac_try) 2>&5
6724 >  ac_status=$?
6725 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6726 >  (exit $ac_status); }; } &&
6727 >         { ac_try='test -s conftest.$ac_objext'
6728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6729 >  (eval $ac_try) 2>&5
6730 >  ac_status=$?
6731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6732 >  (exit $ac_status); }; }; then
6733 >  ac_header_compiler=yes
6734 > else
6735 >  echo "$as_me: failed program was:" >&5
6736 > sed 's/^/| /' conftest.$ac_ext >&5
6737 >
6738 > ac_header_compiler=no
6739 > fi
6740 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6741 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6742 > echo "${ECHO_T}$ac_header_compiler" >&6
6743 >
6744 > # Is the header present?
6745 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6746 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6747 > cat >conftest.$ac_ext <<_ACEOF
6748 > /* confdefs.h.  */
6749 > _ACEOF
6750 > cat confdefs.h >>conftest.$ac_ext
6751 > cat >>conftest.$ac_ext <<_ACEOF
6752 > /* end confdefs.h.  */
6753 > #include <dfftw.h>
6754 > _ACEOF
6755 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6756 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6757 >  ac_status=$?
6758 >  grep -v '^ *+' conftest.er1 >conftest.err
6759 >  rm -f conftest.er1
6760 >  cat conftest.err >&5
6761 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6762 >  (exit $ac_status); } >/dev/null; then
6763 >  if test -s conftest.err; then
6764 >    ac_cpp_err=$ac_c_preproc_warn_flag
6765 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6766 >  else
6767 >    ac_cpp_err=
6768 >  fi
6769 > else
6770 >  ac_cpp_err=yes
6771 > fi
6772 > if test -z "$ac_cpp_err"; then
6773 >  ac_header_preproc=yes
6774 > else
6775 >  echo "$as_me: failed program was:" >&5
6776 > sed 's/^/| /' conftest.$ac_ext >&5
6777 >
6778 >  ac_header_preproc=no
6779 > fi
6780 > rm -f conftest.err conftest.$ac_ext
6781 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6782 > echo "${ECHO_T}$ac_header_preproc" >&6
6783 >
6784 > # So?  What about this header?
6785 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6786 >  yes:no: )
6787 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6788 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6789 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6790 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6791 >    ac_header_preproc=yes
6792 >    ;;
6793 >  no:yes:* )
6794 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6795 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6796 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6797 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6798 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6799 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6800 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6801 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6802 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6803 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6804 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6805 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6806 >    (
6807 >      cat <<\_ASBOX
6808 > ## ------------------------------ ##
6809 > ## Report this to gezelter@nd.edu ##
6810 > ## ------------------------------ ##
6811 > _ASBOX
6812 >    ) |
6813 >      sed "s/^/$as_me: WARNING:     /" >&2
6814 >    ;;
6815 > esac
6816 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6817 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6818 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6819 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6820 > else
6821 >  ac_cv_header_dfftw_h=$ac_header_preproc
6822 > fi
6823 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6824 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6825 >
6826 > fi
6827 > if test $ac_cv_header_dfftw_h = yes; then
6828 >  fftw_cv_dfftw_h=yes
6829 > else
6830 >  fftw_cv_dfftw_h=no
6831 > fi
6832 >
6833 >
6834 >                fi
6835 >        fi
6836 >        ac_ext=c
6837 > ac_cpp='$CPP $CPPFLAGS'
6838 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6839 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6840 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6841 >
6842 >
6843 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6844 >        then
6845 >
6846 > cat >>confdefs.h <<\_ACEOF
6847 > #define HAVE_FFTW3_H 1
6848 > _ACEOF
6849 >
6850 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6851 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6852 >                FFTW_LIBS="-lfftw3"
6853 >        else
6854 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6855 >        then
6856 >
6857 > cat >>confdefs.h <<\_ACEOF
6858 > #define HAVE_FFTW_H 1
6859 > _ACEOF
6860 >
6861 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6862 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6863 >                FFTW_LIBS="-lfftw"
6864 >        else
6865 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6866 >        then
6867 >
6868 > cat >>confdefs.h <<\_ACEOF
6869 > #define HAVE_DFFTW_H 1
6870 > _ACEOF
6871 >
6872 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6873 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6874 >                FFTW_LIBS="-ldfftw"
6875 >        else
6876 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6877 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6878 >                FFTW_INC_DIR=
6879 >                FFTW_LIB_DIR=
6880 >                FFTW_LIBS=
6881 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6882 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6883 >                echo "$as_me:$LINENO: result: failed" >&5
6884 > echo "${ECHO_T}failed" >&6
6885 >        echo ""
6886 >        echo "*********************************************************"
6887 >        echo "* WARNING: Could not find a working FFTW installation   *"
6888 >        echo "* If you need the staticProps program to be able to     *"
6889 >        echo "* compute undulation spectra, be sure to specify a      *"
6890 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6891 >        echo "*                                                       *"
6892 >        echo "* OOPSE will still work without fftw installed.         *"
6893 >        echo "*********************************************************"
6894 >        echo ""
6895 >        fi
6896 >        fi
6897 >        fi
6898 >
6899 >
6900 >
6901 > fi
6902 > fi
6903 >
6904 >
6905 >
6906 > # Checks for header files.
6907 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6908 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6909 > if test "${ac_cv_header_stdc+set}" = set; then
6910 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6911 > else
6912 >  cat >conftest.$ac_ext <<_ACEOF
6913 > /* confdefs.h.  */
6914 > _ACEOF
6915 > cat confdefs.h >>conftest.$ac_ext
6916 > cat >>conftest.$ac_ext <<_ACEOF
6917 > /* end confdefs.h.  */
6918 > #include <stdlib.h>
6919 > #include <stdarg.h>
6920 > #include <string.h>
6921 > #include <float.h>
6922 >
6923 > #ifdef FC_DUMMY_MAIN
6924 > #ifndef FC_DUMMY_MAIN_EQ_F77
6925 > #  ifdef __cplusplus
6926 >     extern "C"
6927 > #  endif
6928 >   int FC_DUMMY_MAIN() { return 1; }
6929 > #endif
6930 > #endif
6931 > int
6932 > main ()
6933 > {
6934 >
6935 >  ;
6936 >  return 0;
6937 > }
6938 > _ACEOF
6939 > rm -f conftest.$ac_objext
6940 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6941 >  (eval $ac_compile) 2>conftest.er1
6942 >  ac_status=$?
6943 >  grep -v '^ *+' conftest.er1 >conftest.err
6944 >  rm -f conftest.er1
6945 >  cat conftest.err >&5
6946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947 >  (exit $ac_status); } &&
6948 >         { ac_try='test -z "$ac_c_werror_flag"
6949 >                         || test ! -s conftest.err'
6950 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6951 >  (eval $ac_try) 2>&5
6952 >  ac_status=$?
6953 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6954 >  (exit $ac_status); }; } &&
6955 >         { ac_try='test -s conftest.$ac_objext'
6956 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6957 >  (eval $ac_try) 2>&5
6958 >  ac_status=$?
6959 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6960 >  (exit $ac_status); }; }; then
6961 >  ac_cv_header_stdc=yes
6962 > else
6963 >  echo "$as_me: failed program was:" >&5
6964 > sed 's/^/| /' conftest.$ac_ext >&5
6965 >
6966 > ac_cv_header_stdc=no
6967 > fi
6968 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6969 >
6970 > if test $ac_cv_header_stdc = yes; then
6971 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6972 >  cat >conftest.$ac_ext <<_ACEOF
6973 > /* confdefs.h.  */
6974 > _ACEOF
6975 > cat confdefs.h >>conftest.$ac_ext
6976 > cat >>conftest.$ac_ext <<_ACEOF
6977 > /* end confdefs.h.  */
6978 > #include <string.h>
6979 >
6980 > _ACEOF
6981 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6982 >  $EGREP "memchr" >/dev/null 2>&1; then
6983 >  :
6984 > else
6985 >  ac_cv_header_stdc=no
6986 > fi
6987 > rm -f conftest*
6988 >
6989 > fi
6990 >
6991 > if test $ac_cv_header_stdc = yes; then
6992 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6993 >  cat >conftest.$ac_ext <<_ACEOF
6994 > /* confdefs.h.  */
6995 > _ACEOF
6996 > cat confdefs.h >>conftest.$ac_ext
6997 > cat >>conftest.$ac_ext <<_ACEOF
6998 > /* end confdefs.h.  */
6999 > #include <stdlib.h>
7000 >
7001 > _ACEOF
7002 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7003 >  $EGREP "free" >/dev/null 2>&1; then
7004 >  :
7005 > else
7006 >  ac_cv_header_stdc=no
7007 > fi
7008 > rm -f conftest*
7009 >
7010 > fi
7011 >
7012 > if test $ac_cv_header_stdc = yes; then
7013 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7014 >  if test "$cross_compiling" = yes; then
7015 >  :
7016 > else
7017 >  cat >conftest.$ac_ext <<_ACEOF
7018 > /* confdefs.h.  */
7019 > _ACEOF
7020 > cat confdefs.h >>conftest.$ac_ext
7021 > cat >>conftest.$ac_ext <<_ACEOF
7022 > /* end confdefs.h.  */
7023 > #include <ctype.h>
7024 > #if ((' ' & 0x0FF) == 0x020)
7025 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7026 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7027 > #else
7028 > # define ISLOWER(c) \
7029 >                   (('a' <= (c) && (c) <= 'i') \
7030 >                     || ('j' <= (c) && (c) <= 'r') \
7031 >                     || ('s' <= (c) && (c) <= 'z'))
7032 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7033 > #endif
7034 >
7035 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7036 > int
7037 > main ()
7038 > {
7039 >  int i;
7040 >  for (i = 0; i < 256; i++)
7041 >    if (XOR (islower (i), ISLOWER (i))
7042 >        || toupper (i) != TOUPPER (i))
7043 >      exit(2);
7044 >  exit (0);
7045 > }
7046 > _ACEOF
7047 > rm -f conftest$ac_exeext
7048 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7049 >  (eval $ac_link) 2>&5
7050 >  ac_status=$?
7051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7052 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7054 >  (eval $ac_try) 2>&5
7055 >  ac_status=$?
7056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7057 >  (exit $ac_status); }; }; then
7058 >  :
7059 > else
7060 >  echo "$as_me: program exited with status $ac_status" >&5
7061 > echo "$as_me: failed program was:" >&5
7062 > sed 's/^/| /' conftest.$ac_ext >&5
7063 >
7064 > ( exit $ac_status )
7065 > ac_cv_header_stdc=no
7066 > fi
7067 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7068 > fi
7069 > fi
7070 > fi
7071 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7072 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7073 > if test $ac_cv_header_stdc = yes; then
7074 >
7075 > cat >>confdefs.h <<\_ACEOF
7076 > #define STDC_HEADERS 1
7077 > _ACEOF
7078 >
7079 > fi
7080 >
7081 >
7082 >
7083 >
7084 >
7085 >
7086 >
7087 >
7088 >
7089 >
7090 >
7091 >
7092 >
7093 >
7094 >
7095 >
7096 >
7097 >
7098 >
7099 >
7100 >
7101 >
7102 >
7103 >
7104 >
7105 >
7106 > for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7107 > do
7108 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7109 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7110 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7111 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7112 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7113 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7114 > fi
7115 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7116 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7117 > else
7118 >  # Is the header compilable?
7119 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7120 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7121 > cat >conftest.$ac_ext <<_ACEOF
7122 > /* confdefs.h.  */
7123 > _ACEOF
7124 > cat confdefs.h >>conftest.$ac_ext
7125 > cat >>conftest.$ac_ext <<_ACEOF
7126 > /* end confdefs.h.  */
7127 > $ac_includes_default
7128 > #include <$ac_header>
7129 > _ACEOF
7130 > rm -f conftest.$ac_objext
7131 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7132 >  (eval $ac_compile) 2>conftest.er1
7133 >  ac_status=$?
7134 >  grep -v '^ *+' conftest.er1 >conftest.err
7135 >  rm -f conftest.er1
7136 >  cat conftest.err >&5
7137 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7138 >  (exit $ac_status); } &&
7139 >         { ac_try='test -z "$ac_c_werror_flag"
7140 >                         || test ! -s conftest.err'
7141 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7142 >  (eval $ac_try) 2>&5
7143 >  ac_status=$?
7144 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7145 >  (exit $ac_status); }; } &&
7146 >         { ac_try='test -s conftest.$ac_objext'
7147 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7148 >  (eval $ac_try) 2>&5
7149 >  ac_status=$?
7150 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7151 >  (exit $ac_status); }; }; then
7152 >  ac_header_compiler=yes
7153 > else
7154 >  echo "$as_me: failed program was:" >&5
7155 > sed 's/^/| /' conftest.$ac_ext >&5
7156 >
7157 > ac_header_compiler=no
7158 > fi
7159 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7160 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7161 > echo "${ECHO_T}$ac_header_compiler" >&6
7162 >
7163 > # Is the header present?
7164 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7165 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7166 > cat >conftest.$ac_ext <<_ACEOF
7167 > /* confdefs.h.  */
7168 > _ACEOF
7169 > cat confdefs.h >>conftest.$ac_ext
7170 > cat >>conftest.$ac_ext <<_ACEOF
7171 > /* end confdefs.h.  */
7172 > #include <$ac_header>
7173 > _ACEOF
7174 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7175 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7176 >  ac_status=$?
7177 >  grep -v '^ *+' conftest.er1 >conftest.err
7178 >  rm -f conftest.er1
7179 >  cat conftest.err >&5
7180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7181 >  (exit $ac_status); } >/dev/null; then
7182 >  if test -s conftest.err; then
7183 >    ac_cpp_err=$ac_c_preproc_warn_flag
7184 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7185 >  else
7186 >    ac_cpp_err=
7187 >  fi
7188 > else
7189 >  ac_cpp_err=yes
7190 > fi
7191 > if test -z "$ac_cpp_err"; then
7192 >  ac_header_preproc=yes
7193 > else
7194 >  echo "$as_me: failed program was:" >&5
7195 > sed 's/^/| /' conftest.$ac_ext >&5
7196 >
7197 >  ac_header_preproc=no
7198 > fi
7199 > rm -f conftest.err conftest.$ac_ext
7200 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7201 > echo "${ECHO_T}$ac_header_preproc" >&6
7202 >
7203 > # So?  What about this header?
7204 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7205 >  yes:no: )
7206 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7207 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7208 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7209 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7210 >    ac_header_preproc=yes
7211 >    ;;
7212 >  no:yes:* )
7213 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7214 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7215 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7216 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7217 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7218 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7219 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7220 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7221 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7222 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7223 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7224 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7225 >    (
7226 >      cat <<\_ASBOX
7227 > ## ------------------------------ ##
7228 > ## Report this to gezelter@nd.edu ##
7229 > ## ------------------------------ ##
7230 > _ASBOX
7231 >    ) |
7232 >      sed "s/^/$as_me: WARNING:     /" >&2
7233 >    ;;
7234 > esac
7235 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7236 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7237 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7238 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7239 > else
7240 >  eval "$as_ac_Header=\$ac_header_preproc"
7241 > fi
7242 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7243 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7244 >
7245 > fi
7246 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7247 >  cat >>confdefs.h <<_ACEOF
7248 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7249 > _ACEOF
7250 >
7251 > fi
7252 >
7253 > done
7254 >
7255 >
7256 > # Checks for typedefs, structures, and compiler characteristics.
7257 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7258 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7259 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7260 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7261 > else
7262 >  cat >conftest.$ac_ext <<_ACEOF
7263 > /* confdefs.h.  */
7264 > _ACEOF
7265 > cat confdefs.h >>conftest.$ac_ext
7266 > cat >>conftest.$ac_ext <<_ACEOF
7267 > /* end confdefs.h.  */
7268 >
7269 > #include <stdbool.h>
7270 > #ifndef bool
7271 > # error bool is not defined
7272 > #endif
7273 > #ifndef false
7274 > # error false is not defined
7275 > #endif
7276 > #if false
7277 > # error false is not 0
7278 > #endif
7279 > #ifndef true
7280 > # error true is not defined
7281 > #endif
7282 > #if true != 1
7283 > # error true is not 1
7284 > #endif
7285 > #ifndef __bool_true_false_are_defined
7286 > # error __bool_true_false_are_defined is not defined
7287 > #endif
7288 >
7289 >        struct s { _Bool s: 1; _Bool t; } s;
7290 >
7291 >        char a[true == 1 ? 1 : -1];
7292 >        char b[false == 0 ? 1 : -1];
7293 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7294 >        char d[(bool) -0.5 == true ? 1 : -1];
7295 >        bool e = &s;
7296 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7297 >        char g[true];
7298 >        char h[sizeof (_Bool)];
7299 >        char i[sizeof s.t];
7300 >
7301 > #ifdef FC_DUMMY_MAIN
7302 > #ifndef FC_DUMMY_MAIN_EQ_F77
7303 > #  ifdef __cplusplus
7304 >     extern "C"
7305 > #  endif
7306 >   int FC_DUMMY_MAIN() { return 1; }
7307 > #endif
7308 > #endif
7309 > int
7310 > main ()
7311 > {
7312 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7313 >  ;
7314 >  return 0;
7315 > }
7316 > _ACEOF
7317 > rm -f conftest.$ac_objext
7318 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7319 >  (eval $ac_compile) 2>conftest.er1
7320 >  ac_status=$?
7321 >  grep -v '^ *+' conftest.er1 >conftest.err
7322 >  rm -f conftest.er1
7323 >  cat conftest.err >&5
7324 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7325 >  (exit $ac_status); } &&
7326 >         { ac_try='test -z "$ac_c_werror_flag"
7327 >                         || test ! -s conftest.err'
7328 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7329 >  (eval $ac_try) 2>&5
7330 >  ac_status=$?
7331 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7332 >  (exit $ac_status); }; } &&
7333 >         { ac_try='test -s conftest.$ac_objext'
7334 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7335 >  (eval $ac_try) 2>&5
7336 >  ac_status=$?
7337 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7338 >  (exit $ac_status); }; }; then
7339 >  ac_cv_header_stdbool_h=yes
7340 > else
7341 >  echo "$as_me: failed program was:" >&5
7342 > sed 's/^/| /' conftest.$ac_ext >&5
7343 >
7344 > ac_cv_header_stdbool_h=no
7345 > fi
7346 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7347 > fi
7348 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7349 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7350 > echo "$as_me:$LINENO: checking for _Bool" >&5
7351 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7352 > if test "${ac_cv_type__Bool+set}" = set; then
7353 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7354 > else
7355 >  cat >conftest.$ac_ext <<_ACEOF
7356 > /* confdefs.h.  */
7357 > _ACEOF
7358 > cat confdefs.h >>conftest.$ac_ext
7359 > cat >>conftest.$ac_ext <<_ACEOF
7360 > /* end confdefs.h.  */
7361 > $ac_includes_default
7362 > #ifdef FC_DUMMY_MAIN
7363 > #ifndef FC_DUMMY_MAIN_EQ_F77
7364 > #  ifdef __cplusplus
7365 >     extern "C"
7366 > #  endif
7367 >   int FC_DUMMY_MAIN() { return 1; }
7368 > #endif
7369 > #endif
7370 > int
7371 > main ()
7372 > {
7373 > if ((_Bool *) 0)
7374 >  return 0;
7375 > if (sizeof (_Bool))
7376 >  return 0;
7377 >  ;
7378 >  return 0;
7379 > }
7380 > _ACEOF
7381 > rm -f conftest.$ac_objext
7382 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7383 >  (eval $ac_compile) 2>conftest.er1
7384 >  ac_status=$?
7385 >  grep -v '^ *+' conftest.er1 >conftest.err
7386 >  rm -f conftest.er1
7387 >  cat conftest.err >&5
7388 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7389 >  (exit $ac_status); } &&
7390 >         { ac_try='test -z "$ac_c_werror_flag"
7391 >                         || test ! -s conftest.err'
7392 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7393 >  (eval $ac_try) 2>&5
7394 >  ac_status=$?
7395 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7396 >  (exit $ac_status); }; } &&
7397 >         { ac_try='test -s conftest.$ac_objext'
7398 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7399 >  (eval $ac_try) 2>&5
7400 >  ac_status=$?
7401 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7402 >  (exit $ac_status); }; }; then
7403 >  ac_cv_type__Bool=yes
7404 > else
7405 >  echo "$as_me: failed program was:" >&5
7406 > sed 's/^/| /' conftest.$ac_ext >&5
7407 >
7408 > ac_cv_type__Bool=no
7409 > fi
7410 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7411 > fi
7412 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7413 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7414 > if test $ac_cv_type__Bool = yes; then
7415 >
7416 > cat >>confdefs.h <<_ACEOF
7417 > #define HAVE__BOOL 1
7418 > _ACEOF
7419 >
7420 >
7421 > fi
7422 >
7423 > if test $ac_cv_header_stdbool_h = yes; then
7424 >
7425 > cat >>confdefs.h <<\_ACEOF
7426 > #define HAVE_STDBOOL_H 1
7427 > _ACEOF
7428 >
7429 > fi
7430 >
7431 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7432 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7433 > if test "${ac_cv_c_const+set}" = set; then
7434 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7435 > else
7436 >  cat >conftest.$ac_ext <<_ACEOF
7437 > /* confdefs.h.  */
7438 > _ACEOF
7439 > cat confdefs.h >>conftest.$ac_ext
7440 > cat >>conftest.$ac_ext <<_ACEOF
7441 > /* end confdefs.h.  */
7442 >
7443 > #ifdef FC_DUMMY_MAIN
7444 > #ifndef FC_DUMMY_MAIN_EQ_F77
7445 > #  ifdef __cplusplus
7446 >     extern "C"
7447 > #  endif
7448 >   int FC_DUMMY_MAIN() { return 1; }
7449 > #endif
7450 > #endif
7451 > int
7452 > main ()
7453 > {
7454 > /* FIXME: Include the comments suggested by Paul. */
7455 > #ifndef __cplusplus
7456 >  /* Ultrix mips cc rejects this.  */
7457 >  typedef int charset[2];
7458 >  const charset x;
7459 >  /* SunOS 4.1.1 cc rejects this.  */
7460 >  char const *const *ccp;
7461 >  char **p;
7462 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7463 >  struct point {int x, y;};
7464 >  static struct point const zero = {0,0};
7465 >  /* AIX XL C 1.02.0.0 rejects this.
7466 >     It does not let you subtract one const X* pointer from another in
7467 >     an arm of an if-expression whose if-part is not a constant
7468 >     expression */
7469 >  const char *g = "string";
7470 >  ccp = &g + (g ? g-g : 0);
7471 >  /* HPUX 7.0 cc rejects these. */
7472 >  ++ccp;
7473 >  p = (char**) ccp;
7474 >  ccp = (char const *const *) p;
7475 >  { /* SCO 3.2v4 cc rejects this.  */
7476 >    char *t;
7477 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7478 >
7479 >    *t++ = 0;
7480 >  }
7481 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7482 >    int x[] = {25, 17};
7483 >    const int *foo = &x[0];
7484 >    ++foo;
7485 >  }
7486 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7487 >    typedef const int *iptr;
7488 >    iptr p = 0;
7489 >    ++p;
7490 >  }
7491 >  { /* AIX XL C 1.02.0.0 rejects this saying
7492 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7493 >    struct s { int j; const int *ap[3]; };
7494 >    struct s *b; b->j = 5;
7495 >  }
7496 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7497 >    const int foo = 10;
7498 >  }
7499 > #endif
7500 >
7501 >  ;
7502 >  return 0;
7503 > }
7504 > _ACEOF
7505 > rm -f conftest.$ac_objext
7506 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7507 >  (eval $ac_compile) 2>conftest.er1
7508 >  ac_status=$?
7509 >  grep -v '^ *+' conftest.er1 >conftest.err
7510 >  rm -f conftest.er1
7511 >  cat conftest.err >&5
7512 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7513 >  (exit $ac_status); } &&
7514 >         { ac_try='test -z "$ac_c_werror_flag"
7515 >                         || test ! -s conftest.err'
7516 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7517 >  (eval $ac_try) 2>&5
7518 >  ac_status=$?
7519 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7520 >  (exit $ac_status); }; } &&
7521 >         { ac_try='test -s conftest.$ac_objext'
7522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7523 >  (eval $ac_try) 2>&5
7524 >  ac_status=$?
7525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7526 >  (exit $ac_status); }; }; then
7527 >  ac_cv_c_const=yes
7528 > else
7529 >  echo "$as_me: failed program was:" >&5
7530 > sed 's/^/| /' conftest.$ac_ext >&5
7531 >
7532 > ac_cv_c_const=no
7533 > fi
7534 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7535 > fi
7536 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7537 > echo "${ECHO_T}$ac_cv_c_const" >&6
7538 > if test $ac_cv_c_const = no; then
7539 >
7540 > cat >>confdefs.h <<\_ACEOF
7541 > #define const
7542 > _ACEOF
7543 >
7544 > fi
7545 >
7546 > echo "$as_me:$LINENO: checking for inline" >&5
7547 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7548 > if test "${ac_cv_c_inline+set}" = set; then
7549 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7550 > else
7551 >  ac_cv_c_inline=no
7552 > for ac_kw in inline __inline__ __inline; do
7553 >  cat >conftest.$ac_ext <<_ACEOF
7554 > /* confdefs.h.  */
7555 > _ACEOF
7556 > cat confdefs.h >>conftest.$ac_ext
7557 > cat >>conftest.$ac_ext <<_ACEOF
7558 > /* end confdefs.h.  */
7559 > #ifndef __cplusplus
7560 > typedef int foo_t;
7561 > static $ac_kw foo_t static_foo () {return 0; }
7562 > $ac_kw foo_t foo () {return 0; }
7563 > #endif
7564 >
7565 > _ACEOF
7566 > rm -f conftest.$ac_objext
7567 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7568 >  (eval $ac_compile) 2>conftest.er1
7569 >  ac_status=$?
7570 >  grep -v '^ *+' conftest.er1 >conftest.err
7571 >  rm -f conftest.er1
7572 >  cat conftest.err >&5
7573 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7574 >  (exit $ac_status); } &&
7575 >         { ac_try='test -z "$ac_c_werror_flag"
7576 >                         || test ! -s conftest.err'
7577 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7578 >  (eval $ac_try) 2>&5
7579 >  ac_status=$?
7580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7581 >  (exit $ac_status); }; } &&
7582 >         { ac_try='test -s conftest.$ac_objext'
7583 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7584 >  (eval $ac_try) 2>&5
7585 >  ac_status=$?
7586 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7587 >  (exit $ac_status); }; }; then
7588 >  ac_cv_c_inline=$ac_kw; break
7589 > else
7590 >  echo "$as_me: failed program was:" >&5
7591 > sed 's/^/| /' conftest.$ac_ext >&5
7592 >
7593 > fi
7594 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7595 > done
7596 >
7597 > fi
7598 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7599 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7600 >
7601 >
7602 > case $ac_cv_c_inline in
7603 >  inline | yes) ;;
7604 >  *)
7605 >    case $ac_cv_c_inline in
7606 >      no) ac_val=;;
7607 >      *) ac_val=$ac_cv_c_inline;;
7608 >    esac
7609 >    cat >>confdefs.h <<_ACEOF
7610 > #ifndef __cplusplus
7611 > #define inline $ac_val
7612 > #endif
7613 > _ACEOF
7614 >    ;;
7615 > esac
7616 >
7617 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7618 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7619 > if test "${ac_cv_c_restrict+set}" = set; then
7620 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7621 > else
7622 >  ac_cv_c_restrict=no
7623 >   # Try the official restrict keyword, then gcc's __restrict, and
7624 >   # the less common variants.
7625 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7626 >     cat >conftest.$ac_ext <<_ACEOF
7627 > /* confdefs.h.  */
7628 > _ACEOF
7629 > cat confdefs.h >>conftest.$ac_ext
7630 > cat >>conftest.$ac_ext <<_ACEOF
7631 > /* end confdefs.h.  */
7632 > float * $ac_kw x;
7633 > _ACEOF
7634 > rm -f conftest.$ac_objext
7635 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7636 >  (eval $ac_compile) 2>conftest.er1
7637 >  ac_status=$?
7638 >  grep -v '^ *+' conftest.er1 >conftest.err
7639 >  rm -f conftest.er1
7640 >  cat conftest.err >&5
7641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7642 >  (exit $ac_status); } &&
7643 >         { ac_try='test -z "$ac_c_werror_flag"
7644 >                         || test ! -s conftest.err'
7645 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7646 >  (eval $ac_try) 2>&5
7647 >  ac_status=$?
7648 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7649 >  (exit $ac_status); }; } &&
7650 >         { ac_try='test -s conftest.$ac_objext'
7651 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7652 >  (eval $ac_try) 2>&5
7653 >  ac_status=$?
7654 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7655 >  (exit $ac_status); }; }; then
7656 >  ac_cv_c_restrict=$ac_kw; break
7657 > else
7658 >  echo "$as_me: failed program was:" >&5
7659 > sed 's/^/| /' conftest.$ac_ext >&5
7660 >
7661 > fi
7662 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7663 >   done
7664 >
7665 > fi
7666 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7667 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7668 > case $ac_cv_c_restrict in
7669 >   restrict) ;;
7670 >   no)
7671 > cat >>confdefs.h <<\_ACEOF
7672 > #define restrict
7673 > _ACEOF
7674 > ;;
7675 >   *)  cat >>confdefs.h <<_ACEOF
7676 > #define restrict $ac_cv_c_restrict
7677 > _ACEOF
7678 > ;;
7679 > esac
7680 >
7681 > echo "$as_me:$LINENO: checking for size_t" >&5
7682 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7683 > if test "${ac_cv_type_size_t+set}" = set; then
7684 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7685 > else
7686 >  cat >conftest.$ac_ext <<_ACEOF
7687 > /* confdefs.h.  */
7688 > _ACEOF
7689 > cat confdefs.h >>conftest.$ac_ext
7690 > cat >>conftest.$ac_ext <<_ACEOF
7691 > /* end confdefs.h.  */
7692 > $ac_includes_default
7693 > #ifdef FC_DUMMY_MAIN
7694 > #ifndef FC_DUMMY_MAIN_EQ_F77
7695 > #  ifdef __cplusplus
7696 >     extern "C"
7697 > #  endif
7698 >   int FC_DUMMY_MAIN() { return 1; }
7699 > #endif
7700 > #endif
7701 > int
7702 > main ()
7703 > {
7704 > if ((size_t *) 0)
7705 >  return 0;
7706 > if (sizeof (size_t))
7707 >  return 0;
7708 >  ;
7709 >  return 0;
7710 > }
7711 > _ACEOF
7712 > rm -f conftest.$ac_objext
7713 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7714 >  (eval $ac_compile) 2>conftest.er1
7715 >  ac_status=$?
7716 >  grep -v '^ *+' conftest.er1 >conftest.err
7717 >  rm -f conftest.er1
7718 >  cat conftest.err >&5
7719 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720 >  (exit $ac_status); } &&
7721 >         { ac_try='test -z "$ac_c_werror_flag"
7722 >                         || test ! -s conftest.err'
7723 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7724 >  (eval $ac_try) 2>&5
7725 >  ac_status=$?
7726 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7727 >  (exit $ac_status); }; } &&
7728 >         { ac_try='test -s conftest.$ac_objext'
7729 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7730 >  (eval $ac_try) 2>&5
7731 >  ac_status=$?
7732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7733 >  (exit $ac_status); }; }; then
7734 >  ac_cv_type_size_t=yes
7735 > else
7736 >  echo "$as_me: failed program was:" >&5
7737 > sed 's/^/| /' conftest.$ac_ext >&5
7738 >
7739 > ac_cv_type_size_t=no
7740 > fi
7741 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7742 > fi
7743 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7744 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7745 > if test $ac_cv_type_size_t = yes; then
7746 >  :
7747 > else
7748 >
7749 > cat >>confdefs.h <<_ACEOF
7750 > #define size_t unsigned
7751 > _ACEOF
7752 >
7753 > fi
7754 >
7755 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7756 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7757 > if test "${ac_cv_header_time+set}" = set; then
7758 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7759 > else
7760 >  cat >conftest.$ac_ext <<_ACEOF
7761 > /* confdefs.h.  */
7762 > _ACEOF
7763 > cat confdefs.h >>conftest.$ac_ext
7764 > cat >>conftest.$ac_ext <<_ACEOF
7765 > /* end confdefs.h.  */
7766 > #include <sys/types.h>
7767 > #include <sys/time.h>
7768 > #include <time.h>
7769 >
7770 > #ifdef FC_DUMMY_MAIN
7771 > #ifndef FC_DUMMY_MAIN_EQ_F77
7772 > #  ifdef __cplusplus
7773 >     extern "C"
7774 > #  endif
7775 >   int FC_DUMMY_MAIN() { return 1; }
7776 > #endif
7777 > #endif
7778 > int
7779 > main ()
7780 > {
7781 > if ((struct tm *) 0)
7782 > return 0;
7783 >  ;
7784 >  return 0;
7785 > }
7786 > _ACEOF
7787 > rm -f conftest.$ac_objext
7788 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7789 >  (eval $ac_compile) 2>conftest.er1
7790 >  ac_status=$?
7791 >  grep -v '^ *+' conftest.er1 >conftest.err
7792 >  rm -f conftest.er1
7793 >  cat conftest.err >&5
7794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7795 >  (exit $ac_status); } &&
7796 >         { ac_try='test -z "$ac_c_werror_flag"
7797 >                         || test ! -s conftest.err'
7798 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7799 >  (eval $ac_try) 2>&5
7800 >  ac_status=$?
7801 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7802 >  (exit $ac_status); }; } &&
7803 >         { ac_try='test -s conftest.$ac_objext'
7804 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7805 >  (eval $ac_try) 2>&5
7806 >  ac_status=$?
7807 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7808 >  (exit $ac_status); }; }; then
7809 >  ac_cv_header_time=yes
7810 > else
7811 >  echo "$as_me: failed program was:" >&5
7812 > sed 's/^/| /' conftest.$ac_ext >&5
7813 >
7814 > ac_cv_header_time=no
7815 > fi
7816 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7817 > fi
7818 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7819 > echo "${ECHO_T}$ac_cv_header_time" >&6
7820 > if test $ac_cv_header_time = yes; then
7821 >
7822 > cat >>confdefs.h <<\_ACEOF
7823 > #define TIME_WITH_SYS_TIME 1
7824 > _ACEOF
7825 >
7826 > fi
7827 >
7828 > echo "$as_me:$LINENO: checking for clock_t" >&5
7829 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7830 > if test "${ac_cv_type_clock_t+set}" = set; then
7831 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7832 > else
7833 >  cat >conftest.$ac_ext <<_ACEOF
7834 > /* confdefs.h.  */
7835 > _ACEOF
7836 > cat confdefs.h >>conftest.$ac_ext
7837 > cat >>conftest.$ac_ext <<_ACEOF
7838 > /* end confdefs.h.  */
7839 > $ac_includes_default
7840 > #ifdef FC_DUMMY_MAIN
7841 > #ifndef FC_DUMMY_MAIN_EQ_F77
7842 > #  ifdef __cplusplus
7843 >     extern "C"
7844 > #  endif
7845 >   int FC_DUMMY_MAIN() { return 1; }
7846 > #endif
7847 > #endif
7848 > int
7849 > main ()
7850 > {
7851 > if ((clock_t *) 0)
7852 >  return 0;
7853 > if (sizeof (clock_t))
7854 >  return 0;
7855 >  ;
7856 >  return 0;
7857 > }
7858 > _ACEOF
7859 > rm -f conftest.$ac_objext
7860 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7861 >  (eval $ac_compile) 2>conftest.er1
7862 >  ac_status=$?
7863 >  grep -v '^ *+' conftest.er1 >conftest.err
7864 >  rm -f conftest.er1
7865 >  cat conftest.err >&5
7866 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7867 >  (exit $ac_status); } &&
7868 >         { ac_try='test -z "$ac_c_werror_flag"
7869 >                         || test ! -s conftest.err'
7870 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7871 >  (eval $ac_try) 2>&5
7872 >  ac_status=$?
7873 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7874 >  (exit $ac_status); }; } &&
7875 >         { ac_try='test -s conftest.$ac_objext'
7876 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7877 >  (eval $ac_try) 2>&5
7878 >  ac_status=$?
7879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7880 >  (exit $ac_status); }; }; then
7881 >  ac_cv_type_clock_t=yes
7882 > else
7883 >  echo "$as_me: failed program was:" >&5
7884 > sed 's/^/| /' conftest.$ac_ext >&5
7885 >
7886 > ac_cv_type_clock_t=no
7887 > fi
7888 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7889 > fi
7890 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7891 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7892 > if test $ac_cv_type_clock_t = yes; then
7893 >
7894 > cat >>confdefs.h <<_ACEOF
7895 > #define HAVE_CLOCK_T 1
7896 > _ACEOF
7897 >
7898 >
7899 > fi
7900 >
7901 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7902 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7903 > if test "${ac_cv_c_const+set}" = set; then
7904 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7905 > else
7906 >  cat >conftest.$ac_ext <<_ACEOF
7907 > /* confdefs.h.  */
7908 > _ACEOF
7909 > cat confdefs.h >>conftest.$ac_ext
7910 > cat >>conftest.$ac_ext <<_ACEOF
7911 > /* end confdefs.h.  */
7912 >
7913 > #ifdef FC_DUMMY_MAIN
7914 > #ifndef FC_DUMMY_MAIN_EQ_F77
7915 > #  ifdef __cplusplus
7916 >     extern "C"
7917 > #  endif
7918 >   int FC_DUMMY_MAIN() { return 1; }
7919 > #endif
7920 > #endif
7921 > int
7922 > main ()
7923 > {
7924 > /* FIXME: Include the comments suggested by Paul. */
7925 > #ifndef __cplusplus
7926 >  /* Ultrix mips cc rejects this.  */
7927 >  typedef int charset[2];
7928 >  const charset x;
7929 >  /* SunOS 4.1.1 cc rejects this.  */
7930 >  char const *const *ccp;
7931 >  char **p;
7932 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7933 >  struct point {int x, y;};
7934 >  static struct point const zero = {0,0};
7935 >  /* AIX XL C 1.02.0.0 rejects this.
7936 >     It does not let you subtract one const X* pointer from another in
7937 >     an arm of an if-expression whose if-part is not a constant
7938 >     expression */
7939 >  const char *g = "string";
7940 >  ccp = &g + (g ? g-g : 0);
7941 >  /* HPUX 7.0 cc rejects these. */
7942 >  ++ccp;
7943 >  p = (char**) ccp;
7944 >  ccp = (char const *const *) p;
7945 >  { /* SCO 3.2v4 cc rejects this.  */
7946 >    char *t;
7947 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7948 >
7949 >    *t++ = 0;
7950 >  }
7951 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7952 >    int x[] = {25, 17};
7953 >    const int *foo = &x[0];
7954 >    ++foo;
7955 >  }
7956 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7957 >    typedef const int *iptr;
7958 >    iptr p = 0;
7959 >    ++p;
7960 >  }
7961 >  { /* AIX XL C 1.02.0.0 rejects this saying
7962 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7963 >    struct s { int j; const int *ap[3]; };
7964 >    struct s *b; b->j = 5;
7965 >  }
7966 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7967 >    const int foo = 10;
7968 >  }
7969 > #endif
7970 >
7971 >  ;
7972 >  return 0;
7973 > }
7974 > _ACEOF
7975 > rm -f conftest.$ac_objext
7976 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7977 >  (eval $ac_compile) 2>conftest.er1
7978 >  ac_status=$?
7979 >  grep -v '^ *+' conftest.er1 >conftest.err
7980 >  rm -f conftest.er1
7981 >  cat conftest.err >&5
7982 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7983 >  (exit $ac_status); } &&
7984 >         { ac_try='test -z "$ac_c_werror_flag"
7985 >                         || test ! -s conftest.err'
7986 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7987 >  (eval $ac_try) 2>&5
7988 >  ac_status=$?
7989 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7990 >  (exit $ac_status); }; } &&
7991 >         { ac_try='test -s conftest.$ac_objext'
7992 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7993 >  (eval $ac_try) 2>&5
7994 >  ac_status=$?
7995 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7996 >  (exit $ac_status); }; }; then
7997 >  ac_cv_c_const=yes
7998 > else
7999 >  echo "$as_me: failed program was:" >&5
8000 > sed 's/^/| /' conftest.$ac_ext >&5
8001 >
8002 > ac_cv_c_const=no
8003 > fi
8004 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8005 > fi
8006 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8007 > echo "${ECHO_T}$ac_cv_c_const" >&6
8008 > if test $ac_cv_c_const = no; then
8009 >
8010 > cat >>confdefs.h <<\_ACEOF
8011 > #define const
8012 > _ACEOF
8013 >
8014 > fi
8015 >
8016 > echo "$as_me:$LINENO: checking for inline" >&5
8017 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8018 > if test "${ac_cv_c_inline+set}" = set; then
8019 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8020 > else
8021 >  ac_cv_c_inline=no
8022 > for ac_kw in inline __inline__ __inline; do
8023 >  cat >conftest.$ac_ext <<_ACEOF
8024 > /* confdefs.h.  */
8025 > _ACEOF
8026 > cat confdefs.h >>conftest.$ac_ext
8027 > cat >>conftest.$ac_ext <<_ACEOF
8028 > /* end confdefs.h.  */
8029 > #ifndef __cplusplus
8030 > typedef int foo_t;
8031 > static $ac_kw foo_t static_foo () {return 0; }
8032 > $ac_kw foo_t foo () {return 0; }
8033 > #endif
8034 >
8035 > _ACEOF
8036 > rm -f conftest.$ac_objext
8037 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8038 >  (eval $ac_compile) 2>conftest.er1
8039 >  ac_status=$?
8040 >  grep -v '^ *+' conftest.er1 >conftest.err
8041 >  rm -f conftest.er1
8042 >  cat conftest.err >&5
8043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8044 >  (exit $ac_status); } &&
8045 >         { ac_try='test -z "$ac_c_werror_flag"
8046 >                         || test ! -s conftest.err'
8047 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8048 >  (eval $ac_try) 2>&5
8049 >  ac_status=$?
8050 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8051 >  (exit $ac_status); }; } &&
8052 >         { ac_try='test -s conftest.$ac_objext'
8053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8054 >  (eval $ac_try) 2>&5
8055 >  ac_status=$?
8056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8057 >  (exit $ac_status); }; }; then
8058 >  ac_cv_c_inline=$ac_kw; break
8059 > else
8060 >  echo "$as_me: failed program was:" >&5
8061 > sed 's/^/| /' conftest.$ac_ext >&5
8062 >
8063 > fi
8064 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8065 > done
8066 >
8067 > fi
8068 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8069 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8070 >
8071 >
8072 > case $ac_cv_c_inline in
8073 >  inline | yes) ;;
8074 >  *)
8075 >    case $ac_cv_c_inline in
8076 >      no) ac_val=;;
8077 >      *) ac_val=$ac_cv_c_inline;;
8078 >    esac
8079 >    cat >>confdefs.h <<_ACEOF
8080 > #ifndef __cplusplus
8081 > #define inline $ac_val
8082 > #endif
8083 > _ACEOF
8084 >    ;;
8085 > esac
8086 >
8087 >
8088 > # Checks for library functions.
8089 >
8090 > for ac_header in stdlib.h
8091 > do
8092 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8093 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8094 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8095 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8096 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8097 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8098 > fi
8099 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8100 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8101 > else
8102 >  # Is the header compilable?
8103 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8104 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8105 > cat >conftest.$ac_ext <<_ACEOF
8106 > /* confdefs.h.  */
8107 > _ACEOF
8108 > cat confdefs.h >>conftest.$ac_ext
8109 > cat >>conftest.$ac_ext <<_ACEOF
8110 > /* end confdefs.h.  */
8111 > $ac_includes_default
8112 > #include <$ac_header>
8113 > _ACEOF
8114 > rm -f conftest.$ac_objext
8115 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8116 >  (eval $ac_compile) 2>conftest.er1
8117 >  ac_status=$?
8118 >  grep -v '^ *+' conftest.er1 >conftest.err
8119 >  rm -f conftest.er1
8120 >  cat conftest.err >&5
8121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122 >  (exit $ac_status); } &&
8123 >         { ac_try='test -z "$ac_c_werror_flag"
8124 >                         || test ! -s conftest.err'
8125 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8126 >  (eval $ac_try) 2>&5
8127 >  ac_status=$?
8128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8129 >  (exit $ac_status); }; } &&
8130 >         { ac_try='test -s conftest.$ac_objext'
8131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8132 >  (eval $ac_try) 2>&5
8133 >  ac_status=$?
8134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8135 >  (exit $ac_status); }; }; then
8136 >  ac_header_compiler=yes
8137 > else
8138 >  echo "$as_me: failed program was:" >&5
8139 > sed 's/^/| /' conftest.$ac_ext >&5
8140 >
8141 > ac_header_compiler=no
8142 > fi
8143 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8144 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8145 > echo "${ECHO_T}$ac_header_compiler" >&6
8146 >
8147 > # Is the header present?
8148 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8149 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8150 > cat >conftest.$ac_ext <<_ACEOF
8151 > /* confdefs.h.  */
8152 > _ACEOF
8153 > cat confdefs.h >>conftest.$ac_ext
8154 > cat >>conftest.$ac_ext <<_ACEOF
8155 > /* end confdefs.h.  */
8156 > #include <$ac_header>
8157 > _ACEOF
8158 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8159 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8160 >  ac_status=$?
8161 >  grep -v '^ *+' conftest.er1 >conftest.err
8162 >  rm -f conftest.er1
8163 >  cat conftest.err >&5
8164 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8165 >  (exit $ac_status); } >/dev/null; then
8166 >  if test -s conftest.err; then
8167 >    ac_cpp_err=$ac_c_preproc_warn_flag
8168 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8169 >  else
8170 >    ac_cpp_err=
8171 >  fi
8172 > else
8173 >  ac_cpp_err=yes
8174 > fi
8175 > if test -z "$ac_cpp_err"; then
8176 >  ac_header_preproc=yes
8177 > else
8178 >  echo "$as_me: failed program was:" >&5
8179 > sed 's/^/| /' conftest.$ac_ext >&5
8180 >
8181 >  ac_header_preproc=no
8182 > fi
8183 > rm -f conftest.err conftest.$ac_ext
8184 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8185 > echo "${ECHO_T}$ac_header_preproc" >&6
8186 >
8187 > # So?  What about this header?
8188 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8189 >  yes:no: )
8190 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8191 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8192 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8193 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8194 >    ac_header_preproc=yes
8195 >    ;;
8196 >  no:yes:* )
8197 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8198 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8199 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8200 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8201 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8202 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8203 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8204 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8205 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8206 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8207 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8208 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8209 >    (
8210 >      cat <<\_ASBOX
8211 > ## ------------------------------ ##
8212 > ## Report this to gezelter@nd.edu ##
8213 > ## ------------------------------ ##
8214 > _ASBOX
8215 >    ) |
8216 >      sed "s/^/$as_me: WARNING:     /" >&2
8217 >    ;;
8218 > esac
8219 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8220 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8221 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8222 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8223 > else
8224 >  eval "$as_ac_Header=\$ac_header_preproc"
8225 > fi
8226 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8227 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8228 >
8229 > fi
8230 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8231 >  cat >>confdefs.h <<_ACEOF
8232 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8233 > _ACEOF
8234 >
8235 > fi
8236 >
8237 > done
8238 >
8239 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8240 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8241 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8242 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8243 > else
8244 >  if test "$cross_compiling" = yes; then
8245 >  ac_cv_func_malloc_0_nonnull=no
8246 > else
8247 >  cat >conftest.$ac_ext <<_ACEOF
8248 > /* confdefs.h.  */
8249 > _ACEOF
8250 > cat confdefs.h >>conftest.$ac_ext
8251 > cat >>conftest.$ac_ext <<_ACEOF
8252 > /* end confdefs.h.  */
8253 > #if STDC_HEADERS || HAVE_STDLIB_H
8254 > # include <stdlib.h>
8255 > #else
8256 > char *malloc ();
8257 > #endif
8258 >
8259 > #ifdef FC_DUMMY_MAIN
8260 > #ifndef FC_DUMMY_MAIN_EQ_F77
8261 > #  ifdef __cplusplus
8262 >     extern "C"
8263 > #  endif
8264 >   int FC_DUMMY_MAIN() { return 1; }
8265 > #endif
8266 > #endif
8267 > int
8268 > main ()
8269 > {
8270 > exit (malloc (0) ? 0 : 1);
8271 >  ;
8272 >  return 0;
8273 > }
8274 > _ACEOF
8275 > rm -f conftest$ac_exeext
8276 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8277 >  (eval $ac_link) 2>&5
8278 >  ac_status=$?
8279 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8280 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8281 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8282 >  (eval $ac_try) 2>&5
8283 >  ac_status=$?
8284 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8285 >  (exit $ac_status); }; }; then
8286 >  ac_cv_func_malloc_0_nonnull=yes
8287 > else
8288 >  echo "$as_me: program exited with status $ac_status" >&5
8289 > echo "$as_me: failed program was:" >&5
8290 > sed 's/^/| /' conftest.$ac_ext >&5
8291 >
8292 > ( exit $ac_status )
8293 > ac_cv_func_malloc_0_nonnull=no
8294 > fi
8295 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8296 > fi
8297 > fi
8298 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8299 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8300 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8301 >
8302 > cat >>confdefs.h <<\_ACEOF
8303 > #define HAVE_MALLOC 1
8304 > _ACEOF
8305 >
8306 > else
8307 >  cat >>confdefs.h <<\_ACEOF
8308 > #define HAVE_MALLOC 0
8309 > _ACEOF
8310 >
8311 >   case $LIBOBJS in
8312 >    "malloc.$ac_objext"   | \
8313 >  *" malloc.$ac_objext"   | \
8314 >    "malloc.$ac_objext "* | \
8315 >  *" malloc.$ac_objext "* ) ;;
8316 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8317 > esac
8318 >
8319 >
8320 > cat >>confdefs.h <<\_ACEOF
8321 > #define malloc rpl_malloc
8322 > _ACEOF
8323 >
8324 > fi
8325 >
8326 >
8327 >
8328 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8329 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8330 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8331 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8332 > else
8333 >  if test "$cross_compiling" = yes; then
8334 >  ac_cv_func_memcmp_working=no
8335 > else
8336 >  cat >conftest.$ac_ext <<_ACEOF
8337 > /* confdefs.h.  */
8338 > _ACEOF
8339 > cat confdefs.h >>conftest.$ac_ext
8340 > cat >>conftest.$ac_ext <<_ACEOF
8341 > /* end confdefs.h.  */
8342 > $ac_includes_default
8343 > #ifdef FC_DUMMY_MAIN
8344 > #ifndef FC_DUMMY_MAIN_EQ_F77
8345 > #  ifdef __cplusplus
8346 >     extern "C"
8347 > #  endif
8348 >   int FC_DUMMY_MAIN() { return 1; }
8349 > #endif
8350 > #endif
8351 > int
8352 > main ()
8353 > {
8354 >
8355 >  /* Some versions of memcmp are not 8-bit clean.  */
8356 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8357 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8358 >    exit (1);
8359 >
8360 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8361 >     or more and with at least one buffer not starting on a 4-byte boundary.
8362 >     William Lewis provided this test program.   */
8363 >  {
8364 >    char foo[21];
8365 >    char bar[21];
8366 >    int i;
8367 >    for (i = 0; i < 4; i++)
8368 >      {
8369 >        char *a = foo + i;
8370 >        char *b = bar + i;
8371 >        strcpy (a, "--------01111111");
8372 >        strcpy (b, "--------10000000");
8373 >        if (memcmp (a, b, 16) >= 0)
8374 >          exit (1);
8375 >      }
8376 >    exit (0);
8377 >  }
8378 >
8379 >  ;
8380 >  return 0;
8381 > }
8382 > _ACEOF
8383 > rm -f conftest$ac_exeext
8384 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8385 >  (eval $ac_link) 2>&5
8386 >  ac_status=$?
8387 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8388 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8389 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8390 >  (eval $ac_try) 2>&5
8391 >  ac_status=$?
8392 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8393 >  (exit $ac_status); }; }; then
8394 >  ac_cv_func_memcmp_working=yes
8395 > else
8396 >  echo "$as_me: program exited with status $ac_status" >&5
8397 > echo "$as_me: failed program was:" >&5
8398 > sed 's/^/| /' conftest.$ac_ext >&5
8399 >
8400 > ( exit $ac_status )
8401 > ac_cv_func_memcmp_working=no
8402 > fi
8403 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8404 > fi
8405 > fi
8406 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8407 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8408 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8409 >    "memcmp.$ac_objext"   | \
8410 >  *" memcmp.$ac_objext"   | \
8411 >    "memcmp.$ac_objext "* | \
8412 >  *" memcmp.$ac_objext "* ) ;;
8413 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8414 > esac
8415 >
8416 >
8417 >
8418 > for ac_header in stdlib.h
8419 > do
8420 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8421 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8422 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8423 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8424 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8425 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8426 > fi
8427 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8428 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8429 > else
8430 >  # Is the header compilable?
8431 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8432 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8433 > cat >conftest.$ac_ext <<_ACEOF
8434 > /* confdefs.h.  */
8435 > _ACEOF
8436 > cat confdefs.h >>conftest.$ac_ext
8437 > cat >>conftest.$ac_ext <<_ACEOF
8438 > /* end confdefs.h.  */
8439 > $ac_includes_default
8440 > #include <$ac_header>
8441 > _ACEOF
8442 > rm -f conftest.$ac_objext
8443 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8444 >  (eval $ac_compile) 2>conftest.er1
8445 >  ac_status=$?
8446 >  grep -v '^ *+' conftest.er1 >conftest.err
8447 >  rm -f conftest.er1
8448 >  cat conftest.err >&5
8449 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8450 >  (exit $ac_status); } &&
8451 >         { ac_try='test -z "$ac_c_werror_flag"
8452 >                         || test ! -s conftest.err'
8453 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8454 >  (eval $ac_try) 2>&5
8455 >  ac_status=$?
8456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8457 >  (exit $ac_status); }; } &&
8458 >         { ac_try='test -s conftest.$ac_objext'
8459 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8460 >  (eval $ac_try) 2>&5
8461 >  ac_status=$?
8462 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8463 >  (exit $ac_status); }; }; then
8464 >  ac_header_compiler=yes
8465 > else
8466 >  echo "$as_me: failed program was:" >&5
8467 > sed 's/^/| /' conftest.$ac_ext >&5
8468 >
8469 > ac_header_compiler=no
8470 > fi
8471 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8472 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8473 > echo "${ECHO_T}$ac_header_compiler" >&6
8474 >
8475 > # Is the header present?
8476 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8477 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 > #include <$ac_header>
8485 > _ACEOF
8486 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8487 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8488 >  ac_status=$?
8489 >  grep -v '^ *+' conftest.er1 >conftest.err
8490 >  rm -f conftest.er1
8491 >  cat conftest.err >&5
8492 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8493 >  (exit $ac_status); } >/dev/null; then
8494 >  if test -s conftest.err; then
8495 >    ac_cpp_err=$ac_c_preproc_warn_flag
8496 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8497 >  else
8498 >    ac_cpp_err=
8499 >  fi
8500 > else
8501 >  ac_cpp_err=yes
8502 > fi
8503 > if test -z "$ac_cpp_err"; then
8504 >  ac_header_preproc=yes
8505 > else
8506 >  echo "$as_me: failed program was:" >&5
8507 > sed 's/^/| /' conftest.$ac_ext >&5
8508 >
8509 >  ac_header_preproc=no
8510 > fi
8511 > rm -f conftest.err conftest.$ac_ext
8512 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8513 > echo "${ECHO_T}$ac_header_preproc" >&6
8514 >
8515 > # So?  What about this header?
8516 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8517 >  yes:no: )
8518 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8519 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8520 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8521 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8522 >    ac_header_preproc=yes
8523 >    ;;
8524 >  no:yes:* )
8525 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8526 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8527 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8528 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8529 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8530 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8531 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8532 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8533 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8534 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8535 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8536 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8537 >    (
8538 >      cat <<\_ASBOX
8539 > ## ------------------------------ ##
8540 > ## Report this to gezelter@nd.edu ##
8541 > ## ------------------------------ ##
8542 > _ASBOX
8543 >    ) |
8544 >      sed "s/^/$as_me: WARNING:     /" >&2
8545 >    ;;
8546 > esac
8547 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8548 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8549 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8550 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8551 > else
8552 >  eval "$as_ac_Header=\$ac_header_preproc"
8553 > fi
8554 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8555 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8556 >
8557 > fi
8558 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8559 >  cat >>confdefs.h <<_ACEOF
8560 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8561 > _ACEOF
8562 >
8563 > fi
8564 >
8565 > done
8566 >
8567 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8568 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8569 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8570 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8571 > else
8572 >  if test "$cross_compiling" = yes; then
8573 >  ac_cv_func_realloc_0_nonnull=no
8574 > else
8575 >  cat >conftest.$ac_ext <<_ACEOF
8576 > /* confdefs.h.  */
8577 > _ACEOF
8578 > cat confdefs.h >>conftest.$ac_ext
8579 > cat >>conftest.$ac_ext <<_ACEOF
8580 > /* end confdefs.h.  */
8581 > #if STDC_HEADERS || HAVE_STDLIB_H
8582 > # include <stdlib.h>
8583 > #else
8584 > char *realloc ();
8585 > #endif
8586 >
8587 > #ifdef FC_DUMMY_MAIN
8588 > #ifndef FC_DUMMY_MAIN_EQ_F77
8589 > #  ifdef __cplusplus
8590 >     extern "C"
8591 > #  endif
8592 >   int FC_DUMMY_MAIN() { return 1; }
8593 > #endif
8594 > #endif
8595 > int
8596 > main ()
8597 > {
8598 > exit (realloc (0, 0) ? 0 : 1);
8599 >  ;
8600 >  return 0;
8601 > }
8602 > _ACEOF
8603 > rm -f conftest$ac_exeext
8604 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8605 >  (eval $ac_link) 2>&5
8606 >  ac_status=$?
8607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8608 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8610 >  (eval $ac_try) 2>&5
8611 >  ac_status=$?
8612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8613 >  (exit $ac_status); }; }; then
8614 >  ac_cv_func_realloc_0_nonnull=yes
8615 > else
8616 >  echo "$as_me: program exited with status $ac_status" >&5
8617 > echo "$as_me: failed program was:" >&5
8618 > sed 's/^/| /' conftest.$ac_ext >&5
8619 >
8620 > ( exit $ac_status )
8621 > ac_cv_func_realloc_0_nonnull=no
8622 > fi
8623 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8624 > fi
8625 > fi
8626 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8627 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8628 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8629 >
8630 > cat >>confdefs.h <<\_ACEOF
8631 > #define HAVE_REALLOC 1
8632 > _ACEOF
8633 >
8634 > else
8635 >  cat >>confdefs.h <<\_ACEOF
8636 > #define HAVE_REALLOC 0
8637 > _ACEOF
8638 >
8639 >   case $LIBOBJS in
8640 >    "realloc.$ac_objext"   | \
8641 >  *" realloc.$ac_objext"   | \
8642 >    "realloc.$ac_objext "* | \
8643 >  *" realloc.$ac_objext "* ) ;;
8644 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8645 > esac
8646 >
8647 >
8648 > cat >>confdefs.h <<\_ACEOF
8649 > #define realloc rpl_realloc
8650 > _ACEOF
8651 >
8652 > fi
8653 >
8654 >
8655 >
8656 >
8657 >
8658 > for ac_header in sys/select.h sys/socket.h
8659 > do
8660 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8661 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8662 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8663 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8664 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8665 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8666 > fi
8667 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8668 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8669 > else
8670 >  # Is the header compilable?
8671 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8672 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8673 > cat >conftest.$ac_ext <<_ACEOF
8674 > /* confdefs.h.  */
8675 > _ACEOF
8676 > cat confdefs.h >>conftest.$ac_ext
8677 > cat >>conftest.$ac_ext <<_ACEOF
8678 > /* end confdefs.h.  */
8679 > $ac_includes_default
8680 > #include <$ac_header>
8681 > _ACEOF
8682 > rm -f conftest.$ac_objext
8683 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8684 >  (eval $ac_compile) 2>conftest.er1
8685 >  ac_status=$?
8686 >  grep -v '^ *+' conftest.er1 >conftest.err
8687 >  rm -f conftest.er1
8688 >  cat conftest.err >&5
8689 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8690 >  (exit $ac_status); } &&
8691 >         { ac_try='test -z "$ac_c_werror_flag"
8692 >                         || test ! -s conftest.err'
8693 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8694 >  (eval $ac_try) 2>&5
8695 >  ac_status=$?
8696 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8697 >  (exit $ac_status); }; } &&
8698 >         { ac_try='test -s conftest.$ac_objext'
8699 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8700 >  (eval $ac_try) 2>&5
8701 >  ac_status=$?
8702 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8703 >  (exit $ac_status); }; }; then
8704 >  ac_header_compiler=yes
8705 > else
8706 >  echo "$as_me: failed program was:" >&5
8707 > sed 's/^/| /' conftest.$ac_ext >&5
8708 >
8709 > ac_header_compiler=no
8710 > fi
8711 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8712 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8713 > echo "${ECHO_T}$ac_header_compiler" >&6
8714 >
8715 > # Is the header present?
8716 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8717 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8718 > cat >conftest.$ac_ext <<_ACEOF
8719 > /* confdefs.h.  */
8720 > _ACEOF
8721 > cat confdefs.h >>conftest.$ac_ext
8722 > cat >>conftest.$ac_ext <<_ACEOF
8723 > /* end confdefs.h.  */
8724 > #include <$ac_header>
8725 > _ACEOF
8726 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8727 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8728 >  ac_status=$?
8729 >  grep -v '^ *+' conftest.er1 >conftest.err
8730 >  rm -f conftest.er1
8731 >  cat conftest.err >&5
8732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8733 >  (exit $ac_status); } >/dev/null; then
8734 >  if test -s conftest.err; then
8735 >    ac_cpp_err=$ac_c_preproc_warn_flag
8736 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8737 >  else
8738 >    ac_cpp_err=
8739 >  fi
8740 > else
8741 >  ac_cpp_err=yes
8742 > fi
8743 > if test -z "$ac_cpp_err"; then
8744 >  ac_header_preproc=yes
8745 > else
8746 >  echo "$as_me: failed program was:" >&5
8747 > sed 's/^/| /' conftest.$ac_ext >&5
8748 >
8749 >  ac_header_preproc=no
8750 > fi
8751 > rm -f conftest.err conftest.$ac_ext
8752 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8753 > echo "${ECHO_T}$ac_header_preproc" >&6
8754 >
8755 > # So?  What about this header?
8756 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8757 >  yes:no: )
8758 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8759 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8760 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8761 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8762 >    ac_header_preproc=yes
8763 >    ;;
8764 >  no:yes:* )
8765 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8766 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8767 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8768 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8769 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8770 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8771 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8772 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8773 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8774 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8775 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8776 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8777 >    (
8778 >      cat <<\_ASBOX
8779 > ## ------------------------------ ##
8780 > ## Report this to gezelter@nd.edu ##
8781 > ## ------------------------------ ##
8782 > _ASBOX
8783 >    ) |
8784 >      sed "s/^/$as_me: WARNING:     /" >&2
8785 >    ;;
8786 > esac
8787 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8788 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8789 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8790 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8791 > else
8792 >  eval "$as_ac_Header=\$ac_header_preproc"
8793 > fi
8794 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8795 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8796 >
8797 > fi
8798 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8799 >  cat >>confdefs.h <<_ACEOF
8800 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8801 > _ACEOF
8802 >
8803 > fi
8804 >
8805 > done
8806 >
8807 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8808 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8809 > if test "${ac_cv_func_select_args+set}" = set; then
8810 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8811 > else
8812 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8813 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8814 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8815 >   cat >conftest.$ac_ext <<_ACEOF
8816 > /* confdefs.h.  */
8817 > _ACEOF
8818 > cat confdefs.h >>conftest.$ac_ext
8819 > cat >>conftest.$ac_ext <<_ACEOF
8820 > /* end confdefs.h.  */
8821 > $ac_includes_default
8822 > #if HAVE_SYS_SELECT_H
8823 > # include <sys/select.h>
8824 > #endif
8825 > #if HAVE_SYS_SOCKET_H
8826 > # include <sys/socket.h>
8827 > #endif
8828 >
8829 > #ifdef FC_DUMMY_MAIN
8830 > #ifndef FC_DUMMY_MAIN_EQ_F77
8831 > #  ifdef __cplusplus
8832 >     extern "C"
8833 > #  endif
8834 >   int FC_DUMMY_MAIN() { return 1; }
8835 > #endif
8836 > #endif
8837 > int
8838 > main ()
8839 > {
8840 > extern int select ($ac_arg1,
8841 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8842 >                                            $ac_arg5);
8843 >  ;
8844 >  return 0;
8845 > }
8846 > _ACEOF
8847 > rm -f conftest.$ac_objext
8848 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8849 >  (eval $ac_compile) 2>conftest.er1
8850 >  ac_status=$?
8851 >  grep -v '^ *+' conftest.er1 >conftest.err
8852 >  rm -f conftest.er1
8853 >  cat conftest.err >&5
8854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8855 >  (exit $ac_status); } &&
8856 >         { ac_try='test -z "$ac_c_werror_flag"
8857 >                         || test ! -s conftest.err'
8858 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8859 >  (eval $ac_try) 2>&5
8860 >  ac_status=$?
8861 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8862 >  (exit $ac_status); }; } &&
8863 >         { ac_try='test -s conftest.$ac_objext'
8864 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8865 >  (eval $ac_try) 2>&5
8866 >  ac_status=$?
8867 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8868 >  (exit $ac_status); }; }; then
8869 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8870 > else
8871 >  echo "$as_me: failed program was:" >&5
8872 > sed 's/^/| /' conftest.$ac_ext >&5
8873 >
8874 > fi
8875 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8876 >  done
8877 > done
8878 > done
8879 > # Provide a safe default value.
8880 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8881 >
8882 > fi
8883 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8884 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8885 > ac_save_IFS=$IFS; IFS=','
8886 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8887 > IFS=$ac_save_IFS
8888 > shift
8889 >
8890 > cat >>confdefs.h <<_ACEOF
8891 > #define SELECT_TYPE_ARG1 $1
8892 > _ACEOF
8893 >
8894 >
8895 > cat >>confdefs.h <<_ACEOF
8896 > #define SELECT_TYPE_ARG234 ($2)
8897 > _ACEOF
8898 >
8899 >
8900 > cat >>confdefs.h <<_ACEOF
8901 > #define SELECT_TYPE_ARG5 ($3)
8902 > _ACEOF
8903 >
8904 > rm -f conftest*
8905 >
8906 >
8907 > for ac_func in strftime
8908 > do
8909 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8910 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8911 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8912 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8913 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8914 > else
8915 >  cat >conftest.$ac_ext <<_ACEOF
8916 > /* confdefs.h.  */
8917 > _ACEOF
8918 > cat confdefs.h >>conftest.$ac_ext
8919 > cat >>conftest.$ac_ext <<_ACEOF
8920 > /* end confdefs.h.  */
8921 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8922 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8923 > #define $ac_func innocuous_$ac_func
8924 >
8925 > /* System header to define __stub macros and hopefully few prototypes,
8926 >    which can conflict with char $ac_func (); below.
8927 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8928 >    <limits.h> exists even on freestanding compilers.  */
8929 >
8930 > #ifdef __STDC__
8931 > # include <limits.h>
8932 > #else
8933 > # include <assert.h>
8934 > #endif
8935 >
8936 > #undef $ac_func
8937 >
8938 > /* Override any gcc2 internal prototype to avoid an error.  */
8939 > #ifdef __cplusplus
8940 > extern "C"
8941 > {
8942 > #endif
8943 > /* We use char because int might match the return type of a gcc2
8944 >   builtin and then its argument prototype would still apply.  */
8945 > char $ac_func ();
8946 > /* The GNU C library defines this for functions which it implements
8947 >    to always fail with ENOSYS.  Some functions are actually named
8948 >    something starting with __ and the normal name is an alias.  */
8949 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8950 > choke me
8951 > #else
8952 > char (*f) () = $ac_func;
8953 > #endif
8954 > #ifdef __cplusplus
8955 > }
8956 > #endif
8957 >
8958 > #ifdef FC_DUMMY_MAIN
8959 > #ifndef FC_DUMMY_MAIN_EQ_F77
8960 > #  ifdef __cplusplus
8961 >     extern "C"
8962 > #  endif
8963 >   int FC_DUMMY_MAIN() { return 1; }
8964 > #endif
8965 > #endif
8966 > int
8967 > main ()
8968 > {
8969 > return f != $ac_func;
8970 >  ;
8971 >  return 0;
8972 > }
8973 > _ACEOF
8974 > rm -f conftest.$ac_objext conftest$ac_exeext
8975 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8976 >  (eval $ac_link) 2>conftest.er1
8977 >  ac_status=$?
8978 >  grep -v '^ *+' conftest.er1 >conftest.err
8979 >  rm -f conftest.er1
8980 >  cat conftest.err >&5
8981 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8982 >  (exit $ac_status); } &&
8983 >         { ac_try='test -z "$ac_c_werror_flag"
8984 >                         || test ! -s conftest.err'
8985 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8986 >  (eval $ac_try) 2>&5
8987 >  ac_status=$?
8988 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8989 >  (exit $ac_status); }; } &&
8990 >         { ac_try='test -s conftest$ac_exeext'
8991 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8992 >  (eval $ac_try) 2>&5
8993 >  ac_status=$?
8994 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8995 >  (exit $ac_status); }; }; then
8996 >  eval "$as_ac_var=yes"
8997 > else
8998 >  echo "$as_me: failed program was:" >&5
8999 > sed 's/^/| /' conftest.$ac_ext >&5
9000 >
9001 > eval "$as_ac_var=no"
9002 > fi
9003 > rm -f conftest.err conftest.$ac_objext \
9004 >      conftest$ac_exeext conftest.$ac_ext
9005 > fi
9006 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9007 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9008 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9009 >  cat >>confdefs.h <<_ACEOF
9010 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9011 > _ACEOF
9012 >
9013 > else
9014 >  # strftime is in -lintl on SCO UNIX.
9015 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9016 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9017 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9018 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9019 > else
9020 >  ac_check_lib_save_LIBS=$LIBS
9021 > LIBS="-lintl  $LIBS"
9022 > cat >conftest.$ac_ext <<_ACEOF
9023 > /* confdefs.h.  */
9024 > _ACEOF
9025 > cat confdefs.h >>conftest.$ac_ext
9026 > cat >>conftest.$ac_ext <<_ACEOF
9027 > /* end confdefs.h.  */
9028 >
9029 > /* Override any gcc2 internal prototype to avoid an error.  */
9030 > #ifdef __cplusplus
9031 > extern "C"
9032 > #endif
9033 > /* We use char because int might match the return type of a gcc2
9034 >   builtin and then its argument prototype would still apply.  */
9035 > char strftime ();
9036 > #ifdef FC_DUMMY_MAIN
9037 > #ifndef FC_DUMMY_MAIN_EQ_F77
9038 > #  ifdef __cplusplus
9039 >     extern "C"
9040 > #  endif
9041 >   int FC_DUMMY_MAIN() { return 1; }
9042 > #endif
9043 > #endif
9044 > int
9045 > main ()
9046 > {
9047 > strftime ();
9048 >  ;
9049 >  return 0;
9050 > }
9051 > _ACEOF
9052 > rm -f conftest.$ac_objext conftest$ac_exeext
9053 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9054 >  (eval $ac_link) 2>conftest.er1
9055 >  ac_status=$?
9056 >  grep -v '^ *+' conftest.er1 >conftest.err
9057 >  rm -f conftest.er1
9058 >  cat conftest.err >&5
9059 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9060 >  (exit $ac_status); } &&
9061 >         { ac_try='test -z "$ac_c_werror_flag"
9062 >                         || test ! -s conftest.err'
9063 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9064 >  (eval $ac_try) 2>&5
9065 >  ac_status=$?
9066 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067 >  (exit $ac_status); }; } &&
9068 >         { ac_try='test -s conftest$ac_exeext'
9069 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9070 >  (eval $ac_try) 2>&5
9071 >  ac_status=$?
9072 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073 >  (exit $ac_status); }; }; then
9074 >  ac_cv_lib_intl_strftime=yes
9075 > else
9076 >  echo "$as_me: failed program was:" >&5
9077 > sed 's/^/| /' conftest.$ac_ext >&5
9078 >
9079 > ac_cv_lib_intl_strftime=no
9080 > fi
9081 > rm -f conftest.err conftest.$ac_objext \
9082 >      conftest$ac_exeext conftest.$ac_ext
9083 > LIBS=$ac_check_lib_save_LIBS
9084 > fi
9085 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9086 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9087 > if test $ac_cv_lib_intl_strftime = yes; then
9088 >  cat >>confdefs.h <<\_ACEOF
9089 > #define HAVE_STRFTIME 1
9090 > _ACEOF
9091 >
9092 > LIBS="-lintl $LIBS"
9093 > fi
9094 >
9095 > fi
9096 > done
9097 >
9098 > echo "$as_me:$LINENO: checking for working strtod" >&5
9099 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9100 > if test "${ac_cv_func_strtod+set}" = set; then
9101 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9102 > else
9103 >  if test "$cross_compiling" = yes; then
9104 >  ac_cv_func_strtod=no
9105 > else
9106 >  cat >conftest.$ac_ext <<_ACEOF
9107 > /* confdefs.h.  */
9108 > _ACEOF
9109 > cat confdefs.h >>conftest.$ac_ext
9110 > cat >>conftest.$ac_ext <<_ACEOF
9111 > /* end confdefs.h.  */
9112 >
9113 > double strtod ();
9114 > int
9115 > main()
9116 > {
9117 >  {
9118 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9119 >    char *string = " +69";
9120 >    char *term;
9121 >    double value;
9122 >    value = strtod (string, &term);
9123 >    if (value != 69 || term != (string + 4))
9124 >      exit (1);
9125 >  }
9126 >
9127 >  {
9128 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9129 >       terminating character under some conditions.  */
9130 >    char *string = "NaN";
9131 >    char *term;
9132 >    strtod (string, &term);
9133 >    if (term != string && *(term - 1) == 0)
9134 >      exit (1);
9135 >  }
9136 >  exit (0);
9137 > }
9138 >
9139 > _ACEOF
9140 > rm -f conftest$ac_exeext
9141 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9142 >  (eval $ac_link) 2>&5
9143 >  ac_status=$?
9144 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9145 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9146 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9147 >  (eval $ac_try) 2>&5
9148 >  ac_status=$?
9149 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9150 >  (exit $ac_status); }; }; then
9151 >  ac_cv_func_strtod=yes
9152 > else
9153 >  echo "$as_me: program exited with status $ac_status" >&5
9154 > echo "$as_me: failed program was:" >&5
9155 > sed 's/^/| /' conftest.$ac_ext >&5
9156 >
9157 > ( exit $ac_status )
9158 > ac_cv_func_strtod=no
9159 > fi
9160 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9161 > fi
9162 > fi
9163 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9164 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9165 > if test $ac_cv_func_strtod = no; then
9166 >  case $LIBOBJS in
9167 >    "strtod.$ac_objext"   | \
9168 >  *" strtod.$ac_objext"   | \
9169 >    "strtod.$ac_objext "* | \
9170 >  *" strtod.$ac_objext "* ) ;;
9171 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9172 > esac
9173 >
9174 > echo "$as_me:$LINENO: checking for pow" >&5
9175 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9176 > if test "${ac_cv_func_pow+set}" = set; then
9177 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9178 > else
9179 >  cat >conftest.$ac_ext <<_ACEOF
9180 > /* confdefs.h.  */
9181 > _ACEOF
9182 > cat confdefs.h >>conftest.$ac_ext
9183 > cat >>conftest.$ac_ext <<_ACEOF
9184 > /* end confdefs.h.  */
9185 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9186 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9187 > #define pow innocuous_pow
9188 >
9189 > /* System header to define __stub macros and hopefully few prototypes,
9190 >    which can conflict with char pow (); below.
9191 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9192 >    <limits.h> exists even on freestanding compilers.  */
9193 >
9194 > #ifdef __STDC__
9195 > # include <limits.h>
9196 > #else
9197 > # include <assert.h>
9198 > #endif
9199 >
9200 > #undef pow
9201 >
9202 > /* Override any gcc2 internal prototype to avoid an error.  */
9203 > #ifdef __cplusplus
9204 > extern "C"
9205 > {
9206 > #endif
9207 > /* We use char because int might match the return type of a gcc2
9208 >   builtin and then its argument prototype would still apply.  */
9209 > char pow ();
9210 > /* The GNU C library defines this for functions which it implements
9211 >    to always fail with ENOSYS.  Some functions are actually named
9212 >    something starting with __ and the normal name is an alias.  */
9213 > #if defined (__stub_pow) || defined (__stub___pow)
9214 > choke me
9215 > #else
9216 > char (*f) () = pow;
9217 > #endif
9218 > #ifdef __cplusplus
9219 > }
9220 > #endif
9221 >
9222 > #ifdef FC_DUMMY_MAIN
9223 > #ifndef FC_DUMMY_MAIN_EQ_F77
9224 > #  ifdef __cplusplus
9225 >     extern "C"
9226 > #  endif
9227 >   int FC_DUMMY_MAIN() { return 1; }
9228 > #endif
9229 > #endif
9230 > int
9231 > main ()
9232 > {
9233 > return f != pow;
9234 >  ;
9235 >  return 0;
9236 > }
9237 > _ACEOF
9238 > rm -f conftest.$ac_objext conftest$ac_exeext
9239 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9240 >  (eval $ac_link) 2>conftest.er1
9241 >  ac_status=$?
9242 >  grep -v '^ *+' conftest.er1 >conftest.err
9243 >  rm -f conftest.er1
9244 >  cat conftest.err >&5
9245 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9246 >  (exit $ac_status); } &&
9247 >         { ac_try='test -z "$ac_c_werror_flag"
9248 >                         || test ! -s conftest.err'
9249 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9250 >  (eval $ac_try) 2>&5
9251 >  ac_status=$?
9252 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9253 >  (exit $ac_status); }; } &&
9254 >         { ac_try='test -s conftest$ac_exeext'
9255 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9256 >  (eval $ac_try) 2>&5
9257 >  ac_status=$?
9258 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9259 >  (exit $ac_status); }; }; then
9260 >  ac_cv_func_pow=yes
9261 > else
9262 >  echo "$as_me: failed program was:" >&5
9263 > sed 's/^/| /' conftest.$ac_ext >&5
9264 >
9265 > ac_cv_func_pow=no
9266 > fi
9267 > rm -f conftest.err conftest.$ac_objext \
9268 >      conftest$ac_exeext conftest.$ac_ext
9269 > fi
9270 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9271 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9272 >
9273 > if test $ac_cv_func_pow = no; then
9274 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9275 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9276 > if test "${ac_cv_lib_m_pow+set}" = set; then
9277 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9278 > else
9279 >  ac_check_lib_save_LIBS=$LIBS
9280 > LIBS="-lm  $LIBS"
9281 > cat >conftest.$ac_ext <<_ACEOF
9282 > /* confdefs.h.  */
9283 > _ACEOF
9284 > cat confdefs.h >>conftest.$ac_ext
9285 > cat >>conftest.$ac_ext <<_ACEOF
9286 > /* end confdefs.h.  */
9287 >
9288 > /* Override any gcc2 internal prototype to avoid an error.  */
9289 > #ifdef __cplusplus
9290 > extern "C"
9291 > #endif
9292 > /* We use char because int might match the return type of a gcc2
9293 >   builtin and then its argument prototype would still apply.  */
9294 > char pow ();
9295 > #ifdef FC_DUMMY_MAIN
9296 > #ifndef FC_DUMMY_MAIN_EQ_F77
9297 > #  ifdef __cplusplus
9298 >     extern "C"
9299 > #  endif
9300 >   int FC_DUMMY_MAIN() { return 1; }
9301 > #endif
9302 > #endif
9303 > int
9304 > main ()
9305 > {
9306 > pow ();
9307 >  ;
9308 >  return 0;
9309 > }
9310 > _ACEOF
9311 > rm -f conftest.$ac_objext conftest$ac_exeext
9312 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9313 >  (eval $ac_link) 2>conftest.er1
9314 >  ac_status=$?
9315 >  grep -v '^ *+' conftest.er1 >conftest.err
9316 >  rm -f conftest.er1
9317 >  cat conftest.err >&5
9318 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9319 >  (exit $ac_status); } &&
9320 >         { ac_try='test -z "$ac_c_werror_flag"
9321 >                         || test ! -s conftest.err'
9322 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9323 >  (eval $ac_try) 2>&5
9324 >  ac_status=$?
9325 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9326 >  (exit $ac_status); }; } &&
9327 >         { ac_try='test -s conftest$ac_exeext'
9328 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9329 >  (eval $ac_try) 2>&5
9330 >  ac_status=$?
9331 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9332 >  (exit $ac_status); }; }; then
9333 >  ac_cv_lib_m_pow=yes
9334 > else
9335 >  echo "$as_me: failed program was:" >&5
9336 > sed 's/^/| /' conftest.$ac_ext >&5
9337 >
9338 > ac_cv_lib_m_pow=no
9339 > fi
9340 > rm -f conftest.err conftest.$ac_objext \
9341 >      conftest$ac_exeext conftest.$ac_ext
9342 > LIBS=$ac_check_lib_save_LIBS
9343 > fi
9344 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9345 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9346 > if test $ac_cv_lib_m_pow = yes; then
9347 >  POW_LIB=-lm
9348 > else
9349 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9350 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9351 > fi
9352 >
9353 > fi
9354 >
9355 > fi
9356 >
9357 >
9358 >
9359 >
9360 >
9361 >
9362 >
9363 >
9364 >
9365 >
9366 >
9367 >
9368 >
9369 >
9370 >
9371 >
9372 >
9373 >
9374 >
9375 >
9376 >
9377 >
9378 >
9379 >
9380 >
9381 >
9382 >
9383 >
9384 > for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9385 > do
9386 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9387 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9388 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9389 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9391 > else
9392 >  cat >conftest.$ac_ext <<_ACEOF
9393 > /* confdefs.h.  */
9394 > _ACEOF
9395 > cat confdefs.h >>conftest.$ac_ext
9396 > cat >>conftest.$ac_ext <<_ACEOF
9397 > /* end confdefs.h.  */
9398 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9399 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9400 > #define $ac_func innocuous_$ac_func
9401 >
9402 > /* System header to define __stub macros and hopefully few prototypes,
9403 >    which can conflict with char $ac_func (); below.
9404 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9405 >    <limits.h> exists even on freestanding compilers.  */
9406 >
9407 > #ifdef __STDC__
9408 > # include <limits.h>
9409 > #else
9410 > # include <assert.h>
9411 > #endif
9412 >
9413 > #undef $ac_func
9414 >
9415 > /* Override any gcc2 internal prototype to avoid an error.  */
9416 > #ifdef __cplusplus
9417 > extern "C"
9418 > {
9419 > #endif
9420 > /* We use char because int might match the return type of a gcc2
9421 >   builtin and then its argument prototype would still apply.  */
9422 > char $ac_func ();
9423 > /* The GNU C library defines this for functions which it implements
9424 >    to always fail with ENOSYS.  Some functions are actually named
9425 >    something starting with __ and the normal name is an alias.  */
9426 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9427 > choke me
9428 > #else
9429 > char (*f) () = $ac_func;
9430 > #endif
9431 > #ifdef __cplusplus
9432 > }
9433 > #endif
9434 >
9435 > #ifdef FC_DUMMY_MAIN
9436 > #ifndef FC_DUMMY_MAIN_EQ_F77
9437 > #  ifdef __cplusplus
9438 >     extern "C"
9439 > #  endif
9440 >   int FC_DUMMY_MAIN() { return 1; }
9441 > #endif
9442 > #endif
9443 > int
9444 > main ()
9445 > {
9446 > return f != $ac_func;
9447 >  ;
9448 >  return 0;
9449 > }
9450 > _ACEOF
9451 > rm -f conftest.$ac_objext conftest$ac_exeext
9452 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9453 >  (eval $ac_link) 2>conftest.er1
9454 >  ac_status=$?
9455 >  grep -v '^ *+' conftest.er1 >conftest.err
9456 >  rm -f conftest.er1
9457 >  cat conftest.err >&5
9458 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9459 >  (exit $ac_status); } &&
9460 >         { ac_try='test -z "$ac_c_werror_flag"
9461 >                         || test ! -s conftest.err'
9462 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9463 >  (eval $ac_try) 2>&5
9464 >  ac_status=$?
9465 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9466 >  (exit $ac_status); }; } &&
9467 >         { ac_try='test -s conftest$ac_exeext'
9468 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9469 >  (eval $ac_try) 2>&5
9470 >  ac_status=$?
9471 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9472 >  (exit $ac_status); }; }; then
9473 >  eval "$as_ac_var=yes"
9474 > else
9475 >  echo "$as_me: failed program was:" >&5
9476 > sed 's/^/| /' conftest.$ac_ext >&5
9477 >
9478 > eval "$as_ac_var=no"
9479 > fi
9480 > rm -f conftest.err conftest.$ac_objext \
9481 >      conftest$ac_exeext conftest.$ac_ext
9482 > fi
9483 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9484 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9485 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9486 >  cat >>confdefs.h <<_ACEOF
9487 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9488 > _ACEOF
9489 >
9490 > fi
9491 > done
9492 >
9493 >
9494 > # special check for _system_configuration because AIX <4.3.2 do not
9495 > # contain the `physmem' member.
9496 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9497 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9498 > cat >conftest.$ac_ext <<_ACEOF
9499 > /* confdefs.h.  */
9500 > _ACEOF
9501 > cat confdefs.h >>conftest.$ac_ext
9502 > cat >>conftest.$ac_ext <<_ACEOF
9503 > /* end confdefs.h.  */
9504 > #include <sys/systemcfg.h>
9505 > #ifdef FC_DUMMY_MAIN
9506 > #ifndef FC_DUMMY_MAIN_EQ_F77
9507 > #  ifdef __cplusplus
9508 >     extern "C"
9509 > #  endif
9510 >   int FC_DUMMY_MAIN() { return 1; }
9511 > #endif
9512 > #endif
9513 > int
9514 > main ()
9515 > {
9516 > double x = _system_configuration.physmem;
9517 >  ;
9518 >  return 0;
9519 > }
9520 > _ACEOF
9521 > rm -f conftest.$ac_objext
9522 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9523 >  (eval $ac_compile) 2>conftest.er1
9524 >  ac_status=$?
9525 >  grep -v '^ *+' conftest.er1 >conftest.err
9526 >  rm -f conftest.er1
9527 >  cat conftest.err >&5
9528 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9529 >  (exit $ac_status); } &&
9530 >         { ac_try='test -z "$ac_c_werror_flag"
9531 >                         || test ! -s conftest.err'
9532 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9533 >  (eval $ac_try) 2>&5
9534 >  ac_status=$?
9535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9536 >  (exit $ac_status); }; } &&
9537 >         { ac_try='test -s conftest.$ac_objext'
9538 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9539 >  (eval $ac_try) 2>&5
9540 >  ac_status=$?
9541 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9542 >  (exit $ac_status); }; }; then
9543 >  echo "$as_me:$LINENO: result: yes" >&5
9544 > echo "${ECHO_T}yes" >&6
9545 >
9546 > cat >>confdefs.h <<\_ACEOF
9547 > #define HAVE__SYSTEM_CONFIGURATION 1
9548 > _ACEOF
9549 >
9550 > else
9551 >  echo "$as_me: failed program was:" >&5
9552 > sed 's/^/| /' conftest.$ac_ext >&5
9553 >
9554 > echo "$as_me:$LINENO: result: no" >&5
9555 > echo "${ECHO_T}no" >&6
9556 > fi
9557 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9558 >
9559 >  # clean out junk possibly left behind by a previous configuration
9560 >  rm -f src/getopt.h
9561 >  # Check for getopt_long support
9562 >
9563 > for ac_header in getopt.h
9564 > do
9565 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9566 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9567 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9568 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9569 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9570 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9571 > fi
9572 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9573 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9574 > else
9575 >  # Is the header compilable?
9576 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9577 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9578 > cat >conftest.$ac_ext <<_ACEOF
9579 > /* confdefs.h.  */
9580 > _ACEOF
9581 > cat confdefs.h >>conftest.$ac_ext
9582 > cat >>conftest.$ac_ext <<_ACEOF
9583 > /* end confdefs.h.  */
9584 > $ac_includes_default
9585 > #include <$ac_header>
9586 > _ACEOF
9587 > rm -f conftest.$ac_objext
9588 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9589 >  (eval $ac_compile) 2>conftest.er1
9590 >  ac_status=$?
9591 >  grep -v '^ *+' conftest.er1 >conftest.err
9592 >  rm -f conftest.er1
9593 >  cat conftest.err >&5
9594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9595 >  (exit $ac_status); } &&
9596 >         { ac_try='test -z "$ac_c_werror_flag"
9597 >                         || test ! -s conftest.err'
9598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9599 >  (eval $ac_try) 2>&5
9600 >  ac_status=$?
9601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9602 >  (exit $ac_status); }; } &&
9603 >         { ac_try='test -s conftest.$ac_objext'
9604 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9605 >  (eval $ac_try) 2>&5
9606 >  ac_status=$?
9607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9608 >  (exit $ac_status); }; }; then
9609 >  ac_header_compiler=yes
9610 > else
9611 >  echo "$as_me: failed program was:" >&5
9612 > sed 's/^/| /' conftest.$ac_ext >&5
9613 >
9614 > ac_header_compiler=no
9615 > fi
9616 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9617 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9618 > echo "${ECHO_T}$ac_header_compiler" >&6
9619 >
9620 > # Is the header present?
9621 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9622 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9623 > cat >conftest.$ac_ext <<_ACEOF
9624 > /* confdefs.h.  */
9625 > _ACEOF
9626 > cat confdefs.h >>conftest.$ac_ext
9627 > cat >>conftest.$ac_ext <<_ACEOF
9628 > /* end confdefs.h.  */
9629 > #include <$ac_header>
9630 > _ACEOF
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9632 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9633 >  ac_status=$?
9634 >  grep -v '^ *+' conftest.er1 >conftest.err
9635 >  rm -f conftest.er1
9636 >  cat conftest.err >&5
9637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638 >  (exit $ac_status); } >/dev/null; then
9639 >  if test -s conftest.err; then
9640 >    ac_cpp_err=$ac_c_preproc_warn_flag
9641      ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9642    else
9643      ac_cpp_err=
# Line 4515 | Line 9646 | if test -z "$ac_cpp_err"; then
9646    ac_cpp_err=yes
9647   fi
9648   if test -z "$ac_cpp_err"; then
9649 +  ac_header_preproc=yes
9650 + else
9651 +  echo "$as_me: failed program was:" >&5
9652 + sed 's/^/| /' conftest.$ac_ext >&5
9653 +
9654 +  ac_header_preproc=no
9655 + fi
9656 + rm -f conftest.err conftest.$ac_ext
9657 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9658 + echo "${ECHO_T}$ac_header_preproc" >&6
9659 +
9660 + # So?  What about this header?
9661 + case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9662 +  yes:no: )
9663 +    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9664 + echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9665 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9666 + echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9667 +    ac_header_preproc=yes
9668 +    ;;
9669 +  no:yes:* )
9670 +    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9671 + echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9672 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9673 + echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9674 +    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9675 + echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9676 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9677 + echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9678 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9679 + echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9680 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9681 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9682 +    (
9683 +      cat <<\_ASBOX
9684 + ## ------------------------------ ##
9685 + ## Report this to gezelter@nd.edu ##
9686 + ## ------------------------------ ##
9687 + _ASBOX
9688 +    ) |
9689 +      sed "s/^/$as_me: WARNING:     /" >&2
9690 +    ;;
9691 + esac
9692 + echo "$as_me:$LINENO: checking for $ac_header" >&5
9693 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9694 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
9695 +  echo $ECHO_N "(cached) $ECHO_C" >&6
9696 + else
9697 +  eval "$as_ac_Header=\$ac_header_preproc"
9698 + fi
9699 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9700 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9701 +
9702 + fi
9703 + if test `eval echo '${'$as_ac_Header'}'` = yes; then
9704 +  cat >>confdefs.h <<_ACEOF
9705 + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9706 + _ACEOF
9707 +
9708 + fi
9709 +
9710 + done
9711 +
9712 +
9713 + for ac_func in getopt_long
9714 + do
9715 + as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9716 + echo "$as_me:$LINENO: checking for $ac_func" >&5
9717 + echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9718 + if eval "test \"\${$as_ac_var+set}\" = set"; then
9719 +  echo $ECHO_N "(cached) $ECHO_C" >&6
9720 + else
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 + /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9728 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9729 + #define $ac_func innocuous_$ac_func
9730 +
9731 + /* System header to define __stub macros and hopefully few prototypes,
9732 +    which can conflict with char $ac_func (); below.
9733 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9734 +    <limits.h> exists even on freestanding compilers.  */
9735 +
9736 + #ifdef __STDC__
9737 + # include <limits.h>
9738 + #else
9739 + # include <assert.h>
9740 + #endif
9741 +
9742 + #undef $ac_func
9743 +
9744 + /* Override any gcc2 internal prototype to avoid an error.  */
9745 + #ifdef __cplusplus
9746 + extern "C"
9747 + {
9748 + #endif
9749 + /* We use char because int might match the return type of a gcc2
9750 +   builtin and then its argument prototype would still apply.  */
9751 + char $ac_func ();
9752 + /* The GNU C library defines this for functions which it implements
9753 +    to always fail with ENOSYS.  Some functions are actually named
9754 +    something starting with __ and the normal name is an alias.  */
9755 + #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9756 + choke me
9757 + #else
9758 + char (*f) () = $ac_func;
9759 + #endif
9760 + #ifdef __cplusplus
9761 + }
9762 + #endif
9763 +
9764 + #ifdef FC_DUMMY_MAIN
9765 + #ifndef FC_DUMMY_MAIN_EQ_F77
9766 + #  ifdef __cplusplus
9767 +     extern "C"
9768 + #  endif
9769 +   int FC_DUMMY_MAIN() { return 1; }
9770 + #endif
9771 + #endif
9772 + int
9773 + main ()
9774 + {
9775 + return f != $ac_func;
9776 +  ;
9777 +  return 0;
9778 + }
9779 + _ACEOF
9780 + rm -f conftest.$ac_objext conftest$ac_exeext
9781 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9782 +  (eval $ac_link) 2>conftest.er1
9783 +  ac_status=$?
9784 +  grep -v '^ *+' conftest.er1 >conftest.err
9785 +  rm -f conftest.er1
9786 +  cat conftest.err >&5
9787 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9788 +  (exit $ac_status); } &&
9789 +         { ac_try='test -z "$ac_c_werror_flag"
9790 +                         || test ! -s conftest.err'
9791 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9792 +  (eval $ac_try) 2>&5
9793 +  ac_status=$?
9794 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9795 +  (exit $ac_status); }; } &&
9796 +         { ac_try='test -s conftest$ac_exeext'
9797 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9798 +  (eval $ac_try) 2>&5
9799 +  ac_status=$?
9800 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9801 +  (exit $ac_status); }; }; then
9802 +  eval "$as_ac_var=yes"
9803 + else
9804 +  echo "$as_me: failed program was:" >&5
9805 + sed 's/^/| /' conftest.$ac_ext >&5
9806 +
9807 + eval "$as_ac_var=no"
9808 + fi
9809 + rm -f conftest.err conftest.$ac_objext \
9810 +      conftest$ac_exeext conftest.$ac_ext
9811 + fi
9812 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9813 + echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9814 + if test `eval echo '${'$as_ac_var'}'` = yes; then
9815 +  cat >>confdefs.h <<_ACEOF
9816 + #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9817 + _ACEOF
9818 +
9819 + else
9820 +  # FreeBSD has a gnugetopt library for this
9821 +    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9822 + echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9823 + if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9824 +  echo $ECHO_N "(cached) $ECHO_C" >&6
9825 + else
9826 +  ac_check_lib_save_LIBS=$LIBS
9827 + LIBS="-lgnugetopt  $LIBS"
9828 + cat >conftest.$ac_ext <<_ACEOF
9829 + /* confdefs.h.  */
9830 + _ACEOF
9831 + cat confdefs.h >>conftest.$ac_ext
9832 + cat >>conftest.$ac_ext <<_ACEOF
9833 + /* end confdefs.h.  */
9834 +
9835 + /* Override any gcc2 internal prototype to avoid an error.  */
9836 + #ifdef __cplusplus
9837 + extern "C"
9838 + #endif
9839 + /* We use char because int might match the return type of a gcc2
9840 +   builtin and then its argument prototype would still apply.  */
9841 + char getopt_long ();
9842 + #ifdef FC_DUMMY_MAIN
9843 + #ifndef FC_DUMMY_MAIN_EQ_F77
9844 + #  ifdef __cplusplus
9845 +     extern "C"
9846 + #  endif
9847 +   int FC_DUMMY_MAIN() { return 1; }
9848 + #endif
9849 + #endif
9850 + int
9851 + main ()
9852 + {
9853 + getopt_long ();
9854 +  ;
9855 +  return 0;
9856 + }
9857 + _ACEOF
9858 + rm -f conftest.$ac_objext conftest$ac_exeext
9859 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9860 +  (eval $ac_link) 2>conftest.er1
9861 +  ac_status=$?
9862 +  grep -v '^ *+' conftest.er1 >conftest.err
9863 +  rm -f conftest.er1
9864 +  cat conftest.err >&5
9865 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866 +  (exit $ac_status); } &&
9867 +         { ac_try='test -z "$ac_c_werror_flag"
9868 +                         || test ! -s conftest.err'
9869 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9870 +  (eval $ac_try) 2>&5
9871 +  ac_status=$?
9872 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9873 +  (exit $ac_status); }; } &&
9874 +         { ac_try='test -s conftest$ac_exeext'
9875 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9876 +  (eval $ac_try) 2>&5
9877 +  ac_status=$?
9878 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9879 +  (exit $ac_status); }; }; then
9880 +  ac_cv_lib_gnugetopt_getopt_long=yes
9881 + else
9882 +  echo "$as_me: failed program was:" >&5
9883 + sed 's/^/| /' conftest.$ac_ext >&5
9884 +
9885 + ac_cv_lib_gnugetopt_getopt_long=no
9886 + fi
9887 + rm -f conftest.err conftest.$ac_objext \
9888 +      conftest$ac_exeext conftest.$ac_ext
9889 + LIBS=$ac_check_lib_save_LIBS
9890 + fi
9891 + echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9892 + echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9893 + if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9894 +  cat >>confdefs.h <<\_ACEOF
9895 + #define HAVE_GETOPT_LONG 1
9896 + _ACEOF
9897 +
9898 + else
9899 +  # use the GNU replacement
9900 +      case $LIBOBJS in
9901 +    "getopt.$ac_objext"   | \
9902 +  *" getopt.$ac_objext"   | \
9903 +    "getopt.$ac_objext "* | \
9904 +  *" getopt.$ac_objext "* ) ;;
9905 +  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9906 + esac
9907 +
9908 +      case $LIBOBJS in
9909 +    "getopt1.$ac_objext"   | \
9910 +  *" getopt1.$ac_objext"   | \
9911 +    "getopt1.$ac_objext "* | \
9912 +  *" getopt1.$ac_objext "* ) ;;
9913 +  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9914 + esac
9915 +
9916 +                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9917 +
9918 + fi
9919 +
9920 + fi
9921 + done
9922 +
9923 +
9924 + ac_ext=cc
9925 + ac_cpp='$CXXCPP $CPPFLAGS'
9926 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9927 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9928 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9929 +
9930 +
9931 + echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9932 + echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9933 + if test "${ac_cv_cxx_namespaces+set}" = set; then
9934 +  echo $ECHO_N "(cached) $ECHO_C" >&6
9935 + else
9936 +
9937 +
9938 + ac_ext=cc
9939 + ac_cpp='$CXXCPP $CPPFLAGS'
9940 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9941 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9942 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9943 +
9944 + cat >conftest.$ac_ext <<_ACEOF
9945 + /* confdefs.h.  */
9946 + _ACEOF
9947 + cat confdefs.h >>conftest.$ac_ext
9948 + cat >>conftest.$ac_ext <<_ACEOF
9949 + /* end confdefs.h.  */
9950 + namespace Outer { namespace Inner { int i = 0; }}
9951 + #ifdef FC_DUMMY_MAIN
9952 + #ifndef FC_DUMMY_MAIN_EQ_F77
9953 + #  ifdef __cplusplus
9954 +     extern "C"
9955 + #  endif
9956 +   int FC_DUMMY_MAIN() { return 1; }
9957 + #endif
9958 + #endif
9959 + int
9960 + main ()
9961 + {
9962 + using namespace Outer::Inner; return i;
9963 +  ;
9964 +  return 0;
9965 + }
9966 + _ACEOF
9967 + rm -f conftest.$ac_objext
9968 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9969 +  (eval $ac_compile) 2>conftest.er1
9970 +  ac_status=$?
9971 +  grep -v '^ *+' conftest.er1 >conftest.err
9972 +  rm -f conftest.er1
9973 +  cat conftest.err >&5
9974 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9975 +  (exit $ac_status); } &&
9976 +         { ac_try='test -z "$ac_cxx_werror_flag"
9977 +                         || test ! -s conftest.err'
9978 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9979 +  (eval $ac_try) 2>&5
9980 +  ac_status=$?
9981 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9982 +  (exit $ac_status); }; } &&
9983 +         { ac_try='test -s conftest.$ac_objext'
9984 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9985 +  (eval $ac_try) 2>&5
9986 +  ac_status=$?
9987 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9988 +  (exit $ac_status); }; }; then
9989 +  ac_cv_cxx_namespaces=yes
9990 + else
9991 +  echo "$as_me: failed program was:" >&5
9992 + sed 's/^/| /' conftest.$ac_ext >&5
9993 +
9994 + ac_cv_cxx_namespaces=no
9995 + fi
9996 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9997 + ac_ext=cc
9998 + ac_cpp='$CXXCPP $CPPFLAGS'
9999 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10000 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10001 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10002 +
10003 +
10004 + fi
10005 + echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10006 + echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10007 + if test "$ac_cv_cxx_namespaces" = yes; then
10008 +
10009 + cat >>confdefs.h <<\_ACEOF
10010 + #define HAVE_NAMESPACES
10011 + _ACEOF
10012 +
10013 + fi
10014 +
10015 + ac_ext=cc
10016 + ac_cpp='$CXXCPP $CPPFLAGS'
10017 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10018 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10019 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10020 + echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10021 + echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10022 + if test -z "$CXXCPP"; then
10023 +  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10024 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10025 + else
10026 +      # Double quotes because CXXCPP needs to be expanded
10027 +    for CXXCPP in "$CXX -E" "/lib/cpp"
10028 +    do
10029 +      ac_preproc_ok=false
10030 + for ac_cxx_preproc_warn_flag in '' yes
10031 + do
10032 +  # Use a header file that comes with gcc, so configuring glibc
10033 +  # with a fresh cross-compiler works.
10034 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10035 +  # <limits.h> exists even on freestanding compilers.
10036 +  # On the NeXT, cc -E runs the code through the compiler's parser,
10037 +  # not just through cpp. "Syntax error" is here to catch this case.
10038 +  cat >conftest.$ac_ext <<_ACEOF
10039 + /* confdefs.h.  */
10040 + _ACEOF
10041 + cat confdefs.h >>conftest.$ac_ext
10042 + cat >>conftest.$ac_ext <<_ACEOF
10043 + /* end confdefs.h.  */
10044 + #ifdef __STDC__
10045 + # include <limits.h>
10046 + #else
10047 + # include <assert.h>
10048 + #endif
10049 +                     Syntax error
10050 + _ACEOF
10051 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10052 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10053 +  ac_status=$?
10054 +  grep -v '^ *+' conftest.er1 >conftest.err
10055 +  rm -f conftest.er1
10056 +  cat conftest.err >&5
10057 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10058 +  (exit $ac_status); } >/dev/null; then
10059 +  if test -s conftest.err; then
10060 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
10061 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10062 +  else
10063 +    ac_cpp_err=
10064 +  fi
10065 + else
10066 +  ac_cpp_err=yes
10067 + fi
10068 + if test -z "$ac_cpp_err"; then
10069    :
10070   else
10071    echo "$as_me: failed program was:" >&5
# Line 4544 | Line 10095 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10095    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10096    (exit $ac_status); } >/dev/null; then
10097    if test -s conftest.err; then
10098 <    ac_cpp_err=$ac_c_preproc_warn_flag
10099 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10098 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10099 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10100    else
10101      ac_cpp_err=
10102    fi
# Line 4573 | Line 10124 | fi
10124   fi
10125  
10126      done
10127 <    ac_cv_prog_CPP=$CPP
10127 >    ac_cv_prog_CXXCPP=$CXXCPP
10128  
10129   fi
10130 <  CPP=$ac_cv_prog_CPP
10130 >  CXXCPP=$ac_cv_prog_CXXCPP
10131   else
10132 <  ac_cv_prog_CPP=$CPP
10132 >  ac_cv_prog_CXXCPP=$CXXCPP
10133   fi
10134 < echo "$as_me:$LINENO: result: $CPP" >&5
10135 < echo "${ECHO_T}$CPP" >&6
10134 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10135 > echo "${ECHO_T}$CXXCPP" >&6
10136   ac_preproc_ok=false
10137 < for ac_c_preproc_warn_flag in '' yes
10137 > for ac_cxx_preproc_warn_flag in '' yes
10138   do
10139    # Use a header file that comes with gcc, so configuring glibc
10140    # with a fresh cross-compiler works.
# Line 4613 | Line 10164 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10164    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10165    (exit $ac_status); } >/dev/null; then
10166    if test -s conftest.err; then
10167 <    ac_cpp_err=$ac_c_preproc_warn_flag
10168 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10167 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10168 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10169    else
10170      ac_cpp_err=
10171    fi
# Line 4651 | Line 10202 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10202    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10203    (exit $ac_status); } >/dev/null; then
10204    if test -s conftest.err; then
10205 <    ac_cpp_err=$ac_c_preproc_warn_flag
10206 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10205 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10206 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10207 >  else
10208 >    ac_cpp_err=
10209 >  fi
10210 > else
10211 >  ac_cpp_err=yes
10212 > fi
10213 > if test -z "$ac_cpp_err"; then
10214 >  # Broken: success on invalid input.
10215 > continue
10216 > else
10217 >  echo "$as_me: failed program was:" >&5
10218 > sed 's/^/| /' conftest.$ac_ext >&5
10219 >
10220 >  # Passes both tests.
10221 > ac_preproc_ok=:
10222 > break
10223 > fi
10224 > rm -f conftest.err conftest.$ac_ext
10225 >
10226 > done
10227 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10228 > rm -f conftest.err conftest.$ac_ext
10229 > if $ac_preproc_ok; then
10230 >  :
10231 > else
10232 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10233 > See \`config.log' for more details." >&5
10234 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10235 > See \`config.log' for more details." >&2;}
10236 >   { (exit 1); exit 1; }; }
10237 > fi
10238 >
10239 > ac_ext=cc
10240 > ac_cpp='$CXXCPP $CPPFLAGS'
10241 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10242 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10243 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10244 >
10245 >
10246 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10247 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10248 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10249 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10250 > else
10251 >
10252 >
10253 >
10254 > ac_ext=cc
10255 > ac_cpp='$CXXCPP $CPPFLAGS'
10256 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10257 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10258 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10259 >
10260 > cat >conftest.$ac_ext <<_ACEOF
10261 > /* confdefs.h.  */
10262 > _ACEOF
10263 > cat confdefs.h >>conftest.$ac_ext
10264 > cat >>conftest.$ac_ext <<_ACEOF
10265 > /* end confdefs.h.  */
10266 > #include <list>
10267 > #include <deque>
10268 > #ifdef HAVE_NAMESPACES
10269 > using namespace std;
10270 > #endif
10271 > #ifdef FC_DUMMY_MAIN
10272 > #ifndef FC_DUMMY_MAIN_EQ_F77
10273 > #  ifdef __cplusplus
10274 >     extern "C"
10275 > #  endif
10276 >   int FC_DUMMY_MAIN() { return 1; }
10277 > #endif
10278 > #endif
10279 > int
10280 > main ()
10281 > {
10282 > list<int> x; x.push_back(5);
10283 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10284 >  ;
10285 >  return 0;
10286 > }
10287 > _ACEOF
10288 > rm -f conftest.$ac_objext
10289 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10290 >  (eval $ac_compile) 2>conftest.er1
10291 >  ac_status=$?
10292 >  grep -v '^ *+' conftest.er1 >conftest.err
10293 >  rm -f conftest.er1
10294 >  cat conftest.err >&5
10295 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10296 >  (exit $ac_status); } &&
10297 >         { ac_try='test -z "$ac_cxx_werror_flag"
10298 >                         || test ! -s conftest.err'
10299 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10300 >  (eval $ac_try) 2>&5
10301 >  ac_status=$?
10302 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10303 >  (exit $ac_status); }; } &&
10304 >         { ac_try='test -s conftest.$ac_objext'
10305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10306 >  (eval $ac_try) 2>&5
10307 >  ac_status=$?
10308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10309 >  (exit $ac_status); }; }; then
10310 >  ac_cv_cxx_have_stl=yes
10311 > else
10312 >  echo "$as_me: failed program was:" >&5
10313 > sed 's/^/| /' conftest.$ac_ext >&5
10314 >
10315 > ac_cv_cxx_have_stl=no
10316 > fi
10317 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10318 > ac_ext=cc
10319 > ac_cpp='$CXXCPP $CPPFLAGS'
10320 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10321 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10322 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10323 >
10324 >
10325 > fi
10326 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10327 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10328 > if test "$ac_cv_cxx_have_stl" = yes; then
10329 >
10330 > cat >>confdefs.h <<\_ACEOF
10331 > #define HAVE_STL
10332 > _ACEOF
10333 >
10334 > fi
10335 >
10336 >
10337 >
10338 >  if test "${ac_cv_header_iostream+set}" = set; then
10339 >  echo "$as_me:$LINENO: checking for iostream" >&5
10340 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10341 > if test "${ac_cv_header_iostream+set}" = set; then
10342 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10343 > fi
10344 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10345 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10346 > else
10347 >  # Is the header compilable?
10348 > echo "$as_me:$LINENO: checking iostream usability" >&5
10349 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10350 > cat >conftest.$ac_ext <<_ACEOF
10351 > /* confdefs.h.  */
10352 > _ACEOF
10353 > cat confdefs.h >>conftest.$ac_ext
10354 > cat >>conftest.$ac_ext <<_ACEOF
10355 > /* end confdefs.h.  */
10356 > $ac_includes_default
10357 > #include <iostream>
10358 > _ACEOF
10359 > rm -f conftest.$ac_objext
10360 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10361 >  (eval $ac_compile) 2>conftest.er1
10362 >  ac_status=$?
10363 >  grep -v '^ *+' conftest.er1 >conftest.err
10364 >  rm -f conftest.er1
10365 >  cat conftest.err >&5
10366 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10367 >  (exit $ac_status); } &&
10368 >         { ac_try='test -z "$ac_cxx_werror_flag"
10369 >                         || test ! -s conftest.err'
10370 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10371 >  (eval $ac_try) 2>&5
10372 >  ac_status=$?
10373 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10374 >  (exit $ac_status); }; } &&
10375 >         { ac_try='test -s conftest.$ac_objext'
10376 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10377 >  (eval $ac_try) 2>&5
10378 >  ac_status=$?
10379 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380 >  (exit $ac_status); }; }; then
10381 >  ac_header_compiler=yes
10382 > else
10383 >  echo "$as_me: failed program was:" >&5
10384 > sed 's/^/| /' conftest.$ac_ext >&5
10385 >
10386 > ac_header_compiler=no
10387 > fi
10388 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10389 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10390 > echo "${ECHO_T}$ac_header_compiler" >&6
10391 >
10392 > # Is the header present?
10393 > echo "$as_me:$LINENO: checking iostream presence" >&5
10394 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10395 > cat >conftest.$ac_ext <<_ACEOF
10396 > /* confdefs.h.  */
10397 > _ACEOF
10398 > cat confdefs.h >>conftest.$ac_ext
10399 > cat >>conftest.$ac_ext <<_ACEOF
10400 > /* end confdefs.h.  */
10401 > #include <iostream>
10402 > _ACEOF
10403 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10404 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10405 >  ac_status=$?
10406 >  grep -v '^ *+' conftest.er1 >conftest.err
10407 >  rm -f conftest.er1
10408 >  cat conftest.err >&5
10409 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10410 >  (exit $ac_status); } >/dev/null; then
10411 >  if test -s conftest.err; then
10412 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10413 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10414    else
10415      ac_cpp_err=
10416    fi
10417   else
10418    ac_cpp_err=yes
10419 < fi
10420 < if test -z "$ac_cpp_err"; then
10421 <  # Broken: success on invalid input.
10422 < continue
10423 < else
10424 <  echo "$as_me: failed program was:" >&5
10425 < sed 's/^/| /' conftest.$ac_ext >&5
10419 > fi
10420 > if test -z "$ac_cpp_err"; then
10421 >  ac_header_preproc=yes
10422 > else
10423 >  echo "$as_me: failed program was:" >&5
10424 > sed 's/^/| /' conftest.$ac_ext >&5
10425 >
10426 >  ac_header_preproc=no
10427 > fi
10428 > rm -f conftest.err conftest.$ac_ext
10429 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10430 > echo "${ECHO_T}$ac_header_preproc" >&6
10431 >
10432 > # So?  What about this header?
10433 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10434 >  yes:no: )
10435 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10436 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10437 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10438 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10439 >    ac_header_preproc=yes
10440 >    ;;
10441 >  no:yes:* )
10442 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10443 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10444 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10445 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10446 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10447 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10448 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10449 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10450 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10451 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10452 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10453 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10454 >    (
10455 >      cat <<\_ASBOX
10456 > ## ------------------------------ ##
10457 > ## Report this to gezelter@nd.edu ##
10458 > ## ------------------------------ ##
10459 > _ASBOX
10460 >    ) |
10461 >      sed "s/^/$as_me: WARNING:     /" >&2
10462 >    ;;
10463 > esac
10464 > echo "$as_me:$LINENO: checking for iostream" >&5
10465 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10466 > if test "${ac_cv_header_iostream+set}" = set; then
10467 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10468 > else
10469 >  ac_cv_header_iostream=$ac_header_preproc
10470 > fi
10471 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10472 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10473 >
10474 > fi
10475 > if test $ac_cv_header_iostream = yes; then
10476 >
10477 >
10478 > cat >>confdefs.h <<\_ACEOF
10479 > #define HAVE_IOSTREAM 1
10480 > _ACEOF
10481 >
10482 >
10483 > else
10484 >
10485 >
10486 > for ac_header in iostream.h
10487 > do
10488 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10489 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10490 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10491 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10492 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10493 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10494 > fi
10495 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10496 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10497 > else
10498 >  # Is the header compilable?
10499 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10500 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10501 > cat >conftest.$ac_ext <<_ACEOF
10502 > /* confdefs.h.  */
10503 > _ACEOF
10504 > cat confdefs.h >>conftest.$ac_ext
10505 > cat >>conftest.$ac_ext <<_ACEOF
10506 > /* end confdefs.h.  */
10507 > $ac_includes_default
10508 > #include <$ac_header>
10509 > _ACEOF
10510 > rm -f conftest.$ac_objext
10511 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10512 >  (eval $ac_compile) 2>conftest.er1
10513 >  ac_status=$?
10514 >  grep -v '^ *+' conftest.er1 >conftest.err
10515 >  rm -f conftest.er1
10516 >  cat conftest.err >&5
10517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10518 >  (exit $ac_status); } &&
10519 >         { ac_try='test -z "$ac_cxx_werror_flag"
10520 >                         || test ! -s conftest.err'
10521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10522 >  (eval $ac_try) 2>&5
10523 >  ac_status=$?
10524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10525 >  (exit $ac_status); }; } &&
10526 >         { ac_try='test -s conftest.$ac_objext'
10527 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10528 >  (eval $ac_try) 2>&5
10529 >  ac_status=$?
10530 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10531 >  (exit $ac_status); }; }; then
10532 >  ac_header_compiler=yes
10533 > else
10534 >  echo "$as_me: failed program was:" >&5
10535 > sed 's/^/| /' conftest.$ac_ext >&5
10536 >
10537 > ac_header_compiler=no
10538 > fi
10539 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10540 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10541 > echo "${ECHO_T}$ac_header_compiler" >&6
10542 >
10543 > # Is the header present?
10544 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10545 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10546 > cat >conftest.$ac_ext <<_ACEOF
10547 > /* confdefs.h.  */
10548 > _ACEOF
10549 > cat confdefs.h >>conftest.$ac_ext
10550 > cat >>conftest.$ac_ext <<_ACEOF
10551 > /* end confdefs.h.  */
10552 > #include <$ac_header>
10553 > _ACEOF
10554 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10555 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10556 >  ac_status=$?
10557 >  grep -v '^ *+' conftest.er1 >conftest.err
10558 >  rm -f conftest.er1
10559 >  cat conftest.err >&5
10560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10561 >  (exit $ac_status); } >/dev/null; then
10562 >  if test -s conftest.err; then
10563 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10564 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10565 >  else
10566 >    ac_cpp_err=
10567 >  fi
10568 > else
10569 >  ac_cpp_err=yes
10570 > fi
10571 > if test -z "$ac_cpp_err"; then
10572 >  ac_header_preproc=yes
10573 > else
10574 >  echo "$as_me: failed program was:" >&5
10575 > sed 's/^/| /' conftest.$ac_ext >&5
10576 >
10577 >  ac_header_preproc=no
10578 > fi
10579 > rm -f conftest.err conftest.$ac_ext
10580 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10581 > echo "${ECHO_T}$ac_header_preproc" >&6
10582 >
10583 > # So?  What about this header?
10584 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10585 >  yes:no: )
10586 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10587 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10588 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10589 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10590 >    ac_header_preproc=yes
10591 >    ;;
10592 >  no:yes:* )
10593 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10594 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10595 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10596 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10598 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10599 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10600 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10601 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10602 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10603 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10604 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10605 >    (
10606 >      cat <<\_ASBOX
10607 > ## ------------------------------ ##
10608 > ## Report this to gezelter@nd.edu ##
10609 > ## ------------------------------ ##
10610 > _ASBOX
10611 >    ) |
10612 >      sed "s/^/$as_me: WARNING:     /" >&2
10613 >    ;;
10614 > esac
10615 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10616 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10617 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10618 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10619 > else
10620 >  eval "$as_ac_Header=\$ac_header_preproc"
10621 > fi
10622 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10623 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10624 >
10625 > fi
10626 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10627 >  cat >>confdefs.h <<_ACEOF
10628 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10629 > _ACEOF
10630  
4669  # Passes both tests.
4670 ac_preproc_ok=:
4671 break
10631   fi
4673 rm -f conftest.err conftest.$ac_ext
10632  
10633   done
4676 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4677 rm -f conftest.err conftest.$ac_ext
4678 if $ac_preproc_ok; then
4679  :
4680 else
4681  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4682 See \`config.log' for more details." >&5
4683 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4684 See \`config.log' for more details." >&2;}
4685   { (exit 1); exit 1; }; }
4686 fi
10634  
4688 ac_ext=c
4689 ac_cpp='$CPP $CPPFLAGS'
4690 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4691 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4692 ac_compiler_gnu=$ac_cv_c_compiler_gnu
10635  
4694
4695 echo "$as_me:$LINENO: checking for egrep" >&5
4696 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4697 if test "${ac_cv_prog_egrep+set}" = set; then
4698  echo $ECHO_N "(cached) $ECHO_C" >&6
4699 else
4700  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4701    then ac_cv_prog_egrep='grep -E'
4702    else ac_cv_prog_egrep='egrep'
4703    fi
10636   fi
4705 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4706 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4707 EGREP=$ac_cv_prog_egrep
10637  
10638  
10639 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10640 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10641 < if test "${ac_cv_header_stdc+set}" = set; then
10639 >
10640 >
10641 >  if test "${ac_cv_header_iomanip+set}" = set; then
10642 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10643 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10644 > if test "${ac_cv_header_iomanip+set}" = set; then
10645    echo $ECHO_N "(cached) $ECHO_C" >&6
10646 + fi
10647 + echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10648 + echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10649   else
10650 <  cat >conftest.$ac_ext <<_ACEOF
10650 >  # Is the header compilable?
10651 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10652 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10653 > cat >conftest.$ac_ext <<_ACEOF
10654   /* confdefs.h.  */
10655   _ACEOF
10656   cat confdefs.h >>conftest.$ac_ext
10657   cat >>conftest.$ac_ext <<_ACEOF
10658   /* end confdefs.h.  */
10659 < #include <stdlib.h>
10660 < #include <stdarg.h>
4723 < #include <string.h>
4724 < #include <float.h>
4725 <
4726 < int
4727 < main ()
4728 < {
4729 <
4730 <  ;
4731 <  return 0;
4732 < }
10659 > $ac_includes_default
10660 > #include <iomanip>
10661   _ACEOF
10662   rm -f conftest.$ac_objext
10663   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 4740 | Line 10668 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10668    cat conftest.err >&5
10669    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10670    (exit $ac_status); } &&
10671 <         { ac_try='test -z "$ac_c_werror_flag"
10671 >         { ac_try='test -z "$ac_cxx_werror_flag"
10672                           || test ! -s conftest.err'
10673    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10674    (eval $ac_try) 2>&5
# Line 4753 | Line 10681 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10681    ac_status=$?
10682    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10683    (exit $ac_status); }; }; then
10684 <  ac_cv_header_stdc=yes
10684 >  ac_header_compiler=yes
10685   else
10686    echo "$as_me: failed program was:" >&5
10687   sed 's/^/| /' conftest.$ac_ext >&5
10688  
10689 < ac_cv_header_stdc=no
10689 > ac_header_compiler=no
10690   fi
10691   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10692 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10693 + echo "${ECHO_T}$ac_header_compiler" >&6
10694  
10695 < if test $ac_cv_header_stdc = yes; then
10696 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
10697 <  cat >conftest.$ac_ext <<_ACEOF
10695 > # Is the header present?
10696 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10697 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10698 > cat >conftest.$ac_ext <<_ACEOF
10699   /* confdefs.h.  */
10700   _ACEOF
10701   cat confdefs.h >>conftest.$ac_ext
10702   cat >>conftest.$ac_ext <<_ACEOF
10703   /* end confdefs.h.  */
10704 < #include <string.h>
4774 <
10704 > #include <iomanip>
10705   _ACEOF
10706 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10707 <  $EGREP "memchr" >/dev/null 2>&1; then
10708 <  :
10706 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10707 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10708 >  ac_status=$?
10709 >  grep -v '^ *+' conftest.er1 >conftest.err
10710 >  rm -f conftest.er1
10711 >  cat conftest.err >&5
10712 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10713 >  (exit $ac_status); } >/dev/null; then
10714 >  if test -s conftest.err; then
10715 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10716 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10717 >  else
10718 >    ac_cpp_err=
10719 >  fi
10720   else
10721 <  ac_cv_header_stdc=no
10721 >  ac_cpp_err=yes
10722   fi
10723 < rm -f conftest*
10723 > if test -z "$ac_cpp_err"; then
10724 >  ac_header_preproc=yes
10725 > else
10726 >  echo "$as_me: failed program was:" >&5
10727 > sed 's/^/| /' conftest.$ac_ext >&5
10728  
10729 +  ac_header_preproc=no
10730   fi
10731 + rm -f conftest.err conftest.$ac_ext
10732 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10733 + echo "${ECHO_T}$ac_header_preproc" >&6
10734  
10735 < if test $ac_cv_header_stdc = yes; then
10736 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
10737 <  cat >conftest.$ac_ext <<_ACEOF
10738 < /* confdefs.h.  */
10739 < _ACEOF
10740 < cat confdefs.h >>conftest.$ac_ext
10741 < cat >>conftest.$ac_ext <<_ACEOF
10742 < /* end confdefs.h.  */
10743 < #include <stdlib.h>
10744 <
10745 < _ACEOF
10746 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10747 <  $EGREP "free" >/dev/null 2>&1; then
10748 <  :
10735 > # So?  What about this header?
10736 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10737 >  yes:no: )
10738 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10739 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10740 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10741 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10742 >    ac_header_preproc=yes
10743 >    ;;
10744 >  no:yes:* )
10745 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10746 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10747 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10748 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10749 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10750 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10751 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10752 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10753 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10754 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10755 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10756 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10757 >    (
10758 >      cat <<\_ASBOX
10759 > ## ------------------------------ ##
10760 > ## Report this to gezelter@nd.edu ##
10761 > ## ------------------------------ ##
10762 > _ASBOX
10763 >    ) |
10764 >      sed "s/^/$as_me: WARNING:     /" >&2
10765 >    ;;
10766 > esac
10767 > echo "$as_me:$LINENO: checking for iomanip" >&5
10768 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10769 > if test "${ac_cv_header_iomanip+set}" = set; then
10770 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10771   else
10772 <  ac_cv_header_stdc=no
10772 >  ac_cv_header_iomanip=$ac_header_preproc
10773   fi
10774 < rm -f conftest*
10774 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10775 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10776  
10777   fi
10778 + if test $ac_cv_header_iomanip = yes; then
10779  
4807 if test $ac_cv_header_stdc = yes; then
4808  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4809  if test "$cross_compiling" = yes; then
4810  :
4811 else
4812  cat >conftest.$ac_ext <<_ACEOF
4813 /* confdefs.h.  */
4814 _ACEOF
4815 cat confdefs.h >>conftest.$ac_ext
4816 cat >>conftest.$ac_ext <<_ACEOF
4817 /* end confdefs.h.  */
4818 #include <ctype.h>
4819 #if ((' ' & 0x0FF) == 0x020)
4820 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4821 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4822 #else
4823 # define ISLOWER(c) \
4824                   (('a' <= (c) && (c) <= 'i') \
4825                     || ('j' <= (c) && (c) <= 'r') \
4826                     || ('s' <= (c) && (c) <= 'z'))
4827 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4828 #endif
10780  
4830 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4831 int
4832 main ()
4833 {
4834  int i;
4835  for (i = 0; i < 256; i++)
4836    if (XOR (islower (i), ISLOWER (i))
4837        || toupper (i) != TOUPPER (i))
4838      exit(2);
4839  exit (0);
4840 }
4841 _ACEOF
4842 rm -f conftest$ac_exeext
4843 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4844  (eval $ac_link) 2>&5
4845  ac_status=$?
4846  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4847  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4848  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4849  (eval $ac_try) 2>&5
4850  ac_status=$?
4851  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4852  (exit $ac_status); }; }; then
4853  :
4854 else
4855  echo "$as_me: program exited with status $ac_status" >&5
4856 echo "$as_me: failed program was:" >&5
4857 sed 's/^/| /' conftest.$ac_ext >&5
4858
4859 ( exit $ac_status )
4860 ac_cv_header_stdc=no
4861 fi
4862 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4863 fi
4864 fi
4865 fi
4866 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4867 echo "${ECHO_T}$ac_cv_header_stdc" >&6
4868 if test $ac_cv_header_stdc = yes; then
4869
10781   cat >>confdefs.h <<\_ACEOF
10782 < #define STDC_HEADERS 1
10782 > #define HAVE_IOMANIP 1
10783   _ACEOF
10784  
4874 fi
10785  
10786 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
10786 > else
10787  
10788  
10789 <
4880 <
4881 <
4882 <
4883 <
4884 <
4885 <
4886 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4887 <                  inttypes.h stdint.h unistd.h
10789 > for ac_header in iomanip.h
10790   do
10791   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10792 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10792 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10793 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10794   echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10795   if eval "test \"\${$as_ac_Header+set}\" = set"; then
10796    echo $ECHO_N "(cached) $ECHO_C" >&6
10797 + fi
10798 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10799 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10800   else
10801 <  cat >conftest.$ac_ext <<_ACEOF
10801 >  # Is the header compilable?
10802 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10803 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10804 > cat >conftest.$ac_ext <<_ACEOF
10805   /* confdefs.h.  */
10806   _ACEOF
10807   cat confdefs.h >>conftest.$ac_ext
10808   cat >>conftest.$ac_ext <<_ACEOF
10809   /* end confdefs.h.  */
10810   $ac_includes_default
4902
10811   #include <$ac_header>
10812   _ACEOF
10813   rm -f conftest.$ac_objext
# Line 4911 | Line 10819 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10819    cat conftest.err >&5
10820    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10821    (exit $ac_status); } &&
10822 <         { ac_try='test -z "$ac_c_werror_flag"
10822 >         { ac_try='test -z "$ac_cxx_werror_flag"
10823                           || test ! -s conftest.err'
10824    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10825    (eval $ac_try) 2>&5
# Line 4924 | Line 10832 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10832    ac_status=$?
10833    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10834    (exit $ac_status); }; }; then
10835 <  eval "$as_ac_Header=yes"
10835 >  ac_header_compiler=yes
10836   else
10837    echo "$as_me: failed program was:" >&5
10838   sed 's/^/| /' conftest.$ac_ext >&5
10839  
10840 < eval "$as_ac_Header=no"
10840 > ac_header_compiler=no
10841   fi
10842   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10843 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10844 + echo "${ECHO_T}$ac_header_compiler" >&6
10845 +
10846 + # Is the header present?
10847 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
10848 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10849 + cat >conftest.$ac_ext <<_ACEOF
10850 + /* confdefs.h.  */
10851 + _ACEOF
10852 + cat confdefs.h >>conftest.$ac_ext
10853 + cat >>conftest.$ac_ext <<_ACEOF
10854 + /* end confdefs.h.  */
10855 + #include <$ac_header>
10856 + _ACEOF
10857 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10858 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10859 +  ac_status=$?
10860 +  grep -v '^ *+' conftest.er1 >conftest.err
10861 +  rm -f conftest.er1
10862 +  cat conftest.err >&5
10863 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10864 +  (exit $ac_status); } >/dev/null; then
10865 +  if test -s conftest.err; then
10866 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
10867 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10868 +  else
10869 +    ac_cpp_err=
10870 +  fi
10871 + else
10872 +  ac_cpp_err=yes
10873 + fi
10874 + if test -z "$ac_cpp_err"; then
10875 +  ac_header_preproc=yes
10876 + else
10877 +  echo "$as_me: failed program was:" >&5
10878 + sed 's/^/| /' conftest.$ac_ext >&5
10879 +
10880 +  ac_header_preproc=no
10881 + fi
10882 + rm -f conftest.err conftest.$ac_ext
10883 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10884 + echo "${ECHO_T}$ac_header_preproc" >&6
10885 +
10886 + # So?  What about this header?
10887 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10888 +  yes:no: )
10889 +    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10890 + echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10891 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10892 + echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10893 +    ac_header_preproc=yes
10894 +    ;;
10895 +  no:yes:* )
10896 +    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10897 + echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10898 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10899 + echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10900 +    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10901 + echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10902 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10903 + echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10904 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10905 + echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10906 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10907 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10908 +    (
10909 +      cat <<\_ASBOX
10910 + ## ------------------------------ ##
10911 + ## Report this to gezelter@nd.edu ##
10912 + ## ------------------------------ ##
10913 + _ASBOX
10914 +    ) |
10915 +      sed "s/^/$as_me: WARNING:     /" >&2
10916 +    ;;
10917 + esac
10918 + echo "$as_me:$LINENO: checking for $ac_header" >&5
10919 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10920 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
10921 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10922 + else
10923 +  eval "$as_ac_Header=\$ac_header_preproc"
10924   fi
10925   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10926   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10927 +
10928 + fi
10929   if test `eval echo '${'$as_ac_Header'}'` = yes; then
10930    cat >>confdefs.h <<_ACEOF
10931   #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
# Line 4945 | Line 10936 | done
10936   done
10937  
10938  
10939 + fi
10940  
10941  
10942  
10943  
10944 <
4953 <
4954 <
4955 <
4956 <
4957 < for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
10944 > for ac_header in cmath
10945   do
10946   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10947   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 4987 | Line 10974 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10974    cat conftest.err >&5
10975    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10976    (exit $ac_status); } &&
10977 <         { ac_try='test -z "$ac_c_werror_flag"
10977 >         { ac_try='test -z "$ac_cxx_werror_flag"
10978                           || test ! -s conftest.err'
10979    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10980    (eval $ac_try) 2>&5
# Line 5031 | Line 11018 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11018    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11019    (exit $ac_status); } >/dev/null; then
11020    if test -s conftest.err; then
11021 <    ac_cpp_err=$ac_c_preproc_warn_flag
11022 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11021 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11022 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11023    else
11024      ac_cpp_err=
11025    fi
# Line 5052 | Line 11039 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11039   echo "${ECHO_T}$ac_header_preproc" >&6
11040  
11041   # So?  What about this header?
11042 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11042 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11043    yes:no: )
11044      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11045   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 5106 | Line 11093 | done
11093  
11094  
11095  
11096 +  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11097 + echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11098 + if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11099 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11100 + else
11101  
11102 +      ac_cv_cxx_have_std_iostream=no
11103 +      ac_cv_cxx_need_use_std_iostream=no
11104 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11105  
11106 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
11107 < do
11108 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11109 < echo "$as_me:$LINENO: checking for $ac_func" >&5
11110 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
11111 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11112 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11113 < else
5119 <  cat >conftest.$ac_ext <<_ACEOF
11106 >
11107 >        ac_ext=cc
11108 > ac_cpp='$CXXCPP $CPPFLAGS'
11109 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11110 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11111 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11112 >
11113 >        cat >conftest.$ac_ext <<_ACEOF
11114   /* confdefs.h.  */
11115   _ACEOF
11116   cat confdefs.h >>conftest.$ac_ext
11117   cat >>conftest.$ac_ext <<_ACEOF
11118   /* end confdefs.h.  */
5125 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5126   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5127 #define $ac_func innocuous_$ac_func
11119  
11120 < /* System header to define __stub macros and hopefully few prototypes,
11121 <    which can conflict with char $ac_func (); below.
5131 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5132 <    <limits.h> exists even on freestanding compilers.  */
5133 <
5134 < #ifdef __STDC__
5135 < # include <limits.h>
11120 > #ifdef HAVE_IOSTREAM
11121 > #include <iostream>
11122   #else
11123 < # include <assert.h>
11123 > #include <iostream.h>
11124   #endif
11125  
11126 < #undef $ac_func
11127 <
11128 < /* Override any gcc2 internal prototype to avoid an error.  */
11129 < #ifdef __cplusplus
11130 < extern "C"
11131 < {
11126 > #ifdef FC_DUMMY_MAIN
11127 > #ifndef FC_DUMMY_MAIN_EQ_F77
11128 > #  ifdef __cplusplus
11129 >     extern "C"
11130 > #  endif
11131 >   int FC_DUMMY_MAIN() { return 1; }
11132   #endif
11133 < /* We use char because int might match the return type of a gcc2
11134 <   builtin and then its argument prototype would still apply.  */
11135 < char $ac_func ();
11136 < /* The GNU C library defines this for functions which it implements
11137 <    to always fail with ENOSYS.  Some functions are actually named
11138 <    something starting with __ and the normal name is an alias.  */
11139 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11140 < choke me
11133 > #endif
11134 > int
11135 > main ()
11136 > {
11137 > std::cout<<"Hello World"<<std::endl;return 0;
11138 >  ;
11139 >  return 0;
11140 > }
11141 > _ACEOF
11142 > rm -f conftest.$ac_objext
11143 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11144 >  (eval $ac_compile) 2>conftest.er1
11145 >  ac_status=$?
11146 >  grep -v '^ *+' conftest.er1 >conftest.err
11147 >  rm -f conftest.er1
11148 >  cat conftest.err >&5
11149 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11150 >  (exit $ac_status); } &&
11151 >         { ac_try='test -z "$ac_cxx_werror_flag"
11152 >                         || test ! -s conftest.err'
11153 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11154 >  (eval $ac_try) 2>&5
11155 >  ac_status=$?
11156 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11157 >  (exit $ac_status); }; } &&
11158 >         { ac_try='test -s conftest.$ac_objext'
11159 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11160 >  (eval $ac_try) 2>&5
11161 >  ac_status=$?
11162 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11163 >  (exit $ac_status); }; }; then
11164 >  ac_cv_cxx_have_std_iostream=yes
11165 > else
11166 >  echo "$as_me: failed program was:" >&5
11167 > sed 's/^/| /' conftest.$ac_ext >&5
11168 >
11169 > fi
11170 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11171 >        cat >conftest.$ac_ext <<_ACEOF
11172 > /* confdefs.h.  */
11173 > _ACEOF
11174 > cat confdefs.h >>conftest.$ac_ext
11175 > cat >>conftest.$ac_ext <<_ACEOF
11176 > /* end confdefs.h.  */
11177 >
11178 > #define __USE_STD_IOSTREAM 1
11179 > #ifdef HAVE_IOSTREAM
11180 > #include <iostream>
11181   #else
11182 < char (*f) () = $ac_func;
11182 > #include <iostream.h>
11183   #endif
11184 < #ifdef __cplusplus
11184 >
11185 > #ifdef FC_DUMMY_MAIN
11186 > #ifndef FC_DUMMY_MAIN_EQ_F77
11187 > #  ifdef __cplusplus
11188 >     extern "C"
11189 > #  endif
11190 >   int FC_DUMMY_MAIN() { return 1; }
11191 > #endif
11192 > #endif
11193 > int
11194 > main ()
11195 > {
11196 > std::cout<<"Hello World"<<std::endl;return 0;
11197 >  ;
11198 >  return 0;
11199   }
11200 < #endif
11200 > _ACEOF
11201 > rm -f conftest.$ac_objext
11202 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11203 >  (eval $ac_compile) 2>conftest.er1
11204 >  ac_status=$?
11205 >  grep -v '^ *+' conftest.er1 >conftest.err
11206 >  rm -f conftest.er1
11207 >  cat conftest.err >&5
11208 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11209 >  (exit $ac_status); } &&
11210 >         { ac_try='test -z "$ac_cxx_werror_flag"
11211 >                         || test ! -s conftest.err'
11212 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11213 >  (eval $ac_try) 2>&5
11214 >  ac_status=$?
11215 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11216 >  (exit $ac_status); }; } &&
11217 >         { ac_try='test -s conftest.$ac_objext'
11218 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11219 >  (eval $ac_try) 2>&5
11220 >  ac_status=$?
11221 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11222 >  (exit $ac_status); }; }; then
11223 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11224 > else
11225 >  echo "$as_me: failed program was:" >&5
11226 > sed 's/^/| /' conftest.$ac_ext >&5
11227  
11228 + fi
11229 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11230 +        ac_ext=cc
11231 + ac_cpp='$CXXCPP $CPPFLAGS'
11232 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11233 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11234 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11235 +
11236 +      fi
11237 +
11238 + fi
11239 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11240 + echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11241 +  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11242 +
11243 + cat >>confdefs.h <<\_ACEOF
11244 + #define HAVE_STD_IOSTREAM 1
11245 + _ACEOF
11246 +
11247 +  fi
11248 +  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11249 +
11250 + cat >>confdefs.h <<\_ACEOF
11251 + #define __USE_STD_IOSTREAM 1
11252 + _ACEOF
11253 +
11254 +  fi
11255 +
11256 +
11257 +
11258 +
11259 +  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11260 + echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11261 + if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11262 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11263 + else
11264 +
11265 +      ac_cv_cxx_have_std_stl=no
11266 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11267 +
11268 +
11269 +        ac_ext=cc
11270 + ac_cpp='$CXXCPP $CPPFLAGS'
11271 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11272 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11273 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11274 +
11275 +        cat >conftest.$ac_ext <<_ACEOF
11276 + /* confdefs.h.  */
11277 + _ACEOF
11278 + cat confdefs.h >>conftest.$ac_ext
11279 + cat >>conftest.$ac_ext <<_ACEOF
11280 + /* end confdefs.h.  */
11281 + #include <list>
11282 +
11283 + #ifdef FC_DUMMY_MAIN
11284 + #ifndef FC_DUMMY_MAIN_EQ_F77
11285 + #  ifdef __cplusplus
11286 +     extern "C"
11287 + #  endif
11288 +   int FC_DUMMY_MAIN() { return 1; }
11289 + #endif
11290 + #endif
11291   int
11292   main ()
11293   {
11294 < return f != $ac_func;
11294 > std::list<int> foo;return 0;
11295    ;
11296    return 0;
11297   }
11298   _ACEOF
11299 < rm -f conftest.$ac_objext conftest$ac_exeext
11300 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11301 <  (eval $ac_link) 2>conftest.er1
11299 > rm -f conftest.$ac_objext
11300 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11301 >  (eval $ac_compile) 2>conftest.er1
11302    ac_status=$?
11303    grep -v '^ *+' conftest.er1 >conftest.err
11304    rm -f conftest.er1
11305    cat conftest.err >&5
11306    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11307    (exit $ac_status); } &&
11308 <         { ac_try='test -z "$ac_c_werror_flag"
11308 >         { ac_try='test -z "$ac_cxx_werror_flag"
11309                           || test ! -s conftest.err'
11310    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11311    (eval $ac_try) 2>&5
11312    ac_status=$?
11313    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11314    (exit $ac_status); }; } &&
11315 <         { ac_try='test -s conftest$ac_exeext'
11315 >         { ac_try='test -s conftest.$ac_objext'
11316    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11317    (eval $ac_try) 2>&5
11318    ac_status=$?
11319    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11320    (exit $ac_status); }; }; then
11321 <  eval "$as_ac_var=yes"
11321 >  ac_cv_cxx_have_std_stl=yes
11322   else
11323    echo "$as_me: failed program was:" >&5
11324   sed 's/^/| /' conftest.$ac_ext >&5
11325  
5197 eval "$as_ac_var=no"
11326   fi
11327 < rm -f conftest.err conftest.$ac_objext \
11328 <      conftest$ac_exeext conftest.$ac_ext
11327 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11328 >        ac_ext=cc
11329 > ac_cpp='$CXXCPP $CPPFLAGS'
11330 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11331 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11332 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11333 >
11334 >      fi
11335 >
11336   fi
11337 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11338 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11339 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11340 <  cat >>confdefs.h <<_ACEOF
11341 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11337 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11338 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11339 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11340 >
11341 > cat >>confdefs.h <<\_ACEOF
11342 > #define HAVE_STD_STL 1
11343   _ACEOF
11344  
11345 < fi
5210 < done
11345 >  fi
11346  
11347 < # special check for _system_configuration because AIX <4.3.2 do not
11348 < # contain the `physmem' member.
11349 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11350 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
11351 < cat >conftest.$ac_ext <<_ACEOF
11347 >
11348 >
11349 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11350 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11351 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11352 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11353 > else
11354 >
11355 >    ac_cv_cxx_have_fstream_attach=no
11356 >
11357 >
11358 >    ac_ext=cc
11359 > ac_cpp='$CXXCPP $CPPFLAGS'
11360 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11361 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11362 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11363 >
11364 >    cat >conftest.$ac_ext <<_ACEOF
11365   /* confdefs.h.  */
11366   _ACEOF
11367   cat confdefs.h >>conftest.$ac_ext
11368   cat >>conftest.$ac_ext <<_ACEOF
11369   /* end confdefs.h.  */
11370 < #include <sys/systemcfg.h>
11370 >
11371 > #ifdef HAVE_IOSTREAM
11372 > #include <fstream>
11373 > #else
11374 > #include <fstream.h>
11375 > #endif
11376 > #ifdef HAVE_STD_IOSTREAM
11377 > using namespace std;
11378 > #endif
11379 >
11380 > #ifdef FC_DUMMY_MAIN
11381 > #ifndef FC_DUMMY_MAIN_EQ_F77
11382 > #  ifdef __cplusplus
11383 >     extern "C"
11384 > #  endif
11385 >   int FC_DUMMY_MAIN() { return 1; }
11386 > #endif
11387 > #endif
11388   int
11389   main ()
11390   {
11391 < double x = _system_configuration.physmem;
11391 > int fd=0;ofstream s;s.attach(fd);
11392    ;
11393    return 0;
11394   }
# Line 5237 | Line 11402 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11402    cat conftest.err >&5
11403    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11404    (exit $ac_status); } &&
11405 <         { ac_try='test -z "$ac_c_werror_flag"
11405 >         { ac_try='test -z "$ac_cxx_werror_flag"
11406                           || test ! -s conftest.err'
11407    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11408    (eval $ac_try) 2>&5
# Line 5250 | Line 11415 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11415    ac_status=$?
11416    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11417    (exit $ac_status); }; }; then
11418 <  echo "$as_me:$LINENO: result: yes" >&5
11419 < echo "${ECHO_T}yes" >&6
11418 >  ac_cv_cxx_have_fstream_attach=yes
11419 > else
11420 >  echo "$as_me: failed program was:" >&5
11421 > sed 's/^/| /' conftest.$ac_ext >&5
11422  
11423 + fi
11424 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11425 +    ac_ext=cc
11426 + ac_cpp='$CXXCPP $CPPFLAGS'
11427 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11428 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11429 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11430 +
11431 +
11432 + fi
11433 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11434 + echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11435 +  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11436 +
11437   cat >>confdefs.h <<\_ACEOF
11438 < #define HAVE__SYSTEM_CONFIGURATION 1
11438 > #define HAVE_FSTREAM_ATTACH 1
11439   _ACEOF
11440  
11441 +  fi
11442 +
11443 +
11444 +
11445 +  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11446 + echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11447 + if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11448 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11449   else
11450 +
11451 +    ac_cv_cxx_have_fstream_open=no
11452 +    ac_cv_cxx_fstream_open_prot=no
11453 +
11454 +
11455 +    ac_ext=cc
11456 + ac_cpp='$CXXCPP $CPPFLAGS'
11457 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11458 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11459 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11460 +
11461 +    # Try with 2 parameters
11462 +    cat >conftest.$ac_ext <<_ACEOF
11463 + /* confdefs.h.  */
11464 + _ACEOF
11465 + cat confdefs.h >>conftest.$ac_ext
11466 + cat >>conftest.$ac_ext <<_ACEOF
11467 + /* end confdefs.h.  */
11468 +
11469 + #ifdef HAVE_IOSTREAM
11470 + #include <fstream>
11471 + #else
11472 + #include <fstream.h>
11473 + #endif
11474 + #ifdef HAVE_STD_IOSTREAM
11475 + using namespace std;
11476 + #endif
11477 +
11478 + #ifdef FC_DUMMY_MAIN
11479 + #ifndef FC_DUMMY_MAIN_EQ_F77
11480 + #  ifdef __cplusplus
11481 +     extern "C"
11482 + #  endif
11483 +   int FC_DUMMY_MAIN() { return 1; }
11484 + #endif
11485 + #endif
11486 + int
11487 + main ()
11488 + {
11489 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11490 +  ;
11491 +  return 0;
11492 + }
11493 + _ACEOF
11494 + rm -f conftest.$ac_objext
11495 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11496 +  (eval $ac_compile) 2>conftest.er1
11497 +  ac_status=$?
11498 +  grep -v '^ *+' conftest.er1 >conftest.err
11499 +  rm -f conftest.er1
11500 +  cat conftest.err >&5
11501 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11502 +  (exit $ac_status); } &&
11503 +         { ac_try='test -z "$ac_cxx_werror_flag"
11504 +                         || test ! -s conftest.err'
11505 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11506 +  (eval $ac_try) 2>&5
11507 +  ac_status=$?
11508 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11509 +  (exit $ac_status); }; } &&
11510 +         { ac_try='test -s conftest.$ac_objext'
11511 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11512 +  (eval $ac_try) 2>&5
11513 +  ac_status=$?
11514 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11515 +  (exit $ac_status); }; }; then
11516 +  ac_cv_cxx_have_fstream_open=yes
11517 + else
11518    echo "$as_me: failed program was:" >&5
11519   sed 's/^/| /' conftest.$ac_ext >&5
11520  
5264 echo "$as_me:$LINENO: result: no" >&5
5265 echo "${ECHO_T}no" >&6
11521   fi
11522   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11523 +    # Try with mode parameter
11524 +    cat >conftest.$ac_ext <<_ACEOF
11525 + /* confdefs.h.  */
11526 + _ACEOF
11527 + cat confdefs.h >>conftest.$ac_ext
11528 + cat >>conftest.$ac_ext <<_ACEOF
11529 + /* end confdefs.h.  */
11530  
11531 <  # clean out junk possibly left behind by a previous configuration
11532 <  rm -f src/getopt.h
11533 <  # Check for getopt_long support
11531 > #ifdef HAVE_IOSTREAM
11532 > #include <fstream>
11533 > #else
11534 > #include <fstream.h>
11535 > #endif
11536 > #ifdef HAVE_STD_IOSTREAM
11537 > using namespace std;
11538 > #endif
11539  
11540 < for ac_header in getopt.h
11540 > #ifdef FC_DUMMY_MAIN
11541 > #ifndef FC_DUMMY_MAIN_EQ_F77
11542 > #  ifdef __cplusplus
11543 >     extern "C"
11544 > #  endif
11545 >   int FC_DUMMY_MAIN() { return 1; }
11546 > #endif
11547 > #endif
11548 > int
11549 > main ()
11550 > {
11551 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11552 >  ;
11553 >  return 0;
11554 > }
11555 > _ACEOF
11556 > rm -f conftest.$ac_objext
11557 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11558 >  (eval $ac_compile) 2>conftest.er1
11559 >  ac_status=$?
11560 >  grep -v '^ *+' conftest.er1 >conftest.err
11561 >  rm -f conftest.er1
11562 >  cat conftest.err >&5
11563 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11564 >  (exit $ac_status); } &&
11565 >         { ac_try='test -z "$ac_cxx_werror_flag"
11566 >                         || test ! -s conftest.err'
11567 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11568 >  (eval $ac_try) 2>&5
11569 >  ac_status=$?
11570 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11571 >  (exit $ac_status); }; } &&
11572 >         { ac_try='test -s conftest.$ac_objext'
11573 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11574 >  (eval $ac_try) 2>&5
11575 >  ac_status=$?
11576 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11577 >  (exit $ac_status); }; }; then
11578 >  ac_cv_cxx_fstream_open_prot=yes
11579 > else
11580 >  echo "$as_me: failed program was:" >&5
11581 > sed 's/^/| /' conftest.$ac_ext >&5
11582 >
11583 > fi
11584 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11585 >    ac_ext=cc
11586 > ac_cpp='$CXXCPP $CPPFLAGS'
11587 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11588 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11589 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11590 >
11591 >
11592 > fi
11593 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11594 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11595 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11596 >
11597 > cat >>confdefs.h <<\_ACEOF
11598 > #define HAVE_FSTREAM_OPEN 1
11599 > _ACEOF
11600 >
11601 >  fi
11602 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11603 >
11604 > cat >>confdefs.h <<\_ACEOF
11605 > #define FSTREAM_OPEN_PROT 1
11606 > _ACEOF
11607 >
11608 >  fi
11609 >
11610 >
11611 >
11612 >
11613 >
11614 >
11615 >
11616 > for ac_header in ctype.h iostream fstream sstream strstream
11617   do
11618   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11619   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5303 | Line 11646 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11646    cat conftest.err >&5
11647    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648    (exit $ac_status); } &&
11649 <         { ac_try='test -z "$ac_c_werror_flag"
11649 >         { ac_try='test -z "$ac_cxx_werror_flag"
11650                           || test ! -s conftest.err'
11651    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11652    (eval $ac_try) 2>&5
# Line 5347 | Line 11690 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11690    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11691    (exit $ac_status); } >/dev/null; then
11692    if test -s conftest.err; then
11693 <    ac_cpp_err=$ac_c_preproc_warn_flag
11694 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11693 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11694 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11695    else
11696      ac_cpp_err=
11697    fi
# Line 5368 | Line 11711 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
11711   echo "${ECHO_T}$ac_header_preproc" >&6
11712  
11713   # So?  What about this header?
11714 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11714 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11715    yes:no: )
11716      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11717   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 5419 | Line 11762 | done
11762  
11763   done
11764  
11765 + # AC_CPP_FUNC
11766 + # ------------------ #
11767 + # Checks to see if ANSI C99 CPP variable __func__ works.
11768 + # If not, perhaps __FUNCTION__ works instead.
11769 + # If not, we'll just define __func__ to "".
11770 + # AC_CPP_FUNC
11771  
11772 < for ac_func in getopt_long
11773 < do
11774 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11775 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5427 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5428 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11772 >
11773 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11774 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11775 > if test "${ac_cv_cpp_func+set}" = set; then
11776    echo $ECHO_N "(cached) $ECHO_C" >&6
11777   else
11778    cat >conftest.$ac_ext <<_ACEOF
# Line 5434 | Line 11781 | cat >>conftest.$ac_ext <<_ACEOF
11781   cat confdefs.h >>conftest.$ac_ext
11782   cat >>conftest.$ac_ext <<_ACEOF
11783   /* end confdefs.h.  */
5437 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5438   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5439 #define $ac_func innocuous_$ac_func
11784  
11785 < /* System header to define __stub macros and hopefully few prototypes,
11786 <    which can conflict with char $ac_func (); below.
11787 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11788 <    <limits.h> exists even on freestanding compilers.  */
11789 <
11790 < #ifdef __STDC__
5447 < # include <limits.h>
5448 < #else
5449 < # include <assert.h>
11785 > #ifdef FC_DUMMY_MAIN
11786 > #ifndef FC_DUMMY_MAIN_EQ_F77
11787 > #  ifdef __cplusplus
11788 >     extern "C"
11789 > #  endif
11790 >   int FC_DUMMY_MAIN() { return 1; }
11791   #endif
5451
5452 #undef $ac_func
5453
5454 /* Override any gcc2 internal prototype to avoid an error.  */
5455 #ifdef __cplusplus
5456 extern "C"
5457 {
11792   #endif
5459 /* We use char because int might match the return type of a gcc2
5460   builtin and then its argument prototype would still apply.  */
5461 char $ac_func ();
5462 /* The GNU C library defines this for functions which it implements
5463    to always fail with ENOSYS.  Some functions are actually named
5464    something starting with __ and the normal name is an alias.  */
5465 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5466 choke me
5467 #else
5468 char (*f) () = $ac_func;
5469 #endif
5470 #ifdef __cplusplus
5471 }
5472 #endif
5473
11793   int
11794   main ()
11795   {
11796 < return f != $ac_func;
11796 > const char *foo = __func__;
11797    ;
11798    return 0;
11799   }
11800   _ACEOF
11801 < rm -f conftest.$ac_objext conftest$ac_exeext
11802 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11803 <  (eval $ac_link) 2>conftest.er1
11801 > rm -f conftest.$ac_objext
11802 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11803 >  (eval $ac_compile) 2>conftest.er1
11804    ac_status=$?
11805    grep -v '^ *+' conftest.er1 >conftest.err
11806    rm -f conftest.er1
11807    cat conftest.err >&5
11808    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11809    (exit $ac_status); } &&
11810 <         { ac_try='test -z "$ac_c_werror_flag"
11810 >         { ac_try='test -z "$ac_cxx_werror_flag"
11811                           || test ! -s conftest.err'
11812    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11813    (eval $ac_try) 2>&5
11814    ac_status=$?
11815    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11816    (exit $ac_status); }; } &&
11817 <         { ac_try='test -s conftest$ac_exeext'
11817 >         { ac_try='test -s conftest.$ac_objext'
11818    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11819    (eval $ac_try) 2>&5
11820    ac_status=$?
11821    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11822    (exit $ac_status); }; }; then
11823 <  eval "$as_ac_var=yes"
11823 >  ac_cv_cpp_func=yes
11824   else
11825    echo "$as_me: failed program was:" >&5
11826   sed 's/^/| /' conftest.$ac_ext >&5
11827  
5509 eval "$as_ac_var=no"
5510 fi
5511 rm -f conftest.err conftest.$ac_objext \
5512      conftest$ac_exeext conftest.$ac_ext
5513 fi
5514 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5515 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5516 if test `eval echo '${'$as_ac_var'}'` = yes; then
5517  cat >>confdefs.h <<_ACEOF
5518 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5519 _ACEOF
5520
5521 else
5522  # FreeBSD has a gnugetopt library for this
5523    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5524 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5525 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5526  echo $ECHO_N "(cached) $ECHO_C" >&6
5527 else
5528  ac_check_lib_save_LIBS=$LIBS
5529 LIBS="-lgnugetopt  $LIBS"
11828   cat >conftest.$ac_ext <<_ACEOF
11829   /* confdefs.h.  */
11830   _ACEOF
11831 < cat confdefs.h >>conftest.$ac_ext
11832 < cat >>conftest.$ac_ext <<_ACEOF
11833 < /* end confdefs.h.  */
11834 <
11835 < /* Override any gcc2 internal prototype to avoid an error.  */
11836 < #ifdef __cplusplus
11837 < extern "C"
11831 > cat confdefs.h >>conftest.$ac_ext
11832 > cat >>conftest.$ac_ext <<_ACEOF
11833 > /* end confdefs.h.  */
11834 >
11835 > #ifdef FC_DUMMY_MAIN
11836 > #ifndef FC_DUMMY_MAIN_EQ_F77
11837 > #  ifdef __cplusplus
11838 >     extern "C"
11839 > #  endif
11840 >   int FC_DUMMY_MAIN() { return 1; }
11841 > #endif
11842   #endif
5541 /* We use char because int might match the return type of a gcc2
5542   builtin and then its argument prototype would still apply.  */
5543 char getopt_long ();
11843   int
11844   main ()
11845   {
11846 < getopt_long ();
11846 > const char *foo = __FUNCTION__;
11847    ;
11848    return 0;
11849   }
11850   _ACEOF
11851 < rm -f conftest.$ac_objext conftest$ac_exeext
11852 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11853 <  (eval $ac_link) 2>conftest.er1
11851 > rm -f conftest.$ac_objext
11852 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11853 >  (eval $ac_compile) 2>conftest.er1
11854    ac_status=$?
11855    grep -v '^ *+' conftest.er1 >conftest.err
11856    rm -f conftest.er1
11857    cat conftest.err >&5
11858    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11859    (exit $ac_status); } &&
11860 <         { ac_try='test -z "$ac_c_werror_flag"
11860 >         { ac_try='test -z "$ac_cxx_werror_flag"
11861                           || test ! -s conftest.err'
11862    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11863    (eval $ac_try) 2>&5
11864    ac_status=$?
11865    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11866    (exit $ac_status); }; } &&
11867 <         { ac_try='test -s conftest$ac_exeext'
11867 >         { ac_try='test -s conftest.$ac_objext'
11868    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11869    (eval $ac_try) 2>&5
11870    ac_status=$?
11871    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11872    (exit $ac_status); }; }; then
11873 <  ac_cv_lib_gnugetopt_getopt_long=yes
11873 >  ac_cv_cpp_func=__FUNCTION__
11874   else
11875    echo "$as_me: failed program was:" >&5
11876   sed 's/^/| /' conftest.$ac_ext >&5
11877  
11878 < ac_cv_lib_gnugetopt_getopt_long=no
11878 > ac_cv_cpp_func=no
11879   fi
11880 < rm -f conftest.err conftest.$ac_objext \
5582 <      conftest$ac_exeext conftest.$ac_ext
5583 < LIBS=$ac_check_lib_save_LIBS
11880 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11881   fi
11882 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11883 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11884 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11885 <  cat >>confdefs.h <<\_ACEOF
11886 < #define HAVE_GETOPT_LONG 1
11882 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11883 > fi
11884 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11885 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11886 > if test $ac_cv_cpp_func = __FUNCTION__; then
11887 >
11888 > cat >>confdefs.h <<\_ACEOF
11889 > #define __func__ __FUNCTION__
11890   _ACEOF
11891  
11892 < else
5593 <  # use the GNU replacement
5594 <      case $LIBOBJS in
5595 <    "getopt.$ac_objext"   | \
5596 <  *" getopt.$ac_objext"   | \
5597 <    "getopt.$ac_objext "* | \
5598 <  *" getopt.$ac_objext "* ) ;;
5599 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5600 < esac
11892 > elif test $ac_cv_cpp_func = no; then
11893  
11894 <      case $LIBOBJS in
11895 <    "getopt1.$ac_objext"   | \
11896 <  *" getopt1.$ac_objext"   | \
5605 <    "getopt1.$ac_objext "* | \
5606 <  *" getopt1.$ac_objext "* ) ;;
5607 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5608 < esac
11894 > cat >>confdefs.h <<\_ACEOF
11895 > #define __func__ ""
11896 > _ACEOF
11897  
5610                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
5611
11898   fi
11899  
5614 fi
5615 done
11900  
11901  
11902  
11903 +
11904   case $debug in
11905    1)
11906       ;;
11907    *)
11908 +
11909 +
11910 +
11911 +
11912 + # Try to determine "good" native compiler flags if none specified on command
11913 + # line
11914 +
11915 + if test "$ac_test_FFLAGS" != "set"; then
11916 +  FCFLAGS=""
11917 +  case "${host_cpu}-${host_os}" in
11918 +
11919 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11920 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11921 +                fi;;
11922 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11923 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11924 +                fi;;
11925 +   powerpc*-aix*)
11926 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11927 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11928 +                echo "*******************************************************"
11929 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11930 +                echo "*  recommended that you use                           *"
11931 +                echo "*                                                     *"
11932 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11933 +                echo "*                                 ^^^                 *"
11934 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11935 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11936 +                echo "*******************************************************"
11937 +        fi;;
11938 +   *darwin*)
11939 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11940 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11941 +        fi
11942 +        if test "$FC" = ifort; then
11943 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11944 +        fi;;
11945 +  esac
11946 +
11947 +  if test -n "$CPU_FLAGS"; then
11948 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11949 +  fi
11950 +
11951 +  if test -z "$FCFLAGS"; then
11952 +        echo ""
11953 +        echo "*********************************************************"
11954 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11955 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11956 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11957 +        echo "*********************************************************"
11958 +        echo ""
11959 +        FCFLAGS="-O3"
11960 +  fi
11961 +
11962 +
11963 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11964 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11965 + if test "${ac_guessed_f90flags+set}" = set; then
11966 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11967 + else
11968  
11969  
11970  
11971 + ac_ext=${FC_SRCEXT-f}
11972 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11973 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11974 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11975  
11976 + echo 'program main' > conftest.$ac_ext
11977 + echo 'end program main' >> conftest.$ac_ext
11978 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11979 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11980 +  (eval $ac_compile) 2>&5
11981 +  ac_status=$?
11982 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11983 +  (exit $ac_status); }; then
11984 +        ac_guessed_f90flags=yes
11985 + else
11986 +        ac_guessed_f90flags=no
11987 + fi
11988 + rm -f conftest*
11989 + ac_ext=cc
11990 + ac_cpp='$CXXCPP $CPPFLAGS'
11991 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11992 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11993 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11994  
11995  
11996 + fi
11997 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
11998 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
11999 + if test "$ac_guessed_f90flags" = yes; then
12000 +        :
12001 +
12002 + else
12003 +        :
12004 +
12005 +        echo ""
12006 +        echo "**********************************************************"
12007 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12008 +        echo "* your compiler.                                        *"
12009 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12010 +        echo "*********************************************************"
12011 +        echo ""
12012 +        FCFLAGS=""
12013 +
12014 + fi
12015 +
12016 +
12017 + fi
12018 +
12019 +
12020 +
12021 +
12022 +
12023 +
12024 +
12025   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12026   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12027   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5634 | Line 12030 | cat > conftest.c <<EOF
12030  
12031   cat > conftest.c <<EOF
12032   #ifdef __GNUC__
12033 <  #ifndef __INTEL_COMPILER
12033 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12034 >     no;
12035 >  #else
12036       yes;
12037    #endif
12038   #endif
# Line 5672 | Line 12070 | if test "$ac_test_CFLAGS" != "set"; then
12070                      CFLAGS="-O"
12071                  fi;;
12072    sparc-solaris2*) if test "$CC" = cc; then
12073 <                    CFLAGS="-native -fast -xO5 -dalign"
12073 >                    CFLAGS="-O -dalign"
12074                   fi;;
12075  
12076    alpha*-osf*)  if test "$CC" = cc; then
# Line 5702 | Line 12100 | if test "$ac_test_CFLAGS" != "set"; then
12100     *darwin*)
12101          if test "$CC" = xlc -o "$CC" = cc; then
12102                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12103 +        fi
12104 +        if test "$CC" = icc; then
12105 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12106          fi;;
12107    esac
12108  
# Line 5715 | Line 12116 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12116      # -malign-double for x86 systems
12117  
12118  
12119 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12120 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12119 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12120 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12121   if test "${ac_align_double+set}" = set; then
12122    echo $ECHO_N "(cached) $ECHO_C" >&6
12123   else
12124    echo 'void f(){}' > conftest.c
12125 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12125 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12126          ac_align_double=yes
12127   else
12128          ac_align_double=no
# Line 5742 | Line 12143 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12143      # -fstrict-aliasing for gcc-2.95+
12144  
12145  
12146 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12147 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12146 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12147 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12148   if test "${ac_fstrict_aliasing+set}" = set; then
12149    echo $ECHO_N "(cached) $ECHO_C" >&6
12150   else
12151    echo 'void f(){}' > conftest.c
12152 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12152 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12153          ac_fstrict_aliasing=yes
12154   else
12155          ac_fstrict_aliasing=no
# Line 5773 | Line 12174 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12174                    case "${host_cpu}" in
12175            i586*)
12176  
12177 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12178 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12177 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12178 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12179   if test "${ac_cpu_pentium+set}" = set; then
12180    echo $ECHO_N "(cached) $ECHO_C" >&6
12181   else
12182    echo 'void f(){}' > conftest.c
12183 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12183 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12184          ac_cpu_pentium=yes
12185   else
12186          ac_cpu_pentium=no
# Line 5796 | Line 12197 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12197          :
12198  
12199  
12200 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12201 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12200 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12201 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12202   if test "${ac_pentium+set}" = set; then
12203    echo $ECHO_N "(cached) $ECHO_C" >&6
12204   else
12205    echo 'void f(){}' > conftest.c
12206 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12206 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12207          ac_pentium=yes
12208   else
12209          ac_pentium=no
# Line 5825 | Line 12226 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12226                    ;;
12227            i686*)
12228  
12229 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12230 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12229 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12230 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12231   if test "${ac_cpu_pentiumpro+set}" = set; then
12232    echo $ECHO_N "(cached) $ECHO_C" >&6
12233   else
12234    echo 'void f(){}' > conftest.c
12235 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12235 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12236          ac_cpu_pentiumpro=yes
12237   else
12238          ac_cpu_pentiumpro=no
# Line 5848 | Line 12249 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12249          :
12250  
12251  
12252 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12253 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12252 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12253 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12254   if test "${ac_pentiumpro+set}" = set; then
12255    echo $ECHO_N "(cached) $ECHO_C" >&6
12256   else
12257    echo 'void f(){}' > conftest.c
12258 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12258 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12259          ac_pentiumpro=yes
12260   else
12261          ac_pentiumpro=no
# Line 5881 | Line 12282 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12282                  if test -n "$is60x"; then
12283  
12284  
12285 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12286 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12285 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12286 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12287   if test "${ac_m_cpu_60x+set}" = set; then
12288    echo $ECHO_N "(cached) $ECHO_C" >&6
12289   else
12290    echo 'void f(){}' > conftest.c
12291 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12291 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12292          ac_m_cpu_60x=yes
12293   else
12294          ac_m_cpu_60x=no
# Line 5939 | Line 12340 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12340          :
12341  
12342  
12343 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12344 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12343 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12344 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12345   if test "${ac_m_cpu_750+set}" = set; then
12346    echo $ECHO_N "(cached) $ECHO_C" >&6
12347   else
12348    echo 'void f(){}' > conftest.c
12349 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12349 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12350          ac_m_cpu_750=yes
12351   else
12352          ac_m_cpu_750=no
# Line 5972 | Line 12373 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12373                  if test -z "$CPU_FLAGS"; then
12374  
12375  
12376 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12377 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12376 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12377 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12378   if test "${ac_m_cpu_powerpc+set}" = set; then
12379    echo $ECHO_N "(cached) $ECHO_C" >&6
12380   else
12381    echo 'void f(){}' > conftest.c
12382 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12382 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12383          ac_m_cpu_powerpc=yes
12384   else
12385          ac_m_cpu_powerpc=no
# Line 6000 | Line 12401 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12401                  if test -z "$CPU_FLAGS"; then
12402  
12403  
12404 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12405 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12404 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12405 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12406   if test "${ac_m_powerpc+set}" = set; then
12407    echo $ECHO_N "(cached) $ECHO_C" >&6
12408   else
12409    echo 'void f(){}' > conftest.c
12410 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12410 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12411          ac_m_powerpc=yes
12412   else
12413          ac_m_powerpc=no
# Line 6045 | Line 12446 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12446  
12447  
12448  
12449 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12450 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12449 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12450 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12451   if test "${ac_guessed_cflags+set}" = set; then
12452    echo $ECHO_N "(cached) $ECHO_C" >&6
12453   else
12454    echo 'void f(){}' > conftest.c
12455 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12455 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12456          ac_guessed_cflags=yes
12457   else
12458          ac_guessed_cflags=no
# Line 6095 | Line 12496 | cat > conftest.cpp <<EOF
12496  
12497   cat > conftest.cpp <<EOF
12498   #ifdef __GNUC__
12499 <  #ifndef __INTEL_COMPILER
12499 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12500 >     no;
12501 >  #else
12502       yes;
12503    #endif
12504   #endif
# Line 6133 | Line 12536 | if test "$ac_test_CXXFLAGS" != "set"; then
12536                      CXXFLAGS="-O"
12537                  fi;;
12538    sparc-solaris2*) if test "$CXX" = CC; then
12539 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12539 >                    CXXFLAGS="-features=extensions -O -dalign"
12540                   fi;;
12541     rs6000*-aix*)  if test "$CXX" = xlC; then
12542                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 6154 | Line 12557 | if test "$ac_test_CXXFLAGS" != "set"; then
12557     *darwin*)
12558          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12559                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12560 +        fi
12561 +        if test "$CXX" = icpc; then
12562 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12563          fi;;
12564    esac
12565  
# Line 6167 | Line 12573 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12573      # -malign-double for x86 systems
12574  
12575  
12576 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12577 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12576 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12577 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12578   if test "${ac_align_double+set}" = set; then
12579    echo $ECHO_N "(cached) $ECHO_C" >&6
12580   else
12581    echo 'void f(){}' > conftest.cpp
12582 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12582 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12583          ac_align_double=yes
12584   else
12585          ac_align_double=no
# Line 6194 | Line 12600 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12600      # -fstrict-aliasing for gcc-2.95+
12601  
12602  
12603 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12604 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12603 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12604 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12605   if test "${ac_fstrict_aliasing+set}" = set; then
12606    echo $ECHO_N "(cached) $ECHO_C" >&6
12607   else
12608    echo 'void f(){}' > conftest.cpp
12609 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12609 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12610          ac_fstrict_aliasing=yes
12611   else
12612          ac_fstrict_aliasing=no
# Line 6225 | Line 12631 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12631                    case "${host_cpu}" in
12632            i586*)
12633  
12634 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12635 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12634 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12635 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12636   if test "${ac_cpu_pentium+set}" = set; then
12637    echo $ECHO_N "(cached) $ECHO_C" >&6
12638   else
12639    echo 'void f(){}' > conftest.cpp
12640 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12640 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12641          ac_cpu_pentium=yes
12642   else
12643          ac_cpu_pentium=no
# Line 6248 | Line 12654 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12654          :
12655  
12656  
12657 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12658 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12657 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12658 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12659   if test "${ac_pentium+set}" = set; then
12660    echo $ECHO_N "(cached) $ECHO_C" >&6
12661   else
12662    echo 'void f(){}' > conftest.cpp
12663 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12663 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12664          ac_pentium=yes
12665   else
12666          ac_pentium=no
# Line 6277 | Line 12683 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12683                    ;;
12684            i686*)
12685  
12686 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12687 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12686 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12687 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12688   if test "${ac_cpu_pentiumpro+set}" = set; then
12689    echo $ECHO_N "(cached) $ECHO_C" >&6
12690   else
12691    echo 'void f(){}' > conftest.cpp
12692 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12692 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12693          ac_cpu_pentiumpro=yes
12694   else
12695          ac_cpu_pentiumpro=no
# Line 6300 | Line 12706 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12706          :
12707  
12708  
12709 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12710 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12709 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12710 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12711   if test "${ac_pentiumpro+set}" = set; then
12712    echo $ECHO_N "(cached) $ECHO_C" >&6
12713   else
12714    echo 'void f(){}' > conftest.cpp
12715 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12715 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12716          ac_pentiumpro=yes
12717   else
12718          ac_pentiumpro=no
# Line 6333 | Line 12739 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12739                  if test -n "$is60x"; then
12740  
12741  
12742 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12743 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12742 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12743 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12744   if test "${ac_m_cpu_60x+set}" = set; then
12745    echo $ECHO_N "(cached) $ECHO_C" >&6
12746   else
12747    echo 'void f(){}' > conftest.cpp
12748 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12748 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12749          ac_m_cpu_60x=yes
12750   else
12751          ac_m_cpu_60x=no
# Line 6391 | Line 12797 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12797          :
12798  
12799  
12800 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12801 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12800 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12801 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12802   if test "${ac_m_cpu_750+set}" = set; then
12803    echo $ECHO_N "(cached) $ECHO_C" >&6
12804   else
12805    echo 'void f(){}' > conftest.cpp
12806 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12806 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12807          ac_m_cpu_750=yes
12808   else
12809          ac_m_cpu_750=no
# Line 6424 | Line 12830 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12830                  if test -z "$CPU_FLAGS"; then
12831  
12832  
12833 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12834 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12833 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12834 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12835   if test "${ac_m_cpu_powerpc+set}" = set; then
12836    echo $ECHO_N "(cached) $ECHO_C" >&6
12837   else
12838    echo 'void f(){}' > conftest.cpp
12839 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12839 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12840          ac_m_cpu_powerpc=yes
12841   else
12842          ac_m_cpu_powerpc=no
# Line 6438 | Line 12844 | echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12844   rm -f conftest*
12845  
12846   fi
12847 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12848 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12849 < if test "$ac_m_cpu_powerpc" = yes; then
12850 <        :
12851 <        CPU_FLAGS=-mcpu=powerpc
6446 < else
6447 <        :
6448 <
6449 < fi
6450 <
6451 <                fi
6452 <                if test -z "$CPU_FLAGS"; then
6453 <
6454 <
6455 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
6456 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
6457 < if test "${ac_m_powerpc+set}" = set; then
6458 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6459 < else
6460 <  echo 'void f(){}' > conftest.cpp
6461 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
6462 <        ac_m_powerpc=yes
6463 < else
6464 <        ac_m_powerpc=no
6465 < fi
6466 < rm -f conftest*
6467 <
6468 < fi
6469 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
6470 < echo "${ECHO_T}$ac_m_powerpc" >&6
6471 < if test "$ac_m_powerpc" = yes; then
6472 <        :
6473 <        CPU_FLAGS=-mpowerpc
6474 < else
6475 <        :
6476 <
6477 < fi
6478 <
6479 <                fi
6480 <          esac
6481 <  fi
6482 <
6483 <  if test -n "$CPU_FLAGS"; then
6484 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6485 <  fi
6486 <
6487 <  if test -z "$CXXFLAGS"; then
6488 <        echo ""
6489 <        echo "**********************************************************"
6490 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6491 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6492 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6493 <        echo "**********************************************************"
6494 <        echo ""
6495 <        CXXFLAGS="-O3"
6496 <  fi
6497 <
6498 <
6499 <
6500 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6501 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6502 < if test "${ac_guessed_cxxflags+set}" = set; then
6503 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6504 < else
6505 <  echo 'void f(){}' > conftest.cpp
6506 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6507 <        ac_guessed_cxxflags=yes
6508 < else
6509 <        ac_guessed_cxxflags=no
6510 < fi
6511 < rm -f conftest*
6512 <
6513 < fi
6514 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6515 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6516 < if test "$ac_guessed_cxxflags" = yes; then
6517 <        :
6518 <
6519 < else
6520 <        :
6521 <
6522 <        echo ""
6523 <        echo "**********************************************************"
6524 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6525 <        echo "* your compiler.                                         *"
6526 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6527 <        echo "**********************************************************"
6528 <        echo ""
6529 <        CXXFLAGS=""
6530 <
6531 < fi
6532 <
6533 <
6534 < fi
6535 <
6536 <
6537 <
6538 <
6539 <
6540 < # Try to determine "good" native compiler flags if none specified on command
6541 < # line
6542 <
6543 < if test x"$F90FLAGS" = x ; then
6544 <  F90FLAGS=""
6545 <  case "${host_cpu}-${host_os}" in
6546 <
6547 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6548 <                    F90FLAGS="-O"
6549 <                fi;;
6550 <   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6551 <                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6552 <                fi;;
6553 <   powerpc*-aix*)
6554 <        if test "$F90" = f90 -o "$F90" = xlf90; then
6555 <                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6556 <                echo "*******************************************************"
6557 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6558 <                echo "*  recommended that you use                           *"
6559 <                echo "*                                                     *"
6560 <                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6561 <                echo "*                                 ^^^                 *"
6562 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6563 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6564 <                echo "*******************************************************"
6565 <        fi;;
6566 <   *darwin*)
6567 <        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6568 <                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6569 <        fi;;
6570 <  esac
6571 <
6572 <  if test -n "$CPU_FLAGS"; then
6573 <        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6574 <  fi
6575 <
6576 <  if test -z "$F90FLAGS"; then
6577 <        echo ""
6578 <        echo "**********************************************************"
6579 <        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6580 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6581 <        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6582 <        echo "**********************************************************"
6583 <        echo ""
6584 <        F90FLAGS="-O3"
6585 <  fi
6586 <
6587 <
6588 < echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6589 < echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6590 < if test "${ac_guessed_f90flags+set}" = set; then
6591 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6592 < else
6593 <
6594 <
6595 <
6596 < ac_ext=f90
6597 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6598 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6599 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6600 <
6601 < echo 'program main' > conftest.$ac_ext
6602 < echo 'end program main' >> conftest.$ac_ext
6603 < ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6604 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6605 <  (eval $ac_compile) 2>&5
6606 <  ac_status=$?
6607 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6608 <  (exit $ac_status); }; then
6609 <        ac_guessed_f90flags=yes
6610 < else
6611 <        ac_guessed_f90flags=no
6612 < fi
6613 < rm -f conftest*
6614 < ac_ext=c
6615 < ac_cpp='$CPP $CPPFLAGS'
6616 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6617 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6618 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6619 <
6620 <
6621 < fi
6622 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6623 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
6624 < if test "$ac_guessed_f90flags" = yes; then
6625 <        :
6626 <
6627 < else
6628 <        :
6629 <
6630 <        echo ""
6631 <        echo "**********************************************************"
6632 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6633 <        echo "* your compiler.                                         *"
6634 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6635 <        echo "**********************************************************"
6636 <        echo ""
6637 <        F90FLAGS=""
6638 <
6639 < fi
6640 <
6641 <
6642 < fi
6643 <
6644 <     ;;
6645 < esac
6646 <
6647 < # Find a good install program.  We prefer a C program (faster),
6648 < # so one script is as good as another.  But avoid the broken or
6649 < # incompatible versions:
6650 < # SysV /etc/install, /usr/sbin/install
6651 < # SunOS /usr/etc/install
6652 < # IRIX /sbin/install
6653 < # AIX /bin/install
6654 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6655 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6656 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6657 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6658 < # OS/2's system install, which has a completely different semantic
6659 < # ./install, which can be erroneously created by make from ./install.sh.
6660 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6661 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6662 < if test -z "$INSTALL"; then
6663 < if test "${ac_cv_path_install+set}" = set; then
6664 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6665 < else
6666 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6667 < for as_dir in $PATH
6668 < do
6669 <  IFS=$as_save_IFS
6670 <  test -z "$as_dir" && as_dir=.
6671 <  # Account for people who put trailing slashes in PATH elements.
6672 < case $as_dir/ in
6673 <  ./ | .// | /cC/* | \
6674 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6675 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6676 <  /usr/ucb/* ) ;;
6677 <  *)
6678 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6679 <    # Don't use installbsd from OSF since it installs stuff as root
6680 <    # by default.
6681 <    for ac_prog in ginstall scoinst install; do
6682 <      for ac_exec_ext in '' $ac_executable_extensions; do
6683 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6684 <          if test $ac_prog = install &&
6685 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6686 <            # AIX install.  It has an incompatible calling convention.
6687 <            :
6688 <          elif test $ac_prog = install &&
6689 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6690 <            # program-specific install script used by HP pwplus--don't use.
6691 <            :
6692 <          else
6693 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6694 <            break 3
6695 <          fi
6696 <        fi
6697 <      done
6698 <    done
6699 <    ;;
6700 < esac
6701 < done
6702 <
6703 <
6704 < fi
6705 <  if test "${ac_cv_path_install+set}" = set; then
6706 <    INSTALL=$ac_cv_path_install
6707 <  else
6708 <    # As a last resort, use the slow shell script.  We don't cache a
6709 <    # path for INSTALL within a source directory, because that will
6710 <    # break other packages using the cache if that directory is
6711 <    # removed, or if the path is relative.
6712 <    INSTALL=$ac_install_sh
6713 <  fi
6714 < fi
6715 < echo "$as_me:$LINENO: result: $INSTALL" >&5
6716 < echo "${ECHO_T}$INSTALL" >&6
6717 <
6718 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6719 < # It thinks the first close brace ends the variable substitution.
6720 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6721 <
6722 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6723 <
6724 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6725 <
6726 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
6727 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6728 < LN_S=$as_ln_s
6729 < if test "$LN_S" = "ln -s"; then
6730 <  echo "$as_me:$LINENO: result: yes" >&5
6731 < echo "${ECHO_T}yes" >&6
6732 < else
6733 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6734 < echo "${ECHO_T}no, using $LN_S" >&6
6735 < fi
6736 <
6737 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6738 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6739 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6740 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6741 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6742 < else
6743 <  cat >conftest.make <<\_ACEOF
6744 < all:
6745 <        @echo 'ac_maketemp="$(MAKE)"'
6746 < _ACEOF
6747 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6748 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6749 < if test -n "$ac_maketemp"; then
6750 <  eval ac_cv_prog_make_${ac_make}_set=yes
6751 < else
6752 <  eval ac_cv_prog_make_${ac_make}_set=no
6753 < fi
6754 < rm -f conftest.make
6755 < fi
6756 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6757 <  echo "$as_me:$LINENO: result: yes" >&5
6758 < echo "${ECHO_T}yes" >&6
6759 <  SET_MAKE=
6760 < else
6761 <  echo "$as_me:$LINENO: result: no" >&5
6762 < echo "${ECHO_T}no" >&6
6763 <  SET_MAKE="MAKE=${MAKE-make}"
6764 < fi
6765 <
6766 < if test -n "$ac_tool_prefix"; then
6767 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6768 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6769 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6770 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6771 < if test "${ac_cv_prog_RANLIB+set}" = set; then
6772 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6773 < else
6774 <  if test -n "$RANLIB"; then
6775 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6776 < else
6777 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6778 < for as_dir in $PATH
6779 < do
6780 <  IFS=$as_save_IFS
6781 <  test -z "$as_dir" && as_dir=.
6782 <  for ac_exec_ext in '' $ac_executable_extensions; do
6783 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6784 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6785 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6786 <    break 2
6787 <  fi
6788 < done
6789 < done
6790 <
6791 < fi
6792 < fi
6793 < RANLIB=$ac_cv_prog_RANLIB
6794 < if test -n "$RANLIB"; then
6795 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6796 < echo "${ECHO_T}$RANLIB" >&6
6797 < else
6798 <  echo "$as_me:$LINENO: result: no" >&5
6799 < echo "${ECHO_T}no" >&6
6800 < fi
6801 <
6802 < fi
6803 < if test -z "$ac_cv_prog_RANLIB"; then
6804 <  ac_ct_RANLIB=$RANLIB
6805 <  # Extract the first word of "ranlib", so it can be a program name with args.
6806 < set dummy ranlib; ac_word=$2
6807 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6808 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6809 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6810 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6811 < else
6812 <  if test -n "$ac_ct_RANLIB"; then
6813 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6814 < else
6815 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6816 < for as_dir in $PATH
6817 < do
6818 <  IFS=$as_save_IFS
6819 <  test -z "$as_dir" && as_dir=.
6820 <  for ac_exec_ext in '' $ac_executable_extensions; do
6821 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6822 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6823 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6824 <    break 2
6825 <  fi
6826 < done
6827 < done
6828 <
6829 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6830 < fi
6831 < fi
6832 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6833 < if test -n "$ac_ct_RANLIB"; then
6834 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6835 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6836 < else
6837 <  echo "$as_me:$LINENO: result: no" >&5
6838 < echo "${ECHO_T}no" >&6
6839 < fi
6840 <
6841 <  RANLIB=$ac_ct_RANLIB
6842 < else
6843 <  RANLIB="$ac_cv_prog_RANLIB"
6844 < fi
6845 <
6846 < for ac_prog in 'bison -y' byacc
6847 < do
6848 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6849 < set dummy $ac_prog; ac_word=$2
6850 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6851 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6852 < if test "${ac_cv_prog_YACC+set}" = set; then
6853 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6854 < else
6855 <  if test -n "$YACC"; then
6856 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6857 < else
6858 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6859 < for as_dir in $PATH
6860 < do
6861 <  IFS=$as_save_IFS
6862 <  test -z "$as_dir" && as_dir=.
6863 <  for ac_exec_ext in '' $ac_executable_extensions; do
6864 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6865 <    ac_cv_prog_YACC="$ac_prog"
6866 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6867 <    break 2
6868 <  fi
6869 < done
6870 < done
6871 <
6872 < fi
6873 < fi
6874 < YACC=$ac_cv_prog_YACC
6875 < if test -n "$YACC"; then
6876 <  echo "$as_me:$LINENO: result: $YACC" >&5
6877 < echo "${ECHO_T}$YACC" >&6
6878 < else
6879 <  echo "$as_me:$LINENO: result: no" >&5
6880 < echo "${ECHO_T}no" >&6
6881 < fi
6882 <
6883 <  test -n "$YACC" && break
6884 < done
6885 < test -n "$YACC" || YACC="yacc"
6886 <
6887 < for ac_prog in flex lex
6888 < do
6889 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6890 < set dummy $ac_prog; ac_word=$2
6891 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6892 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6893 < if test "${ac_cv_prog_LEX+set}" = set; then
6894 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6895 < else
6896 <  if test -n "$LEX"; then
6897 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6898 < else
6899 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6900 < for as_dir in $PATH
6901 < do
6902 <  IFS=$as_save_IFS
6903 <  test -z "$as_dir" && as_dir=.
6904 <  for ac_exec_ext in '' $ac_executable_extensions; do
6905 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6906 <    ac_cv_prog_LEX="$ac_prog"
6907 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6908 <    break 2
6909 <  fi
6910 < done
6911 < done
6912 <
6913 < fi
6914 < fi
6915 < LEX=$ac_cv_prog_LEX
6916 < if test -n "$LEX"; then
6917 <  echo "$as_me:$LINENO: result: $LEX" >&5
6918 < echo "${ECHO_T}$LEX" >&6
6919 < else
6920 <  echo "$as_me:$LINENO: result: no" >&5
6921 < echo "${ECHO_T}no" >&6
6922 < fi
6923 <
6924 <  test -n "$LEX" && break
6925 < done
6926 < test -n "$LEX" || LEX=":"
6927 <
6928 < if test -z "$LEXLIB"
6929 < then
6930 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6931 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6932 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6933 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6934 < else
6935 <  ac_check_lib_save_LIBS=$LIBS
6936 < LIBS="-lfl  $LIBS"
6937 < cat >conftest.$ac_ext <<_ACEOF
6938 < /* confdefs.h.  */
6939 < _ACEOF
6940 < cat confdefs.h >>conftest.$ac_ext
6941 < cat >>conftest.$ac_ext <<_ACEOF
6942 < /* end confdefs.h.  */
6943 <
6944 < /* Override any gcc2 internal prototype to avoid an error.  */
6945 < #ifdef __cplusplus
6946 < extern "C"
6947 < #endif
6948 < /* We use char because int might match the return type of a gcc2
6949 <   builtin and then its argument prototype would still apply.  */
6950 < char yywrap ();
6951 < int
6952 < main ()
6953 < {
6954 < yywrap ();
6955 <  ;
6956 <  return 0;
6957 < }
6958 < _ACEOF
6959 < rm -f conftest.$ac_objext conftest$ac_exeext
6960 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6961 <  (eval $ac_link) 2>conftest.er1
6962 <  ac_status=$?
6963 <  grep -v '^ *+' conftest.er1 >conftest.err
6964 <  rm -f conftest.er1
6965 <  cat conftest.err >&5
6966 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6967 <  (exit $ac_status); } &&
6968 <         { ac_try='test -z "$ac_c_werror_flag"
6969 <                         || test ! -s conftest.err'
6970 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6971 <  (eval $ac_try) 2>&5
6972 <  ac_status=$?
6973 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6974 <  (exit $ac_status); }; } &&
6975 <         { ac_try='test -s conftest$ac_exeext'
6976 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6977 <  (eval $ac_try) 2>&5
6978 <  ac_status=$?
6979 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6980 <  (exit $ac_status); }; }; then
6981 <  ac_cv_lib_fl_yywrap=yes
6982 < else
6983 <  echo "$as_me: failed program was:" >&5
6984 < sed 's/^/| /' conftest.$ac_ext >&5
6985 <
6986 < ac_cv_lib_fl_yywrap=no
6987 < fi
6988 < rm -f conftest.err conftest.$ac_objext \
6989 <      conftest$ac_exeext conftest.$ac_ext
6990 < LIBS=$ac_check_lib_save_LIBS
6991 < fi
6992 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6993 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6994 < if test $ac_cv_lib_fl_yywrap = yes; then
6995 <  LEXLIB="-lfl"
6996 < else
6997 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6998 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6999 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
7000 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7001 < else
7002 <  ac_check_lib_save_LIBS=$LIBS
7003 < LIBS="-ll  $LIBS"
7004 < cat >conftest.$ac_ext <<_ACEOF
7005 < /* confdefs.h.  */
7006 < _ACEOF
7007 < cat confdefs.h >>conftest.$ac_ext
7008 < cat >>conftest.$ac_ext <<_ACEOF
7009 < /* end confdefs.h.  */
7010 <
7011 < /* Override any gcc2 internal prototype to avoid an error.  */
7012 < #ifdef __cplusplus
7013 < extern "C"
7014 < #endif
7015 < /* We use char because int might match the return type of a gcc2
7016 <   builtin and then its argument prototype would still apply.  */
7017 < char yywrap ();
7018 < int
7019 < main ()
7020 < {
7021 < yywrap ();
7022 <  ;
7023 <  return 0;
7024 < }
7025 < _ACEOF
7026 < rm -f conftest.$ac_objext conftest$ac_exeext
7027 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7028 <  (eval $ac_link) 2>conftest.er1
7029 <  ac_status=$?
7030 <  grep -v '^ *+' conftest.er1 >conftest.err
7031 <  rm -f conftest.er1
7032 <  cat conftest.err >&5
7033 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7034 <  (exit $ac_status); } &&
7035 <         { ac_try='test -z "$ac_c_werror_flag"
7036 <                         || test ! -s conftest.err'
7037 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7038 <  (eval $ac_try) 2>&5
7039 <  ac_status=$?
7040 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7041 <  (exit $ac_status); }; } &&
7042 <         { ac_try='test -s conftest$ac_exeext'
7043 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7044 <  (eval $ac_try) 2>&5
7045 <  ac_status=$?
7046 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7047 <  (exit $ac_status); }; }; then
7048 <  ac_cv_lib_l_yywrap=yes
7049 < else
7050 <  echo "$as_me: failed program was:" >&5
7051 < sed 's/^/| /' conftest.$ac_ext >&5
7052 <
7053 < ac_cv_lib_l_yywrap=no
7054 < fi
7055 < rm -f conftest.err conftest.$ac_objext \
7056 <      conftest$ac_exeext conftest.$ac_ext
7057 < LIBS=$ac_check_lib_save_LIBS
7058 < fi
7059 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
7060 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
7061 < if test $ac_cv_lib_l_yywrap = yes; then
7062 <  LEXLIB="-ll"
7063 < fi
7064 <
7065 < fi
7066 <
7067 < fi
7068 <
7069 < if test "x$LEX" != "x:"; then
7070 <  echo "$as_me:$LINENO: checking lex output file root" >&5
7071 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
7072 < if test "${ac_cv_prog_lex_root+set}" = set; then
7073 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7074 < else
7075 <  # The minimal lex program is just a single line: %%.  But some broken lexes
7076 < # (Solaris, I think it was) want two %% lines, so accommodate them.
7077 < cat >conftest.l <<_ACEOF
7078 < %%
7079 < %%
7080 < _ACEOF
7081 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
7082 <  (eval $LEX conftest.l) 2>&5
7083 <  ac_status=$?
7084 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7085 <  (exit $ac_status); }
7086 < if test -f lex.yy.c; then
7087 <  ac_cv_prog_lex_root=lex.yy
7088 < elif test -f lexyy.c; then
7089 <  ac_cv_prog_lex_root=lexyy
7090 < else
7091 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
7092 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
7093 <   { (exit 1); exit 1; }; }
7094 < fi
7095 < fi
7096 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
7097 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
7098 < rm -f conftest.l
7099 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
7100 <
7101 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
7102 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
7103 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
7104 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7105 < else
7106 <  # POSIX says lex can declare yytext either as a pointer or an array; the
7107 < # default is implementation-dependent. Figure out which it is, since
7108 < # not all implementations provide the %pointer and %array declarations.
7109 < ac_cv_prog_lex_yytext_pointer=no
7110 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
7111 < ac_save_LIBS=$LIBS
7112 < LIBS="$LIBS $LEXLIB"
7113 < cat >conftest.$ac_ext <<_ACEOF
7114 < `cat $LEX_OUTPUT_ROOT.c`
7115 < _ACEOF
7116 < rm -f conftest.$ac_objext conftest$ac_exeext
7117 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7118 <  (eval $ac_link) 2>conftest.er1
7119 <  ac_status=$?
7120 <  grep -v '^ *+' conftest.er1 >conftest.err
7121 <  rm -f conftest.er1
7122 <  cat conftest.err >&5
7123 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7124 <  (exit $ac_status); } &&
7125 <         { ac_try='test -z "$ac_c_werror_flag"
7126 <                         || test ! -s conftest.err'
7127 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7128 <  (eval $ac_try) 2>&5
7129 <  ac_status=$?
7130 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7131 <  (exit $ac_status); }; } &&
7132 <         { ac_try='test -s conftest$ac_exeext'
7133 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7134 <  (eval $ac_try) 2>&5
7135 <  ac_status=$?
7136 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7137 <  (exit $ac_status); }; }; then
7138 <  ac_cv_prog_lex_yytext_pointer=yes
12847 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12848 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12849 > if test "$ac_m_cpu_powerpc" = yes; then
12850 >        :
12851 >        CPU_FLAGS=-mcpu=powerpc
12852   else
12853 <  echo "$as_me: failed program was:" >&5
7141 < sed 's/^/| /' conftest.$ac_ext >&5
12853 >        :
12854  
12855   fi
7144 rm -f conftest.err conftest.$ac_objext \
7145      conftest$ac_exeext conftest.$ac_ext
7146 LIBS=$ac_save_LIBS
7147 rm -f "${LEX_OUTPUT_ROOT}.c"
12856  
12857 < fi
12858 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
7151 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
7152 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
12857 >                fi
12858 >                if test -z "$CPU_FLAGS"; then
12859  
7154 cat >>confdefs.h <<\_ACEOF
7155 #define YYTEXT_POINTER 1
7156 _ACEOF
12860  
12861 < fi
12862 <
12863 < fi
7161 < # Extract the first word of "ar", so it can be a program name with args.
7162 < set dummy ar; ac_word=$2
7163 < echo "$as_me:$LINENO: checking for $ac_word" >&5
7164 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7165 < if test "${ac_cv_prog_AR+set}" = set; then
12861 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12862 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12863 > if test "${ac_m_powerpc+set}" = set; then
12864    echo $ECHO_N "(cached) $ECHO_C" >&6
12865   else
12866 <  if test -n "$AR"; then
12867 <  ac_cv_prog_AR="$AR" # Let the user override the test.
12866 >  echo 'void f(){}' > conftest.cpp
12867 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12868 >        ac_m_powerpc=yes
12869   else
12870 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12871 < for as_dir in $PATH
12872 < do
7174 <  IFS=$as_save_IFS
7175 <  test -z "$as_dir" && as_dir=.
7176 <  for ac_exec_ext in '' $ac_executable_extensions; do
7177 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7178 <    ac_cv_prog_AR="ar"
7179 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7180 <    break 2
7181 <  fi
7182 < done
7183 < done
12870 >        ac_m_powerpc=no
12871 > fi
12872 > rm -f conftest*
12873  
7185  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12874   fi
12875 < fi
12876 < AR=$ac_cv_prog_AR
12877 < if test -n "$AR"; then
12878 <  echo "$as_me:$LINENO: result: $AR" >&5
12879 < echo "${ECHO_T}$AR" >&6
12875 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12876 > echo "${ECHO_T}$ac_m_powerpc" >&6
12877 > if test "$ac_m_powerpc" = yes; then
12878 >        :
12879 >        CPU_FLAGS=-mpowerpc
12880   else
12881 <  echo "$as_me:$LINENO: result: no" >&5
12882 < echo "${ECHO_T}no" >&6
12881 >        :
12882 >
12883   fi
12884  
12885 < if test "$AR" = "NONE"; then
12886 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
12887 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
7200 <   { (exit 1); exit 1; }; }
7201 <  cat >confcache <<\_ACEOF
7202 < # This file is a shell script that caches the results of configure
7203 < # tests run on this system so they can be shared between configure
7204 < # scripts and configure runs, see configure's option --config-cache.
7205 < # It is not useful on other systems.  If it contains results you don't
7206 < # want to keep, you may remove or edit it.
7207 < #
7208 < # config.status only pays attention to the cache file if you give it
7209 < # the --recheck option to rerun configure.
7210 < #
7211 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
7212 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
7213 < # following values.
12885 >                fi
12886 >          esac
12887 >  fi
12888  
12889 < _ACEOF
12890 <
7217 < # The following way of writing the cache mishandles newlines in values,
7218 < # but we know of no workaround that is simple, portable, and efficient.
7219 < # So, don't put newlines in cache variables' values.
7220 < # Ultrix sh set writes to stderr and can't be redirected directly,
7221 < # and sets the high bit in the cache file unless we assign to the vars.
7222 < {
7223 <  (set) 2>&1 |
7224 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
7225 <    *ac_space=\ *)
7226 <      # `set' does not quote correctly, so add quotes (double-quote
7227 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7228 <      sed -n \
7229 <        "s/'/'\\\\''/g;
7230 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
7231 <      ;;
7232 <    *)
7233 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
7234 <      sed -n \
7235 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
7236 <      ;;
7237 <    esac;
7238 < } |
7239 <  sed '
7240 <     t clear
7241 <     : clear
7242 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
7243 <     t end
7244 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
7245 <     : end' >>confcache
7246 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
7247 <  if test -w $cache_file; then
7248 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
7249 <    cat confcache >$cache_file
7250 <  else
7251 <    echo "not updating unwritable cache $cache_file"
12889 >  if test -n "$CPU_FLAGS"; then
12890 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12891    fi
7253 fi
7254 rm -f confcache
7255  exit 1
7256 fi
12892  
12893 < # Extract the first word of "ps", so it can be a program name with args.
12894 < set dummy ps; ac_word=$2
12895 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12896 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12897 < if test "${ac_cv_path_PS+set}" = set; then
12898 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12899 < else
12900 <  case $PS in
12901 <  [\\/]* | ?:[\\/]*)
7267 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
7268 <  ;;
7269 <  *)
7270 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7271 < for as_dir in $PATH
7272 < do
7273 <  IFS=$as_save_IFS
7274 <  test -z "$as_dir" && as_dir=.
7275 <  for ac_exec_ext in '' $ac_executable_extensions; do
7276 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7277 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
7278 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7279 <    break 2
12893 >  if test -z "$CXXFLAGS"; then
12894 >        echo ""
12895 >        echo "**********************************************************"
12896 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12897 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12898 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12899 >        echo "**********************************************************"
12900 >        echo ""
12901 >        CXXFLAGS="-O3"
12902    fi
7281 done
7282 done
12903  
7284  ;;
7285 esac
7286 fi
7287 PS=$ac_cv_path_PS
12904  
12905 < if test -n "$PS"; then
12906 <  echo "$as_me:$LINENO: result: $PS" >&5
12907 < echo "${ECHO_T}$PS" >&6
12905 >
12906 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12907 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12908 > if test "${ac_guessed_cxxflags+set}" = set; then
12909 >  echo $ECHO_N "(cached) $ECHO_C" >&6
12910   else
12911 <  echo "$as_me:$LINENO: result: no" >&5
12912 < echo "${ECHO_T}no" >&6
12911 >  echo 'void f(){}' > conftest.cpp
12912 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12913 >        ac_guessed_cxxflags=yes
12914 > else
12915 >        ac_guessed_cxxflags=no
12916   fi
12917 + rm -f conftest*
12918  
12919 < echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
12920 < echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
12921 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
12922 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12919 > fi
12920 > echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12921 > echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12922 > if test "$ac_guessed_cxxflags" = yes; then
12923 >        :
12924 >
12925   else
12926 +        :
12927  
12928 <        if $PS ax -o rss > /dev/null 2>&1; then
12929 <                ac_cv_prog_ps_ax=yes
12930 <        else
12931 <                ac_cv_prog_ps_ax=no
12932 <        fi
12933 <        if $PS -ef -o rss > /dev/null 2>&1; then
12934 <                ac_cv_prog_ps_ef=yes
12935 <        else
7311 <                ac_cv_prog_ps_ef=no
7312 <        fi
7313 <        if test "$ac_cv_prog_ps_ax" = yes; then
7314 <                ac_cv_prog_ps_syntax=BSD
7315 <        else
7316 <                if test "$ac_cv_prog_ps_es" = yes; then
7317 <                        ac_cv_prog_ps_syntax=POSIX
7318 <                else
7319 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
7320 < echo "$as_me: error: Could not determine ps syntax" >&2;}
7321 <   { (exit 1); exit 1; }; }
7322 <                fi
7323 <        fi
12928 >        echo ""
12929 >        echo "**********************************************************"
12930 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12931 >        echo "* your compiler.                                         *"
12932 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12933 >        echo "**********************************************************"
12934 >        echo ""
12935 >        CXXFLAGS=""
12936  
12937   fi
7326 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
7327 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
12938  
7329 cat >>confdefs.h <<_ACEOF
7330 #define PSCOMMAND $PS
7331 _ACEOF
12939  
12940 + fi
12941  
12942 < cat >>confdefs.h <<_ACEOF
12943 < #define PSTYPE $ac_cv_prog_ps_syntax
12942 >     ;;
12943 > esac
12944 >
12945 >
12946 > cat >>confdefs.h <<\_ACEOF
12947 > #define OBAPI
12948   _ACEOF
12949  
12950  
# Line 7366 | Line 12978 | echo '#include <mpi.h>' > conftest.cc
12978   echo "$as_me:$LINENO: checking for mpi.h" >&5
12979   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
12980   have_mpi_h=0
12981 + rm -f conftest*
12982   echo '#include <mpi.h>' > conftest.cc
12983 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
12983 > if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
12984          echo "$as_me:$LINENO: result: yes" >&5
12985   echo "${ECHO_T}yes" >&6
12986          have_mpi_h=1
12987   else
12988 +        if test -s conftest.out ; then
12989 +                cat conftest.out >> config.log
12990 +        fi
12991          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
12992   echo "${ECHO_T}no! Check MPI include paths" >&6
12993          USE_MPI="no"
# Line 7389 | Line 13005 | cat >conftest.f90 <<EOF
13005   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13006   have_mpif_h=0
13007   rm -f conftest*
13008 < cat >conftest.f90 <<EOF
13008 > cat >conftest.$ac_ext <<EOF
13009   program main
13010     include 'mpif.h'
13011   end
13012   EOF
13013 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13013 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13014          echo "$as_me:$LINENO: result: yes" >&5
13015   echo "${ECHO_T}yes" >&6
13016          MPI_F90_INC="$MPI_INC_DIR"
# Line 7448 | Line 13064 | int
13064   /* We use char because int might match the return type of a gcc2
13065     builtin and then its argument prototype would still apply.  */
13066   char MPI_Init ();
13067 + #ifdef FC_DUMMY_MAIN
13068 + #ifndef FC_DUMMY_MAIN_EQ_F77
13069 + #  ifdef __cplusplus
13070 +     extern "C"
13071 + #  endif
13072 +   int FC_DUMMY_MAIN() { return 1; }
13073 + #endif
13074 + #endif
13075   int
13076   main ()
13077   {
# Line 7518 | Line 13142 | int
13142   /* We use char because int might match the return type of a gcc2
13143     builtin and then its argument prototype would still apply.  */
13144   char MPI_Init ();
13145 + #ifdef FC_DUMMY_MAIN
13146 + #ifndef FC_DUMMY_MAIN_EQ_F77
13147 + #  ifdef __cplusplus
13148 +     extern "C"
13149 + #  endif
13150 +   int FC_DUMMY_MAIN() { return 1; }
13151 + #endif
13152 + #endif
13153   int
13154   main ()
13155   {
# Line 7589 | Line 13221 | int
13221   /* We use char because int might match the return type of a gcc2
13222     builtin and then its argument prototype would still apply.  */
13223   char MPI_Init ();
13224 + #ifdef FC_DUMMY_MAIN
13225 + #ifndef FC_DUMMY_MAIN_EQ_F77
13226 + #  ifdef __cplusplus
13227 +     extern "C"
13228 + #  endif
13229 +   int FC_DUMMY_MAIN() { return 1; }
13230 + #endif
13231 + #endif
13232   int
13233   main ()
13234   {
# Line 7660 | Line 13300 | int
13300   /* We use char because int might match the return type of a gcc2
13301     builtin and then its argument prototype would still apply.  */
13302   char MPI_Init ();
13303 + #ifdef FC_DUMMY_MAIN
13304 + #ifndef FC_DUMMY_MAIN_EQ_F77
13305 + #  ifdef __cplusplus
13306 +     extern "C"
13307 + #  endif
13308 +   int FC_DUMMY_MAIN() { return 1; }
13309 + #endif
13310 + #endif
13311   int
13312   main ()
13313   {
# Line 7704 | Line 13352 | if test $ac_cv_lib_mpich_MPI_Init = yes; then
13352   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13353   echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13354   if test $ac_cv_lib_mpich_MPI_Init = yes; then
13355 <  MPI_LIB="-lmpich -lpmpich"
13355 >  MPI_LIB="-lpmpich -lmpich"
13356   fi
13357  
13358   fi
# Line 7732 | Line 13380 | int
13380   /* We use char because int might match the return type of a gcc2
13381     builtin and then its argument prototype would still apply.  */
13382   char MPI_Init ();
13383 + #ifdef FC_DUMMY_MAIN
13384 + #ifndef FC_DUMMY_MAIN_EQ_F77
13385 + #  ifdef __cplusplus
13386 +     extern "C"
13387 + #  endif
13388 +   int FC_DUMMY_MAIN() { return 1; }
13389 + #endif
13390 + #endif
13391   int
13392   main ()
13393   {
# Line 7808 | Line 13464 | fi
13464  
13465  
13466  
13467 < # Check whether --with-sprng or --without-sprng was given.
13468 < if test "${with_sprng+set}" = set; then
13469 <  withval="$with_sprng"
13470 <  with_sprng=$withval
13471 < else
13472 <  with_sprng="/usr/local"
13467 > USE_CGAL=no
13468 > cgal_makefile=auto
13469 >
13470 > # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13471 > if test "${with_cgal_makefile+set}" = set; then
13472 >  withval="$with_cgal_makefile"
13473 >  cgal_makefile="$withval"
13474   fi;
13475  
13476 < case "x$with_sprng" in
7820 <        xyes | "x")  USE_SPRNG=yes;;
7821 <        xno) USE_SPRNG=no ;;
7822 <        *) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7823 < esac
7824 < if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7825 <        SPRNG="/usr/local"
7826 < fi
7827 < if test "$USE_SPRNG" = "yes"; then
13476 > if test "x$cgal_makefile" != xno; then
13477  
13478 +  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13479 +    cgal_makefile="$CGAL_MAKEFILE"
13480 +  fi
13481  
13482 < # Set variables...
13483 < SPRNG_LIB_DIR="$SPRNG/lib"
7832 < SPRNG_INC_DIR="$SPRNG/include"
13482 >  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13483 > echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13484  
13485 +  if test -f "$cgal_makefile"; then
13486  
13487 +    cat >config.tmp.Makefile <<EOF
13488 + include $cgal_makefile
13489 + default:
13490 +        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13491 +        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13492 +        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13493 +        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13494 +        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13495 +        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13496 +        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13497 +        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13498 +        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13499 +        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13500 +        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13501 +        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13502 + EOF
13503  
13504 < echo "$as_me:$LINENO: checking for sprng.h" >&5
13505 < echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
7838 < have_sprng_h=0
7839 < echo '#include <sprng.h>' > conftest.cc
7840 < if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
7841 <        echo "$as_me:$LINENO: result: yes" >&5
7842 < echo "${ECHO_T}yes" >&6
7843 <        have_sprng_h=1
7844 < else
7845 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7846 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
7847 <        USE_SPRNG="no"
7848 < fi
7849 < rm -f conftest*
7850 < if test "$have_sprng_h" = 1; then
13504 >    make -s -f config.tmp.Makefile
13505 >    . config.tmp.cgalvariables
13506  
13507 < cat >>confdefs.h <<\_ACEOF
7853 < #define HAVE_SPRNG_H 1
7854 < _ACEOF
13507 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
13508  
13509 < fi
13509 >    if test "x$CGAL_INCLDIR" = "x"; then
13510 >      CGAL_INCLDIR=""
13511 >    fi
13512  
13513 < ac_ext=c
13514 < ac_cpp='$CPP $CPPFLAGS'
13515 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7861 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7862 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13513 >    if test "x$CGAL_LIBDIR" = "x"; then
13514 >      CGAL_LIBDIR=""
13515 >    fi
13516  
13517 < ac_save_LDFLAGS=$LDFLAGS
13518 < LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
13517 >    if test "x$CGAL_RLIBDIR" = "x"; then
13518 >      CGAL_RLIBDIR=""
13519 >    fi
13520  
13521 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
13522 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
13523 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
7870 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7871 < else
7872 <  ac_check_lib_save_LIBS=$LIBS
7873 < LIBS="-lsprng  $LIBS"
7874 < cat >conftest.$ac_ext <<_ACEOF
7875 < /* confdefs.h.  */
7876 < _ACEOF
7877 < cat confdefs.h >>conftest.$ac_ext
7878 < cat >>conftest.$ac_ext <<_ACEOF
7879 < /* end confdefs.h.  */
13521 >    if test "x$LEDA_INCLDIR" = "x"; then
13522 >      LEDA_INCLDIR=""
13523 >    fi
13524  
13525 < /* Override any gcc2 internal prototype to avoid an error.  */
13526 < #ifdef __cplusplus
13527 < extern "C"
7884 < #endif
7885 < /* We use char because int might match the return type of a gcc2
7886 <   builtin and then its argument prototype would still apply.  */
7887 < char init_rng ();
7888 < int
7889 < main ()
7890 < {
7891 < init_rng ();
7892 <  ;
7893 <  return 0;
7894 < }
7895 < _ACEOF
7896 < rm -f conftest.$ac_objext conftest$ac_exeext
7897 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7898 <  (eval $ac_link) 2>conftest.er1
7899 <  ac_status=$?
7900 <  grep -v '^ *+' conftest.er1 >conftest.err
7901 <  rm -f conftest.er1
7902 <  cat conftest.err >&5
7903 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7904 <  (exit $ac_status); } &&
7905 <         { ac_try='test -z "$ac_c_werror_flag"
7906 <                         || test ! -s conftest.err'
7907 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7908 <  (eval $ac_try) 2>&5
7909 <  ac_status=$?
7910 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7911 <  (exit $ac_status); }; } &&
7912 <         { ac_try='test -s conftest$ac_exeext'
7913 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7914 <  (eval $ac_try) 2>&5
7915 <  ac_status=$?
7916 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7917 <  (exit $ac_status); }; }; then
7918 <  ac_cv_lib_sprng_init_rng=yes
7919 < else
7920 <  echo "$as_me: failed program was:" >&5
7921 < sed 's/^/| /' conftest.$ac_ext >&5
13525 >    if test "x$LEDA_LIBDIR" = "x"; then
13526 >      LEDA_LIBDIR=""
13527 >    fi
13528  
13529 < ac_cv_lib_sprng_init_rng=no
13530 < fi
13531 < rm -f conftest.err conftest.$ac_objext \
7926 <      conftest$ac_exeext conftest.$ac_ext
7927 < LIBS=$ac_check_lib_save_LIBS
7928 < fi
7929 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
7930 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
7931 < if test $ac_cv_lib_sprng_init_rng = yes; then
7932 <  SPRNG_LIB="-lsprng"
7933 < else
13529 >    if test "x$LEDA_RLIBDIR" = "x"; then
13530 >      LEDA_RLIBDIR=""
13531 >    fi
13532  
13533 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13534 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13535 <   { (exit 1); exit 1; }; }
7938 <             USE_SPRNG="no"
13533 >    if test "x$GMP_INCLDIR" = "x"; then
13534 >      GMP_INCLDIR=""
13535 >    fi
13536  
13537 < fi
13537 >    if test "x$GMP_LIBDIR" = "x"; then
13538 >      GMP_LIBDIR=""
13539 >    fi
13540  
13541 <
13542 < if test "$USE_SPRNG" = "no"; then
7944 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
7945 < echo "$as_me: error: No working SPRNG library found" >&2;}
7946 <   { (exit 1); exit 1; }; }
7947 < fi
7948 <
7949 <
7950 < fi
7951 <
7952 <
7953 <
7954 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
7955 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
7956 <
7957 < # Check whether --with-mkl or --without-mkl was given.
7958 < if test "${with_mkl+set}" = set; then
7959 <  withval="$with_mkl"
7960 <     echo "$as_me:$LINENO: result: yes" >&5
7961 < echo "${ECHO_T}yes" >&6
7962 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7963 <        mkldir="$dir"
7964 <        if test -f "$dir/include/mkl.h"; then
7965 <            found_mkl="yes";
7966 <            break;
7967 <        fi
7968 <    done
7969 <    if test x_$found_mkl != x_yes; then
7970 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7971 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7972 <   { (exit 1); exit 1; }; }
7973 <    else
7974 <        printf "MKL includes found in $mkldir/include\n";
13541 >    if test "x$GMP_RLIBDIR" = "x"; then
13542 >      GMP_RLIBDIR=""
13543      fi
13544  
13545 +    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13546 + echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13547 +    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13548 + echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13549 +    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13550 + echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13551 +    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13552 + echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13553 +    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13554 + echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13555 +    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13556 + echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13557 +    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13558 + echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13559 +    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13560 + echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13561 +    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13562 + echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13563  
13564 +    ac_ext=cc
13565 + ac_cpp='$CXXCPP $CPPFLAGS'
13566 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13567 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13568 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13569  
13570 <  ac_ext=c
13571 < ac_cpp='$CPP $CPPFLAGS'
13572 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13573 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13574 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13575 <
7985 <  ac_save_CPPFLAGS=$CPPFLAGS
7986 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
7987 <  ac_save_LDFLAGS=$LDFLAGS
7988 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
7989 <  if test "${ac_cv_header_mkl_h+set}" = set; then
7990 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
7991 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7992 < if test "${ac_cv_header_mkl_h+set}" = set; then
13570 >    save_CXXFLAGS="$CXXFLAGS"
13571 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13572 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13573 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13574 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13575 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13576    echo $ECHO_N "(cached) $ECHO_C" >&6
13577   fi
13578 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13579 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13578 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13579 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13580   else
13581    # Is the header compilable?
13582 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
13583 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13582 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13583 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13584   cat >conftest.$ac_ext <<_ACEOF
13585   /* confdefs.h.  */
13586   _ACEOF
# Line 8005 | Line 13588 | $ac_includes_default
13588   cat >>conftest.$ac_ext <<_ACEOF
13589   /* end confdefs.h.  */
13590   $ac_includes_default
13591 < #include <mkl.h>
13591 > #include <CGAL/Cartesian.h>
13592   _ACEOF
13593   rm -f conftest.$ac_objext
13594   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 8016 | Line 13599 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13599    cat conftest.err >&5
13600    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13601    (exit $ac_status); } &&
13602 <         { ac_try='test -z "$ac_c_werror_flag"
13602 >         { ac_try='test -z "$ac_cxx_werror_flag"
13603                           || test ! -s conftest.err'
13604    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13605    (eval $ac_try) 2>&5
# Line 8041 | Line 13624 | echo "$as_me:$LINENO: checking mkl.h presence" >&5
13624   echo "${ECHO_T}$ac_header_compiler" >&6
13625  
13626   # Is the header present?
13627 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
13628 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13627 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13628 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13629   cat >conftest.$ac_ext <<_ACEOF
13630   /* confdefs.h.  */
13631   _ACEOF
13632   cat confdefs.h >>conftest.$ac_ext
13633   cat >>conftest.$ac_ext <<_ACEOF
13634   /* end confdefs.h.  */
13635 < #include <mkl.h>
13635 > #include <CGAL/Cartesian.h>
13636   _ACEOF
13637   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13638    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 8060 | Line 13643 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13643    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13644    (exit $ac_status); } >/dev/null; then
13645    if test -s conftest.err; then
13646 <    ac_cpp_err=$ac_c_preproc_warn_flag
13647 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13646 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13647 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13648    else
13649      ac_cpp_err=
13650    fi
# Line 8081 | Line 13664 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
13664   echo "${ECHO_T}$ac_header_preproc" >&6
13665  
13666   # So?  What about this header?
13667 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13667 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13668    yes:no: )
13669 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13670 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13671 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
13672 < echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
13669 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13670 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13671 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13672 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13673      ac_header_preproc=yes
13674      ;;
13675    no:yes:* )
13676 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13677 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13678 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
13679 < echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
13680 <    { echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
13681 < echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
13682 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
13683 < echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13684 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13685 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13686 <    { echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
13687 < echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
13676 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13677 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13678 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13679 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13680 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13681 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13682 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13683 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13684 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13685 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13686 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13687 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13688      (
13689        cat <<\_ASBOX
13690   ## ------------------------------ ##
# Line 8112 | Line 13695 | echo "$as_me:$LINENO: checking for mkl.h" >&5
13695        sed "s/^/$as_me: WARNING:     /" >&2
13696      ;;
13697   esac
13698 < echo "$as_me:$LINENO: checking for mkl.h" >&5
13699 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13700 < if test "${ac_cv_header_mkl_h+set}" = set; then
13698 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13699 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13700 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13701    echo $ECHO_N "(cached) $ECHO_C" >&6
13702   else
13703 <  ac_cv_header_mkl_h=$ac_header_preproc
13703 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13704   fi
13705 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13706 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13705 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13706 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13707  
13708   fi
13709 < if test $ac_cv_header_mkl_h = yes; then
13710 <
8128 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
8129 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
8130 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
8131 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13709 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13710 >  cgal=yes
13711   else
13712 <  ac_check_lib_save_LIBS=$LIBS
13713 < LIBS="-lmkl  $LIBS"
13712 >  cgal=no
13713 > fi
13714 >
13715 >
13716 >    CXXFLAGS="$save_CXXFLAGS"
13717 >
13718 >    if test "x$cgal" = xyes; then
13719 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
13720 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
13721 >      LOCATION=${CGAL_INCLDIR}
13722 >      LOCATION=${LOCATION:-/usr/include}
13723 >      if test -f $LOCATION/CGAL/version.h; then
13724 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
13725 >      else
13726 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
13727 >      fi
13728 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
13729 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
13730 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
13731 >      else
13732 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
13733 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
13734 >        cgal=no
13735 >      fi
13736 >    fi
13737 >
13738 >    if test "x$cgal" = xyes; then
13739 >      CGAL_LIBS="-lCGAL"
13740 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13741 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13742 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13743 >        CGAL_USES_LEDA=yes
13744 >        echo "$as_me:$LINENO: result: yes" >&5
13745 > echo "${ECHO_T}yes" >&6
13746 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13747 >      else
13748 >        echo "$as_me:$LINENO: result: no" >&5
13749 > echo "${ECHO_T}no" >&6
13750 >        CGAL_USES_LEDA=no
13751 >      fi
13752 >
13753 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13754 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13755 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13756 >        CGAL_USES_GMP=yes
13757 >        echo "$as_me:$LINENO: result: yes" >&5
13758 > echo "${ECHO_T}yes" >&6
13759 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13760 >      else
13761 >        echo "$as_me:$LINENO: result: no" >&5
13762 > echo "${ECHO_T}no" >&6
13763 >        CGAL_USES_GMP=no
13764 >      fi
13765 >
13766 >      CGAL_LIBS="$CGAL_LIBS -lm"
13767 >
13768 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
13769 >
13770 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13771 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13772 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13773 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13774 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13775 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13776 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13777 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13778 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13779 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13780 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13781 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13782 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13783 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13784 >    fi
13785 >
13786 >    if test "x$cgal" = xyes; then
13787 >      save_LIBS="$LIBS"
13788 >      LIBS="$LIBS -L$CGAL_LIBDIR"
13789 >      if test "x$CGAL_USES_LEDA" = xyes; then
13790 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13791 >      fi
13792 >      # if test "x$CGAL_USES_GMP" = xyes; then
13793 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13794 >      # fi
13795 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13796 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13797 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13798 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13799 > save_LIBS_CHECK_CXX_LIB="$LIBS"
13800 > LIBS="-lCGAL  $LIBS"
13801   cat >conftest.$ac_ext <<_ACEOF
13802   /* confdefs.h.  */
13803   _ACEOF
13804   cat confdefs.h >>conftest.$ac_ext
13805   cat >>conftest.$ac_ext <<_ACEOF
13806   /* end confdefs.h.  */
13807 <
13808 < /* Override any gcc2 internal prototype to avoid an error.  */
13809 < #ifdef __cplusplus
13810 < extern "C"
13807 > #include <CGAL/Cartesian.h>
13808 > #ifdef FC_DUMMY_MAIN
13809 > #ifndef FC_DUMMY_MAIN_EQ_F77
13810 > #  ifdef __cplusplus
13811 >     extern "C"
13812 > #  endif
13813 >   int FC_DUMMY_MAIN() { return 1; }
13814   #endif
13815 < /* We use char because int might match the return type of a gcc2
8147 <   builtin and then its argument prototype would still apply.  */
8148 < char vslNewStream ();
13815 > #endif
13816   int
13817   main ()
13818   {
13819 < vslNewStream ();
13819 > ::CGAL::Cartesian<int>::Point_2 P
13820    ;
13821    return 0;
13822   }
# Line 8163 | Line 13830 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13830    cat conftest.err >&5
13831    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13832    (exit $ac_status); } &&
13833 <         { ac_try='test -z "$ac_c_werror_flag"
13833 >         { ac_try='test -z "$ac_cxx_werror_flag"
13834                           || test ! -s conftest.err'
13835    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13836    (eval $ac_try) 2>&5
# Line 8176 | Line 13843 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13843    ac_status=$?
13844    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13845    (exit $ac_status); }; }; then
13846 <  ac_cv_lib_mkl_vslNewStream=yes
13846 >  echo "$as_me:$LINENO: result: yes" >&5
13847 > echo "${ECHO_T}yes" >&6
13848 > cgal=yes
13849   else
13850    echo "$as_me: failed program was:" >&5
13851   sed 's/^/| /' conftest.$ac_ext >&5
13852  
13853 < ac_cv_lib_mkl_vslNewStream=no
13853 > echo "$as_me:$LINENO: result: no" >&5
13854 > echo "${ECHO_T}no" >&6
13855 > cgal=no
13856   fi
13857   rm -f conftest.err conftest.$ac_objext \
13858        conftest$ac_exeext conftest.$ac_ext
13859 < LIBS=$ac_check_lib_save_LIBS
13860 < fi
13861 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
13862 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
8192 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
8193 <  MKL_LIBDIR="${mkldir}/lib/32",
8194 <                     MKL_LIB="-lmkl -lvml -lguide",
8195 <                     HAVE_MKL="yes"
8196 < fi
13859 > CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13860 > LIBS="$save_LIBS_CHECK_CXX_LIB"
13861 >      LIBS="$save_LIBS"
13862 >    fi
13863  
13864 <
8199 < else
8200 <  MKL_INC="-I${mkldir}/include"
8201 < fi
8202 <
8203 <
8204 <  CPPFLAGS=$ac_save_CPPFLAGS
8205 <  LDFLAGS=$ac_save_LDFLAGS
13864 >  fi
13865    ac_ext=c
13866   ac_cpp='$CPP $CPPFLAGS'
13867   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8210 | Line 13869 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
13869   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13870  
13871  
13872 <  if test x_$HAVE_MKL != x_yes; then
8214 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
8215 < echo "$as_me: error: Can't build with MKL" >&2;}
8216 <   { (exit 1); exit 1; }; }
8217 <  fi
13872 > fi
13873  
13874 + if test "x$cgal" = xyes; then
13875 +  USE_CGAL=yes
13876  
13877 + cat >>confdefs.h <<\_ACEOF
13878 + #define HAVE_CGAL 1
13879 + _ACEOF
13880  
13881  
13882 + cat >>confdefs.h <<_ACEOF
13883 + #define CGAL_VERSION $CGAL_VERSION
13884 + _ACEOF
13885  
13886 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
13887 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13888 + echo "$as_me: WARNING: *****************************************************" >&2;}
13889 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
13890 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
13891 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
13892 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
13893 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13894 + echo "$as_me: WARNING: *****************************************************" >&2;}
13895 +  fi
13896   else
13897 +   if test "x$cgal_makefile" != xno; then
13898 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
13899 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
13900 +  fi
13901 +  CGAL_INCLDIR=
13902 +  CGAL_LIBDIR=
13903 +  CGAL_RLIBDIR=
13904 +  CGAL_DEFINES=
13905 +  CGAL_CXXFLAGS=
13906 +  CGAL_LIBS=
13907 + fi
13908  
8225    echo "$as_me:$LINENO: result: no" >&5
8226 echo "${ECHO_T}no" >&6
13909  
13910 < fi;
13910 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
13911  
13912 + CGAL_LIB_DIR=${CGAL_LIBDIR}
13913  
13914 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13915  
13916 +
13917 +
13918 +
13919 +
13920 +
13921   # Check whether --enable-doxygen or --disable-doxygen was given.
13922   if test "${enable_doxygen+set}" = set; then
13923    enableval="$enable_doxygen"
# Line 8363 | Line 14052 | fi
14052   else
14053          enable_dot=yes
14054   fi
8366
8367
8368
8369
8370
8371
8372
8373 OBJEXT=".$OBJEXT"
8374
8375 OOPSE=oopse
8376
8377 if test "x${prefix}" = "xNONE"
8378 then
8379  OOPSE_HOME=${ac_default_prefix}/oopse
8380 else
8381  OOPSE_HOME=${prefix}/oopse
8382 fi
8383 # Check whether --enable-oopse-home or --disable-oopse-home was given.
8384 if test "${enable_oopse_home+set}" = set; then
8385  enableval="$enable_oopse_home"
8386  OOPSE_HOME="${enableval}"
8387 fi;
8388
8389 case "x$INSTALL" in
8390   x/*) ;;
8391   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
8392 esac
8393
8394 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
8395
8396 CFLAGS=${CFLAGS-""}
8397 CXXFLAGS=${CXXFLAGS-""}
8398 CPPFLAGS=${CPPFLAGS-""}
8399 FFLAGS=${FFLAGS-""}
8400 F90FLAGS=${F90FLAGS-""}
8401 LDFLAGS=${LDFLAGS-""}
8402 DEBUG=${DEBUG-"-g"}
14055  
8404 case $debug in
8405  1)
8406     FFLAGS="$DEBUG $FFLAGS"
8407     F90FLAGS="$DEBUG $F90FLAGS"
8408     ;;
8409  *)
8410     ;;
8411 esac
14056  
14057  
14058  
# Line 8427 | Line 14071 | esac
14071  
14072  
14073  
14074 <          ac_config_headers="$ac_config_headers src/config.h"
8431 <
8432 <                    ac_config_files="$ac_config_files make/Makefile src/utils/Makefile"
14074 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14075  
14076  
14077   cat >confcache <<\_ACEOF
# Line 8794 | Line 14436 | This file was extended by OOPSE $as_me 2.0, which was
14436   } >&5
14437   cat >&5 <<_CSEOF
14438  
14439 < This file was extended by OOPSE $as_me 2.0, which was
14439 > This file was extended by OOPSE $as_me 3.0, which was
14440   generated by GNU Autoconf 2.59.  Invocation command line was
14441  
14442    CONFIG_FILES    = $CONFIG_FILES
# Line 8857 | Line 14499 | OOPSE config.status 2.0
14499  
14500   cat >>$CONFIG_STATUS <<_ACEOF
14501   ac_cs_version="\\
14502 < OOPSE config.status 2.0
14502 > OOPSE config.status 3.0
14503   configured by $0, generated by GNU Autoconf 2.59,
14504    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14505  
# Line 8962 | Line 14604 | do
14604    # Handling of arguments.
14605    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14606    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14607 +  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14608 +  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14609    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14610    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14611    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
# Line 9049 | Line 14693 | s,@PROGNAME@,$PROGNAME,;t t
14693   s,@ECHO_N@,$ECHO_N,;t t
14694   s,@ECHO_T@,$ECHO_T,;t t
14695   s,@LIBS@,$LIBS,;t t
9052 s,@PROGNAME@,$PROGNAME,;t t
9053 s,@debug@,$debug,;t t
14696   s,@build@,$build,;t t
14697   s,@build_cpu@,$build_cpu,;t t
14698   s,@build_vendor@,$build_vendor,;t t
# Line 9059 | Line 14701 | s,@CC@,$CC,;t t
14701   s,@host_cpu@,$host_cpu,;t t
14702   s,@host_vendor@,$host_vendor,;t t
14703   s,@host_os@,$host_os,;t t
14704 < s,@CC@,$CC,;t t
14705 < s,@CFLAGS@,$CFLAGS,;t t
14704 > s,@PROGNAME@,$PROGNAME,;t t
14705 > s,@debug@,$debug,;t t
14706 > s,@CXX@,$CXX,;t t
14707 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14708   s,@LDFLAGS@,$LDFLAGS,;t t
14709   s,@CPPFLAGS@,$CPPFLAGS,;t t
14710 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14710 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14711   s,@EXEEXT@,$EXEEXT,;t t
14712   s,@OBJEXT@,$OBJEXT,;t t
14713 < s,@CXX@,$CXX,;t t
14714 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14715 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14716 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14717 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14718 < s,@F90@,$F90,;t t
9075 < s,@F90FLAGS@,$F90FLAGS,;t t
9076 < s,@ac_ct_F90@,$ac_ct_F90,;t t
9077 < s,@PREPFLAG@,$PREPFLAG,;t t
9078 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
9079 < s,@F90LIBS@,$F90LIBS,;t t
9080 < s,@F90_FUNC@,$F90_FUNC,;t t
9081 < s,@F90_FUNC_@,$F90_FUNC_,;t t
9082 < s,@MOD@,$MOD,;t t
9083 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
9084 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
9085 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
9086 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14713 > s,@CC@,$CC,;t t
14714 > s,@CFLAGS@,$CFLAGS,;t t
14715 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14716 > s,@FC@,$FC,;t t
14717 > s,@FCFLAGS@,$FCFLAGS,;t t
14718 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14719   s,@CPP@,$CPP,;t t
14720   s,@EGREP@,$EGREP,;t t
9089 s,@LIBOBJS@,$LIBOBJS,;t t
9090 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
9091 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
9092 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14721   s,@LN_S@,$LN_S,;t t
14722   s,@SET_MAKE@,$SET_MAKE,;t t
14723   s,@RANLIB@,$RANLIB,;t t
14724   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
14725 < s,@YACC@,$YACC,;t t
14726 < s,@LEX@,$LEX,;t t
14727 < s,@LEXLIB@,$LEXLIB,;t t
14728 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14725 > s,@PERLINTERP@,$PERLINTERP,;t t
14726 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14727 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14728 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14729 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14730   s,@AR@,$AR,;t t
14731   s,@PS@,$PS,;t t
14732 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14733 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14734 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14735 + s,@FCLIBS@,$FCLIBS,;t t
14736 + s,@FC_FUNC@,$FC_FUNC,;t t
14737 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14738 + s,@MOD@,$MOD,;t t
14739 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14740 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14741 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14742 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14743 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14744 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14745 + s,@ZLIB@,$ZLIB,;t t
14746 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14747 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14748 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14749 + s,@LIBOBJS@,$LIBOBJS,;t t
14750 + s,@POW_LIB@,$POW_LIB,;t t
14751 + s,@CXXCPP@,$CXXCPP,;t t
14752 + s,@__func__@,$__func__,;t t
14753   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14754   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14755   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14756   s,@MPI_LIB@,$MPI_LIB,;t t
14757   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14758   s,@USE_MPI@,$USE_MPI,;t t
14759 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
14760 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
14761 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
14762 < s,@USE_SPRNG@,$USE_SPRNG,;t t
14763 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
14764 < s,@MKL_LIB@,$MKL_LIB,;t t
14765 < s,@MKL_INC@,$MKL_INC,;t t
9116 < s,@HAVE_MKL@,$HAVE_MKL,;t t
14759 > s,@USE_CGAL@,$USE_CGAL,;t t
14760 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14761 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
14762 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
14763 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
14764 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
14765 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14766   s,@DOXYGEN@,$DOXYGEN,;t t
14767   s,@DOT@,$DOT,;t t
14768   s,@DOC@,$DOC,;t t
# Line 9125 | Line 14774 | s,@FFLAGS@,$FFLAGS,;t t
14774   s,@OOPSE@,$OOPSE,;t t
14775   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14776   s,@SUBDIRS@,$SUBDIRS,;t t
9128 s,@FFLAGS@,$FFLAGS,;t t
14777   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14778   CEOF
14779  
# Line 9363 | Line 15011 | done
15011      rm -f $tmp/out
15012    fi
15013  
15014 +  # Run the commands associated with the file.
15015 +  case $ac_file in
15016 +    make/Makefile ) chmod 0755 scripts/* ;;
15017 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15018 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15019 +    scripts/filepp ) chmod 0755 scripts/* ;;
15020 +  esac
15021   done
15022   _ACEOF
15023   cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines